paper_trail_diff 0.11.0 → 0.13.0

data/lib/paper_trail_diff/scoped_analysis_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Selects both populations and checks their shared ceiling before analysis.
+  class ScopedAnalysisBuilder
+    #: (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped) -> void
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      scope, limit:, within:, historical_filter:, max_filter_versions:, include_deleted:,
+      analyzer:, deleted_analyzer:
+    )
+      raise ConfigurationError, 'limit: is required when selecting roots by scope' if limit.nil?
+      unless [true, false].include?(include_deleted)
+        raise ConfigurationError, 'include_deleted: must be true or false'
+      end
+
+      @selection = ScopedRootSelection.new(
+        scope, limit: limit, time_range: within.nil? ? nil : TimeRange.new(within),
+               historical_filter: historical_filter, max_filter_versions: max_filter_versions
+      )
+      @limit = limit
+      @include_deleted = include_deleted
+      @analyzer = analyzer
+      @deleted_analyzer = deleted_analyzer
+    end
+
+    #: () -> ScopedAnalysis
+    def call
+      selection = @selection.call
+      if @include_deleted && selection.records.length + selection.unreachable.length > @limit
+        raise BatchLimitExceededError, 'include_deleted: live and missing roots exceed limit:'
+      end
+
+      ScopedAnalysis.new(
+        analyses: @analyzer.call(selection.records), roots: selection.records,
+        unreachable: selection.unreachable,
+        deleted: @include_deleted ? @deleted_analyzer.call(selection.unreachable) : {}
+      )
+    end
+
+    # @rbs @selection: ScopedRootSelection
+    # @rbs @limit: Integer
+    # @rbs @include_deleted: bool
+    # @rbs @analyzer: untyped
+    # @rbs @deleted_analyzer: untyped
+  end
+end

data/lib/paper_trail_diff/scoped_root_selection.rb

@@ -26,6 +26,9 @@ module PaperTrailDiff
   # window. `where(status: 'published')` selects what is published now, which is
   # not the same set as what was published while the window was open.
   class ScopedRootSelection
+    PAGE_SIZE = 250
+    private_constant :PAGE_SIZE
+
     # A plain class rather than Data.define, which arrived in Ruby 3.2 while this
     # gem supports 3.1.
     class Result
@@ -40,16 +43,25 @@ module PaperTrailDiff
       end
     end
 
-    #: (untyped, time_range: TimeRange?, limit: Integer) -> void
-    def initialize(scope, time_range:, limit:)
+    #: (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer) -> void
+    def initialize(scope, time_range:, limit:, historical_filter: nil,
+                   max_filter_versions: HistoricalFilter::DEFAULT_VERSION_LIMIT)
       @scope = normalize_scope(scope)
       @time_range = time_range
       @limit = validate_limit(limit)
+      @historical_filter = unless historical_filter.nil?
+                             HistoricalFilter.new(base_class, predicate: historical_filter,
+                                                              time_range: time_range, limit: @limit,
+                                                              max_versions: max_filter_versions)
+                           end
     end
 
     #: () -> Result
     def call
+      return database_selection if @historical_filter.nil? && comparable_keys?
+
       candidates = versioned_ids
+      candidates = @historical_filter.call(candidates) if @historical_filter && candidates.any?
       return Result.new(records: [], unreachable: []) if candidates.empty?
 
       live = live_ids(candidates)
@@ -64,6 +76,47 @@ module PaperTrailDiff
     # @rbs @scope: untyped
     # @rbs @time_range: TimeRange?
     # @rbs @limit: Integer
+    # @rbs @historical_filter: untyped
+
+    # Leaves the candidate set in the database. Plucking every root changed in
+    # the window would cost memory and a statement proportional to all activity
+    # in the window -- not to the relation or `limit:` -- so a report on one
+    # record could read every id in a busy table. A subquery keeps the work
+    # bounded by what the relation and the deletions actually contain.
+    #: () -> Result
+    def database_selection
+      candidates = window_versions.select(:item_id)
+      Result.new(
+        records: selected_records(candidates),
+        unreachable: missing_ids.map { |id| identity(id) }.freeze
+      )
+    end
+
+    # Comparing the two columns in SQL needs them to share a type: PostgreSQL
+    # rejects an integer key against a string item_id outright.
+    #: () -> bool
+    def comparable_keys?
+      return false unless primary_key.is_a?(String)
+
+      item_id = version_class.columns_hash['item_id']&.type
+      key = base_class.columns_hash[primary_key]&.type
+      !item_id.nil? && item_id == key
+    end
+
+    # Changed in the window but without a row, found with an anti-join instead
+    # of comparing two plucked lists.
+    #: () -> Array[String]
+    def missing_ids
+      live = base_class.unscoped.select(primary_key)
+      window_versions.where.not(item_id: live).distinct.pluck(:item_id).map(&:to_s).uniq.sort
+    end
+
+    #: () -> untyped
+    def window_versions
+      relation = version_class.where(item_type: item_type)
+      range = @time_range
+      range ? range.scope(relation) : relation
+    end
 
     # Accepts a model class as readily as a relation: `Article` and
     # `Article.where(...)` both name a population, and `all` is what makes them
@@ -93,27 +146,67 @@ module PaperTrailDiff
     # version table alone so that it does not depend on rows still existing.
     #: () -> Array[String]
     def versioned_ids
-      relation = version_class.where(item_type: item_type)
-      range = @time_range
-      relation = range.scope(relation) if range
-      relation.distinct.pluck(:item_id).map(&:to_s).uniq
+      window_versions.distinct.pluck(:item_id).map(&:to_s).uniq
     end
 
     # Which of those candidates still have a row, asked without the relation's
     # conditions so that "filtered out" and "no longer exists" stay separable.
     #: (Array[String]) -> Array[String]
     def live_ids(candidates)
-      base_class.unscoped.where(primary_key => candidates).pluck(primary_key).map(&:to_s)
+      candidates.each_slice(PAGE_SIZE).flat_map do |slice|
+        base_class.unscoped.where(primary_key => slice).pluck(primary_key).map(&:to_s)
+      end
     end
 
-    # Loading one past the limit is what turns an oversized page into an error
-    # rather than a silently truncated report.
-    #: (Array[String]) -> Array[untyped]
+    # Deduplicate records rather than adding SQL DISTINCT: an otherwise valid
+    # relation may order by joined columns or select a PostgreSQL json column.
+    # Read bounded pages until the relation ends or too many unique roots appear.
+    #: (untyped) -> Array[untyped]
     def selected_records(live)
-      return [] if live.empty?
+      return [] if live.is_a?(Array) && live.empty?
+
+      records = {} #: Hash[untyped, untyped]
+      consumed = 0
+      loop do
+        page = record_page(live, consumed)
+        page.each { |record| records[record.id] ||= record }
+        reject_oversized!(records.length)
+        break if page.length < PAGE_SIZE
+
+        consumed += page.length
+      end
+      records.values.freeze
+    end
+
+    #: (untyped, Integer) -> Array[untyped]
+    def record_page(live, consumed)
+      count = page_limit(consumed)
+      return [] if count.zero?
+
+      # An id list or a candidate subquery; both read the same way in SQL.
+      conditions = { primary_key => live } #: Hash[untyped, untyped]
+      ordered_scope.where(conditions)
+                   .offset((@scope.offset_value || 0) + consumed).limit(count).to_a
+    end
+
+    # Preserve explicit ordering: SQL Server rejects duplicate ORDER BY columns,
+    # even when the extra ordering would only have served as a tie-breaker.
+    #: () -> untyped
+    def ordered_scope
+      return @scope unless @scope.order_values.empty?
+
+      @scope.order(primary_key => :asc)
+    end
+
+    #: (Integer) -> Integer
+    def page_limit(consumed)
+      remaining = @scope.limit_value
+      [remaining ? remaining - consumed : PAGE_SIZE, PAGE_SIZE].min
+    end
 
-      records = @scope.where(primary_key => live).limit(@limit + 1).to_a
-      return records.freeze unless records.length > @limit
+    #: (Integer) -> void
+    def reject_oversized!(count)
+      return unless count > @limit
 
       raise BatchLimitExceededError,
             "scope: selected more than #{@limit} roots; narrow the window or the " \

data/lib/paper_trail_diff/snapshot.rb

@@ -184,6 +184,15 @@ module PaperTrailDiff
       RecordReference.new(type: type, id: id)
     end
 
+    # A copy holding a different state for one association.
+    #: (String, AssociationSnapshot) -> RecordSnapshot
+    def with_association(name, association)
+      self.class.new(
+        type: type, id: id, attributes: attributes,
+        associations: associations.merge(name => association)
+      )
+    end
+
     #: () -> Hash[Symbol, untyped]
     def to_h
       value = {

data/lib/paper_trail_diff/snapshot_normalizer.rb

@@ -76,12 +76,37 @@ module PaperTrailDiff
     # Normalizes scalar attributes without traversing or loading associations.
     #: (untyped, tree: AssociationTree, path: String) -> snapshot_attributes
     def attributes_for(record, tree:, path:)
+      if record.is_a?(PreparedRecordState)
+        return from_state(record, tree: tree,
+                                  path: path).attributes
+      end
+
       reflections = reflections_for(record, tree, path)
       normalized_attributes(record, reflections, path)
     end
 
+    # Same exclusions as AR normalization, applied to an already typed state.
+    #: (PreparedRecordState, tree: AssociationTree, path: String, ?incoming: untyped, ?associations: snapshot_associations) -> RecordSnapshot
+    def from_state(state, tree:, path:, incoming: nil, associations: {})
+      model = state.model_class
+      @structural_columns[path] ||= @traversal.incoming_relationship_columns(incoming) if incoming
+      reflections = @traversal.reflections_for(model, tree, path: path)
+      excluded = @excluded_attributes[[model, path]] ||=
+        build_excluded_attributes(model, reflections, path)
+      snapshot = RecordSnapshot.new(
+        type: model.name, id: state.attributes[model.primary_key],
+        attributes: state.attributes.except(*excluded), associations: associations
+      )
+      pool_state(path, snapshot)
+    end
+
     private
 
+    #: (String, RecordSnapshot) -> RecordSnapshot
+    def pool_state(path, snapshot)
+      path.empty? ? snapshot : @pool.record(path, snapshot)
+    end
+
     # @rbs @tree: AssociationTree
     # @rbs @ignore_policy: IgnorePolicy
     # @rbs @traversal: AssociationTraversal
@@ -106,7 +131,7 @@ module PaperTrailDiff
     def normalized_attributes(record, reflections, path)
       attributes = record.attributes.dup
       excluded_attributes(record, reflections, path).each { |name| attributes.delete(name) }
-      attributes
+      StoredTimePrecision.apply(attributes, StoredTimePrecision.digits(record.class))
     end
 
     # Every input is fixed for one model class at one selected path, and the
@@ -127,7 +152,21 @@ module PaperTrailDiff
       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.freeze
+      (primary_keys + ignored + skipped_columns(model_class) +
+        relationship_columns(reflections) + structural).uniq.freeze
+    end
+
+    # `has_paper_trail skip:` columns are never written to a version, so history
+    # holds only their defaults. Compared with a live row they would report a
+    # change nobody recorded.
+    #: (untyped) -> Array[String]
+    def skipped_columns(model_class)
+      return [] unless Support.versioned?(model_class)
+
+      entries = Array(model_class.paper_trail_options[:skip]) #: Array[untyped]
+      entries.flat_map do |entry|
+        entry.is_a?(Hash) ? entry.keys.map(&:to_s) : [entry.to_s]
+      end
     end
 
     #: (Array[untyped]) -> Array[String]

data/lib/paper_trail_diff/step.rb

@@ -33,12 +33,17 @@ module PaperTrailDiff
       diff.empty?
     end
 
-    #: () -> Hash[Symbol, untyped]
-    def to_h
+    # The root event whose change this step reports.
+    #: () -> ActivityBoundary
+    def source_boundary = from_boundary
+
+    # The same shape as `ActivityStep#to_h`, so a consumer reads both step
+    # types alike; each boundary carries its own `version_id`.
+    #: (?metadata: bool) -> Hash[Symbol, untyped]
+    def to_h(metadata: false)
       {
-        from_version_id: from_version.id,
-        to_version_id: to_version&.id,
-        to_boundary: to_boundary.to_h,
+        from: from_boundary.to_h(metadata: metadata),
+        to: to_boundary.to_h(metadata: metadata),
         diff: diff.to_h
       }
     end

data/lib/paper_trail_diff/stored_time_precision.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # Matches time values to the precision PaperTrail actually stored.
+  #
+  # PaperTrail's JSON serializer, and a `json` or `jsonb` object column, write
+  # times through ActiveSupport's JSON encoder, which keeps only
+  # `ActiveSupport::JSON::Encoding.time_precision` fractional digits
+  # (milliseconds by default). The live row keeps the database's precision, so
+  # comparing the two would report every timestamp as changed even though
+  # nothing was edited. Truncating every side to the stored precision is
+  # idempotent, so values that came from history are unaffected and only the
+  # digits history could never have held are dropped.
+  module StoredTimePrecision
+    NANOSECOND_DIGITS = 9
+    JSON_COLUMN_TYPES = %i[json jsonb].freeze
+    private_constant :NANOSECOND_DIGITS, :JSON_COLUMN_TYPES
+
+    module_function
+
+    # Fractional digits a model's history keeps for times, or nil when the
+    # history is stored losslessly.
+    #: (untyped) -> Integer?
+    def digits(model_class)
+      return unless Support.versioned?(model_class)
+      return unless json_history?(model_class.paper_trail.version_class)
+
+      active_support = Object.const_get(:ActiveSupport) #: untyped
+      active_support.const_get(:JSON).const_get(:Encoding).time_precision
+    end
+
+    #: (Hash[untyped, untyped], Integer?) -> Hash[untyped, untyped]
+    def apply(attributes, digits)
+      return attributes unless digits
+
+      attributes.transform_values { |value| truncate(value, digits) }
+    end
+
+    #: (untyped, Integer) -> untyped
+    def truncate(value, digits)
+      return value unless value.is_a?(Time) && digits < NANOSECOND_DIGITS
+
+      # ActiveSupport's Time#change, which also serves TimeWithZone.
+      time = value #: untyped
+      step = 10**(NANOSECOND_DIGITS - [digits, 0].max) #: Integer
+      remainder = time.nsec % step
+      remainder.zero? ? time : time.change(nsec: time.nsec - remainder)
+    end
+
+    #: (untyped) -> bool
+    def json_history?(version_class)
+      columns = version_class.columns_hash
+      json_column = %w[object object_changes].any? do |name|
+        JSON_COLUMN_TYPES.include?(columns[name]&.type)
+      end
+      json_column || json_serializer?
+    end
+    private_class_method :json_history?
+
+    #: () -> bool
+    def json_serializer?
+      paper_trail = Object.const_get(:PaperTrail) #: untyped
+      paper_trail.serializer.equal?(paper_trail.const_get(:Serializers).const_get(:JSON))
+    end
+    private_class_method :json_serializer?
+  end
+end

data/lib/paper_trail_diff/support.rb

@@ -8,15 +8,13 @@ module PaperTrailDiff
 
     #: (untyped) -> untyped
     def immutable_copy(value)
-      return value if value.frozen?
-
       case value
       when Hash
         immutable_hash(value)
       when Array
         value.map { |item| immutable_copy(item) }.freeze
       else
-        duplicate_and_freeze(value)
+        value.frozen? ? value : duplicate_and_freeze(value)
       end
     end
 
@@ -94,6 +92,18 @@ module PaperTrailDiff
       model_class.respond_to?(:paper_trail_options) && !model_class.paper_trail_options.nil?
     end
 
+    # `versions.item_id` is often a string column -- PaperTrail's setup for UUID
+    # keys -- while the model's own key is an integer. An id read from history
+    # is cast to the key's type, or the same record read once from history and
+    # once from its live row would count as two.
+    #: (untyped, untyped) -> untyped
+    def record_id(model_class, id)
+      key = model_class.primary_key
+      return id if id.nil? || !key.is_a?(String)
+
+      model_class.type_for_attribute(key).cast(id)
+    end
+
     #: (untyped) -> bool
     def sequential_id?(id)
       id.is_a?(Integer) || id.to_s.match?(/\A\d+\z/)

data/lib/paper_trail_diff/time_activity_timeline_builder.rb

@@ -28,7 +28,7 @@ module PaperTrailDiff
     #: () -> Analysis
     def analyze
       history, plan, closing, closing_snapshot, captured_at = history_and_versions
-      final = closing_snapshot || history.last_snapshot
+      final = plan.closes_on_destroy ? nil : closing_snapshot || history.last_snapshot
       Analysis.new(
         diff: Engine.compare(history.first_snapshot, final),
         timeline: ActivityRootSteps.call(
@@ -52,7 +52,10 @@ module PaperTrailDiff
     #: () -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
     def history_and_versions
       plan = @range.select_plan(context_required: !@tree.empty?)
-      return [ActivityHistory.empty, plan, nil, nil, nil] if plan.reconstruction_versions.empty?
+      reject_live_habtm! if plan.closing_record
+      if plan.reconstruction_versions.empty? && !plan.closing_record
+        return [ActivityHistory.empty, plan, nil, nil, nil]
+      end
 
       # A window closing on current state runs to the instant it is captured,
       # not to the last root version, or descendants that moved after that
@@ -60,6 +63,11 @@ module PaperTrailDiff
       history_for(plan, plan.closing_record ? Time.now.utc : nil)
     end
 
+    #: () -> void
+    def reject_live_habtm!
+      AssociationTraversal.new(@tree).reject_live_habtm_activity!(@record.class)
+    end
+
     #: (RootVersionPlan, untyped) -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
     def history_for(plan, captured_at)
       root_versions = plan.reconstruction_versions
@@ -69,7 +77,7 @@ module PaperTrailDiff
         return [ActivityHistory.empty, plan, nil, nil, nil]
       end
 
-      history = build_history(root_versions, events)
+      history = build_history(root_versions, events, current: plan.closing_record)
       snapshot = current_snapshot(plan)
       closing = closing_step(history, selected.last, plan, captured_at, snapshot)
       [history, plan, closing, snapshot, captured_at]
@@ -91,12 +99,15 @@ module PaperTrailDiff
       collect_events(root_versions, range_end: captured_at)
     end
 
-    #: (Array[untyped], Array[ActivityEvent]) -> ActivityHistory
-    def build_history(root_versions, events)
+    # Events after the last root version read the root from the live record
+    # when the window closes on it, as an explicit `to: record` range does.
+    #: (Array[untyped], Array[ActivityEvent], ?current: untyped) -> ActivityHistory
+    def build_history(root_versions, events, current: nil)
       ActivityHistoryBuilder.new(
         root_versions,
         events,
         @snapshotter,
+        current: current,
         include_step: ->(event) { @range.include?(event.version) },
         snapshots: @retain
       ).call
@@ -150,13 +161,13 @@ module PaperTrailDiff
     # have moved since it.
     #: (ActivityHistory, untyped, untyped, RecordSnapshot?) -> ActivityStep?
     def current_step(history, record, captured_at, snapshot)
-      previous = history.steps.last&.to_boundary
+      previous = history.last_boundary
       return unless previous
 
       ActivityStep.between(
         from_boundary: previous,
         to_boundary: ActivityBoundary.current(record, captured_at: captured_at),
-        from_snapshot: history.last_snapshot, to_snapshot: snapshot, retain: @retain
+        from_snapshot: history.last_event_snapshot, to_snapshot: snapshot, retain: @retain
       )
     end
 
@@ -184,6 +195,7 @@ module PaperTrailDiff
         root_versions: root_versions,
         tree: @tree,
         traversal: AssociationTraversal.new(@tree),
+        prepared: (@snapshotter.activity_index if @snapshotter.respond_to?(:activity_index)),
         range_start: @range.begin_time,
         range_end: range_end || root_versions.last
       ).call

data/lib/paper_trail_diff/time_range.rb

@@ -41,14 +41,34 @@ module PaperTrailDiff
     #: (untyped) -> untyped
     def trailing_scope(relation)
       column = relation.klass.arel_table[:created_at]
-      predicate = exclude_end? ? column.gteq(end_time) : column.gt(end_time)
-      relation.where(predicate)
+      relation.where(after_end(column))
+    end
+
+    # Each item's earliest version after the range, keyed by item id. One row
+    # per item comes back from a NOT EXISTS rather than a window function, so
+    # the query stays portable; a timestamp tie keeps the lower id.
+    #: (untyped) -> Hash[String, untyped]
+    def first_trailing_versions(relation)
+      table = relation.klass.arel_table
+      first_after = VersionQuery.no_earlier_version(table) do |earlier|
+        after_end(earlier[:created_at])
+      end
+      versions = trailing_scope(relation).where(first_after)
+                                         .reorder(created_at: :asc, id: :asc).to_a
+      first = {} #: Hash[String, untyped]
+      versions.each { |version| first[version.item_id.to_s] ||= version }
+      first
     end
 
     private
 
     # @rbs @exclude_end: bool
 
+    #: (untyped) -> untyped
+    def after_end(column)
+      exclude_end? ? column.gteq(end_time) : column.gt(end_time)
+    end
+
     #: () -> Range[Time]
     def query_range
       exclude_end? ? (begin_time...end_time) : (begin_time..end_time)

data/lib/paper_trail_diff/time_version_range.rb

@@ -12,14 +12,9 @@ module PaperTrailDiff
       @live_endpoint = live_endpoint
     end
 
-    #: (?context_required: bool) -> Array[untyped]
-    def select(context_required: false)
-      select_plan(context_required: context_required).versions
-    end
-
     #: (?context_required: bool) -> RootVersionPlan
     def select_plan(context_required: false)
-      relation = versions_relation
+      relation = Endpoint.versions(@record)
       in_range = ordered(@time_range.scope(relation).to_a)
       RootVersionSelection.new(
         in_range: in_range,
@@ -40,15 +35,6 @@ module PaperTrailDiff
     # @rbs @version_scope: untyped
     # @rbs @live_endpoint: untyped
 
-    #: () -> untyped
-    def versions_relation
-      association_name = @record.class.versions_association_name
-      @record.public_send(association_name)
-    rescue NoMethodError => e
-      message = 'record does not expose a PaperTrail version history'
-      raise InvalidTimelineRangeError, message, cause: e
-    end
-
     #: (untyped) -> untyped
     def trailing_version(relation)
       @time_range.trailing_scope(relation).reorder(created_at: :asc, id: :asc).first

data/lib/paper_trail_diff/timeline_builder.rb

@@ -4,15 +4,15 @@
 module PaperTrailDiff
   # Selects and compares a chronological slice of a record's version history.
   class TimelineBuilder
-    #: (untyped, from: untyped, to: untyped, snapshotter: untyped, ?within: untyped, ?versions: Array[untyped]?, ?version_scope: untyped, ?plan: RootVersionPlan?, ?live_endpoint: untyped) -> void
+    #: (untyped, from: untyped, to: untyped, snapshotter: untyped, ?within: untyped, ?version_scope: untyped, ?plan: RootVersionPlan?, ?live_endpoint: untyped) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
-      record, from:, to:, snapshotter:, within: nil, versions: nil, version_scope: nil, plan: nil,
+      record, from:, to:, snapshotter:, within: nil, version_scope: nil, plan: nil,
       live_endpoint: nil
     )
       @record = record
       @range = TimelineRange.new(
         record, from: from, to: to, within: within,
-                versions: versions, version_scope: version_scope, plan: plan,
+                version_scope: version_scope, plan: plan,
                 live_endpoint: live_endpoint
       )
       @snapshotter = snapshotter
@@ -48,7 +48,8 @@ module PaperTrailDiff
       versions = plan.versions
       @snapshotter.prepare(@record, versions) if @snapshotter.respond_to?(:prepare)
       steps = build_steps(plan)
-      [steps, @snapshotter.call(versions.first), @snapshotter.call(plan.final_endpoint)]
+      final = plan.closes_on_destroy ? nil : @snapshotter.call(plan.final_endpoint)
+      [steps, @snapshotter.call(versions.first), final]
     end
 
     #: (RootVersionPlan) -> Array[Step]