paper_trail_diff 0.13.1 → 0.14.0

data/lib/paper_trail_diff/version_range.rb

@@ -4,8 +4,8 @@
 module PaperTrailDiff
   # Selects an inclusive, chronological range from a record's root versions.
   class VersionRange
-    #: (untyped, from: untyped, to: untyped, ?version_scope: untyped) -> void
-    def initialize(record, from:, to:, version_scope: nil)
+    #: (untyped, from: untyped, to: untyped, version_scope: untyped) -> void
+    def initialize(record, from:, to:, version_scope:)
       @record = record
       @from = from
       @to = to
@@ -51,11 +51,9 @@ module PaperTrailDiff
 
     #: (untyped, ?through: untyped, ?live_endpoint: untyped) -> RootVersionPlan
     def select_plan(relation, through: nil, live_endpoint: nil)
-      in_range = ordered(relation.to_a.select do |version|
-        next false if Support.compare_versions(@from, version).positive?
-        next true unless through
-
-        Support.compare_versions(version, through) <= 0
+      in_range = ordered(relation.select do |version|
+        Support.compare_versions(@from, version) <= 0 &&
+          (!through || Support.compare_versions(version, through) <= 0)
       end)
       RootVersionSelection.new(
         in_range: in_range,
@@ -73,21 +71,16 @@ module PaperTrailDiff
 
     #: (untyped, untyped, boundary: Symbol) -> void
     def validate_boundary!(requested, relation, boundary:)
-      Endpoint.validate!(requested)
       return if valid_boundary?(requested, relation)
 
-      raise InvalidTimelineRangeError, "`#{boundary}` version is not in the record history"
-    rescue InvalidEndpointError, NoMethodError
       raise InvalidTimelineRangeError, "`#{boundary}` version is not in the record history"
     end
 
+    # The relation holds only this record's versions, so finding the id there
+    # also settles which record the version belongs to.
     #: (untyped, untyped) -> bool
     def valid_boundary?(requested, relation)
-      expected_identity = [@record.class.base_class.name.to_s, @record.id.to_s]
-      Endpoint.version?(requested) &&
-        requested.instance_of?(relation.klass) &&
-        Endpoint.identity(requested) == expected_identity &&
-        relation.where(id: requested.id).exists?
+      requested.instance_of?(relation.klass) && relation.exists?(requested.id)
     end
   end
 end

data/lib/paper_trail_diff/version_scope_filter.rb

@@ -14,13 +14,21 @@ module PaperTrailDiff
 
     #: (untyped, Array[untyped]) -> Array[untyped]
     def call(relation, in_range)
+      chosen = chosen_ids(relation)
+      return in_range unless chosen
+
+      in_range.select { |version| chosen.include?(version.id) }
+    end
+
+    # The ids of the versions the scope keeps, or nil when there is no scope.
+    #: (untyped) -> Set[untyped]?
+    def chosen_ids(relation)
       scope = @scope
-      return in_range unless scope
+      return unless scope
 
       # A narrowed relation is the expected return. Active Support also gives
       # `pluck` to plain enumerables, so an array of versions works too.
-      chosen = Set.new(scope.call(relation).pluck(:id))
-      in_range.select { |version| chosen.include?(version.id) }
+      Set.new(scope.call(relation).pluck(:id))
     end
 
     private

data/lib/paper_trail_diff.rb

@@ -12,7 +12,10 @@ require_relative 'paper_trail_diff/instrumentation'
 require_relative 'paper_trail_diff/errors'
 require_relative 'paper_trail_diff/configuration'
 require_relative 'paper_trail_diff/endpoint'
+require_relative 'paper_trail_diff/recorded_class'
 require_relative 'paper_trail_diff/association_traversal'
+require_relative 'paper_trail_diff/scope_ranking'
+require_relative 'paper_trail_diff/scope_condition'
 require_relative 'paper_trail_diff/batch_safety'
 require_relative 'paper_trail_diff/traversal_preparer'
 require_relative 'paper_trail_diff/association_discovery'
@@ -30,6 +33,7 @@ require_relative 'paper_trail_diff/traversal'
 require_relative 'paper_trail_diff/collection_comparator'
 require_relative 'paper_trail_diff/nested_comparator'
 require_relative 'paper_trail_diff/engine'
+require_relative 'paper_trail_diff/habtm_transaction_owners'
 require_relative 'paper_trail_diff/historical_association_reifier'
 require_relative 'paper_trail_diff/prepared_record_index'
 require_relative 'paper_trail_diff/direct_record_state_loader'
@@ -56,6 +60,7 @@ require_relative 'paper_trail_diff/snapshot_normalizer'
 require_relative 'paper_trail_diff/historical_snapshot_store'
 require_relative 'paper_trail_diff/timeline_snapshot_provider'
 require_relative 'paper_trail_diff/activity_event_record_resolver'
+require_relative 'paper_trail_diff/recorded_changes'
 require_relative 'paper_trail_diff/activity_event_route_finder'
 require_relative 'paper_trail_diff/activity_relationship'
 require_relative 'paper_trail_diff/activity_collection_route_change'
@@ -77,6 +82,8 @@ require_relative 'paper_trail_diff/analysis_batch'
 require_relative 'paper_trail_diff/deleted_analysis_batch'
 require_relative 'paper_trail_diff/scoped_analysis'
 require_relative 'paper_trail_diff/historical_filter'
+require_relative 'paper_trail_diff/association_activity_edge'
+require_relative 'paper_trail_diff/association_activity_selection'
 require_relative 'paper_trail_diff/scoped_root_selection'
 require_relative 'paper_trail_diff/scoped_analysis_builder'
 require_relative 'paper_trail_diff/batched_root_analyzer'
@@ -89,6 +96,7 @@ require_relative 'paper_trail_diff/timeline_builder'
 require_relative 'paper_trail_diff/activity_range'
 require_relative 'paper_trail_diff/activity_event'
 require_relative 'paper_trail_diff/activity_child_candidate_loader'
+require_relative 'paper_trail_diff/activity_target_candidate_loader'
 require_relative 'paper_trail_diff/activity_version_collector'
 require_relative 'paper_trail_diff/activity_snapshot_sequence'
 require_relative 'paper_trail_diff/activity_history'
@@ -278,7 +286,9 @@ module PaperTrailDiff # rubocop:disable Metrics/ModuleLength
     end
 
     # Analyzes every root the relation reaches whose history moved inside the
-    # window. Joined duplicates are read in bounded pages and analyzed once.
+    # window. With `activity: true`, a change to a record on one of the
+    # requested association paths also counts, because the activity timeline
+    # reports it. Joined duplicates are read in bounded pages and analyzed once.
     #
     # `limit:` is required and exceeding it raises. Selection moves into the gem
     # here. The relation's own limit/offset select the live page; this separate
@@ -328,7 +338,8 @@ module PaperTrailDiff # rubocop:disable Metrics/ModuleLength
       )
     end
 
-    # Recent root and selected-child activity through the current saved state.
+    # Recent root and selected-child activity through the current saved state,
+    # for every root that changed or whose requested associations did.
     # Historical windows remain explicit on analyze_scope; this entry point is
     # deliberately named for a report through now rather than an as-of query.
     #: (untyped, since: untyped, limit: Integer, ?associations: Array[String | Symbol], ?ignore: ignore_option, ?snapshots: bool, ?group: Symbol?, ?include_deleted: bool, ?historical_filter: untyped, ?max_filter_versions: Integer, ?allow_expensive: bool) -> ScopedAnalysis
@@ -390,5 +401,23 @@ module PaperTrailDiff # rubocop:disable Metrics/ModuleLength
 
       NestedComparator.call(change, to_value)
     end
+
+    # Reads what PaperTrail recorded with one version: its `object_changes`,
+    # typed by the version's model, as `{ "title" => <from "Draft" to "Published"> }`.
+    #
+    #   versions = PaperTrail::Version.where(id: steps.map { _1.source_boundary.version_id })
+    #   versions.to_h { [_1.id, PaperTrailDiff.recorded_changes(_1)] }
+    #
+    # A step's diff compares the states before and after an event, so it also
+    # includes anything saved without a version in between; this does not.
+    # Returns nil when nothing was recorded (no `object_changes` column, or no
+    # value for this version), which differs from a recorded empty hash. Unlike
+    # PaperTrail's `version.changeset`, it never loads the record, so it costs no
+    # query per version and still types a deleted record's changes. `ignore:`
+    # takes attribute names, as an array, and defaults to `updated_at`.
+    #: (untyped, ?ignore: Array[String | Symbol]) -> Hash[String, ValueChange]?
+    def recorded_changes(version, ignore: DEFAULT_IGNORED_ATTRIBUTES)
+      RecordedChanges.call(version, ignore: ignore)
+    end
   end
 end

data/sig/generated/paper_trail_diff/activity_belongs_to_event_applier.rbs

@@ -17,6 +17,11 @@ module PaperTrailDiff
 
     @route_finder: ActivityEventRouteFinder
 
+    # An edit can move a target into or out of a scope, which a replacement
+    # in place cannot show, so a scoped route's branch is read again instead.
+    # : (Array[Array[untyped]]) -> bool
+    def scoped_route?: (Array[Array[untyped]]) -> bool
+
     # : (Array[untyped], untyped, SnapshotNormalizer, untyped, untyped) -> RecordSnapshot?
     def normalized_route_record: (Array[untyped], untyped, SnapshotNormalizer, untyped, untyped) -> RecordSnapshot?
 
@@ -29,8 +34,11 @@ module PaperTrailDiff
     # : (Array[RecordSnapshot], untyped, RecordSnapshot?) -> [Array[RecordSnapshot], bool]
     def replace_existing_target: (Array[RecordSnapshot], untyped, RecordSnapshot?) -> [ Array[RecordSnapshot], bool ]
 
-    # : (untyped, RecordSnapshot?) -> String
-    def replacement_type: (untyped, RecordSnapshot?) -> String
+    # The target is matched by id within its table rather than by type name.
+    # Without `item_subtype`, a version names only the STI base class, and a
+    # row whose type changes is replaced by a record of another class.
+    # : (RecordSnapshot, untyped) -> bool
+    def same_table?: (RecordSnapshot, untyped) -> bool
 
     # : (untyped) -> untyped
     def endpoint_model_class: (untyped) -> untyped

data/sig/generated/paper_trail_diff/activity_collection_event_applier.rbs

@@ -25,6 +25,11 @@ module PaperTrailDiff
     # : (RecordSnapshot, Array[untyped], untyped, ActivitySnapshotDelta?, Array[untyped], SnapshotNormalizer, Array[untyped], ?direct: bool) -> RecordSnapshot
     def apply_route: (RecordSnapshot, Array[untyped], untyped, ActivitySnapshotDelta?, Array[untyped], SnapshotNormalizer, Array[untyped], ?direct: bool) -> RecordSnapshot
 
+    # Any edit can move a record into or out of a scope, so a scoped route's
+    # branch is read again from history instead.
+    # : (Array[Array[untyped]]) -> bool
+    def scoped_route?: (Array[Array[untyped]]) -> bool
+
     # : (Array[Array[untyped]], untyped) -> bool
     def unsafe_through_membership_event?: (Array[Array[untyped]], untyped) -> bool
 

data/sig/generated/paper_trail_diff/activity_collection_record_updater.rbs

@@ -19,6 +19,11 @@ module PaperTrailDiff
 
     @relationship: ActivityRelationship
 
+    # A row whose STI type changed is the same row under a new identity, so it
+    # is found by id among the records of its table.
+    # : (AssociationSnapshot, untyped) -> Integer?
+    def retyped_position: (AssociationSnapshot, untyped) -> Integer?
+
     # : (Array[RecordSnapshot], Integer?, RecordSnapshot?) -> Array[RecordSnapshot]
     def replacement_records: (Array[RecordSnapshot], Integer?, RecordSnapshot?) -> Array[RecordSnapshot]
   end

data/sig/generated/paper_trail_diff/activity_event_record_resolver.rbs

@@ -45,6 +45,13 @@ module PaperTrailDiff
     # : (untyped) -> PreparedRecordState?
     def direct_record_after: (untyped) -> PreparedRecordState?
 
+    # Without `item_subtype` a version names only the STI base class, and a
+    # change can move the row to another class, so the type the row holds
+    # after the change decides. A type that names no class has no direct
+    # state; the caller falls back to reifying the record.
+    # : (untyped, Hash[untyped, untyped]) -> untyped
+    def class_after: (untyped, Hash[untyped, untyped]) -> untyped
+
     # : (untyped) -> untyped
     def prepared_changeset: (untyped) -> untyped
 

data/sig/generated/paper_trail_diff/activity_range.rbs

@@ -21,14 +21,18 @@ module PaperTrailDiff
     # : () -> bool
     def current_end?: () -> bool
 
+    # Whether the state a version recorded after its change held inside the
+    # range. A range ending at a version ends at the state before it, so the
+    # change that version records is past the end, unlike #include?.
+    # : (untyped, untyped) -> bool
+    def recorded_before_end?: (untyped, untyped) -> bool
+
     private
 
     @end_boundary: untyped
 
     @end_key: Array[untyped]?
 
-    @start_boundary: untyped
-
     @start_key: Array[untyped]?
 
     @start_time: untyped

data/sig/generated/paper_trail_diff/activity_relationship.rbs

@@ -11,6 +11,9 @@ module PaperTrailDiff
 
     private
 
+    # : (untyped, untyped, Symbol) -> bool
+    def sti_member?: (untyped, untyped, Symbol) -> bool
+
     # : (untyped, untyped, state: Symbol) -> Array[String]
     def relationship_owner_values: (untyped, untyped, state: Symbol) -> Array[String]
 

data/sig/generated/paper_trail_diff/activity_root_snapshot_refresher.rbs

@@ -36,6 +36,8 @@ module PaperTrailDiff
     # : (untyped) -> Array[String]
     def unsupported_branches: (untyped) -> Array[String]
 
+    # A polymorphic target's class is known only per record, so it cannot be
+    # checked here; a target that is not versioned raises when it is read.
     # : (untyped) -> bool
     def direct_versioned_reflection?: (untyped) -> bool
 

data/sig/generated/paper_trail_diff/activity_target_candidate_loader.rbs

@@ -0,0 +1,79 @@
+# Generated from lib/paper_trail_diff/activity_target_candidate_loader.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Loads the `belongs_to` targets owners pointed at during one activity range:
+  # at its start and after each change inside it.
+  #
+  # PT-AT records a version's foreign keys as they stood after its change, so
+  # the target at the start comes from the latest version before it, and the
+  # version a range ends at names a target only after the range. Reading only
+  # the owners' versions inside the range misses a target whose owner did not
+  # change there -- an author renamed under an article nobody edited.
+  class ActivityTargetCandidateLoader
+    # A plain class rather than Data.define, which arrived in Ruby 3.2 while this
+    # gem supports 3.1.
+    class Row
+      attr_reader owner_id: untyped
+
+      attr_reader foreign_key_id: untyped
+
+      attr_reader foreign_type: String?
+
+      attr_reader created_at: untyped
+
+      attr_reader event: String?
+
+      attr_reader version_id: untyped
+
+      # : (untyped, untyped, String?, ?untyped, ?String?, ?untyped) -> void
+      def initialize: (untyped, untyped, String?, ?untyped, ?String?, ?untyped) -> void
+    end
+
+    # : (untyped, Array[untyped], untyped, ActivityRange) -> void
+    def initialize: (untyped, Array[untyped], untyped, ActivityRange) -> void
+
+    # : () -> Array[Row]
+    def call: () -> Array[Row]
+
+    # One shared query keeps the owner and timestamp needed to partition a
+    # batch's candidates back into each root's exact activity range.
+    # : () -> Array[Row]
+    def historical_rows: () -> Array[Row]
+
+    # The live row holds the state at a range that ends at the current record.
+    # : () -> Array[Row]
+    def current_rows: () -> Array[Row]
+
+    private
+
+    @owner_class: untyped
+
+    @owner_ids: Array[untyped]
+
+    @range: ActivityRange
+
+    @reflection: untyped
+
+    # : (untyped) -> untyped
+    def historical_relation: (untyped) -> untyped
+
+    # : (untyped, untyped) -> Array[Array[untyped]]
+    def historical_columns: (untyped, untyped) -> Array[Array[untyped]]
+
+    # A polymorphic key names its target in a type column; any other names it
+    # in the reflection, so no type is read. Like the history, the live read
+    # takes owners of every class under the base class: a batch can ask for
+    # the owners of an association through one subclass.
+    # : () -> Array[Array[untyped]]
+    def live_rows: () -> Array[Array[untyped]]
+
+    # : (untyped) -> VersionAssociationCandidateScope
+    def candidate_scope: (untyped) -> VersionAssociationCandidateScope
+
+    # : () -> untyped
+    def association_class: () -> untyped
+
+    # : () -> bool
+    def composite_foreign_key?: () -> bool
+  end
+end

data/sig/generated/paper_trail_diff/activity_timeline_builder.rbs

@@ -5,8 +5,8 @@ module PaperTrailDiff
   class ActivityTimelineBuilder
     include ActivityGrouping
 
-    # : (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, ?snapshots: bool, ?group: Symbol?) -> void
-    def initialize: (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, ?snapshots: bool, ?group: Symbol?) -> void
+    # : (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, snapshots: bool, group: Symbol?) -> void
+    def initialize: (untyped, range: TimelineRange, tree: AssociationTree, snapshotter: untyped, snapshots: bool, group: Symbol?) -> void
 
     # : () -> Array[ActivityStep]
     def build: () -> Array[ActivityStep]
@@ -17,8 +17,6 @@ module PaperTrailDiff
 
     private
 
-    @from: untyped
-
     @range: TimelineRange
 
     @record: untyped
@@ -37,7 +35,8 @@ module PaperTrailDiff
     # Every boundary in the span, filtered out or not. A filter narrows where the
     # span starts and ends, but the sequence inside it stays complete: dropping
     # boundaries would fold the changes they carried into a neighbouring step and
-    # credit them to whoever made that one.
+    # credit them to whoever made that one. A filter that keeps no version
+    # leaves no span, as it does for a checkpoint timeline.
     # : () -> Array[ActivityStep]
     def build_between_versions: () -> Array[ActivityStep]
 
@@ -52,6 +51,12 @@ module PaperTrailDiff
     # : () -> [RootVersionPlan, Array[ActivityEvent], ActivityHistory, RecordSnapshot?, ActivityBoundary?]
     def current_history: () -> [ RootVersionPlan, Array[ActivityEvent], ActivityHistory, RecordSnapshot?, ActivityBoundary? ]
 
+    # Without a closing boundary nothing reads the events or the closing pair,
+    # so their mutations cannot change an answer.
+    # mutant:disable
+    # : (RootVersionPlan) -> [RootVersionPlan, Array[ActivityEvent], ActivityHistory, RecordSnapshot?, ActivityBoundary?]
+    def empty_history: (RootVersionPlan) -> [ RootVersionPlan, Array[ActivityEvent], ActivityHistory, RecordSnapshot?, ActivityBoundary? ]
+
     # : () -> [RecordSnapshot?, untyped]
     def capture_current: () -> [ RecordSnapshot?, untyped ]
 
@@ -66,6 +71,7 @@ module PaperTrailDiff
 
     # Appends the transition into an explicit closing boundary, which is either
     # a requested current record or the absence a final root destroy leaves.
+    # Either follows the root versions, which are themselves events.
     # : (ActivityHistory, Array[ActivityEvent], ActivityBoundary?, RecordSnapshot?) -> Array[ActivityStep]
     def activity_steps: (ActivityHistory, Array[ActivityEvent], ActivityBoundary?, RecordSnapshot?) -> Array[ActivityStep]
 

data/sig/generated/paper_trail_diff/activity_version_collector.rbs

@@ -3,8 +3,8 @@
 module PaperTrailDiff
   # Collects root and selected-descendant versions relevant to one root history range.
   class ActivityVersionCollector
-    # : (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?range_start: untyped, ?range_end: untyped, ?prepared: PreparedActivityIndex?) -> void
-    def initialize: (untyped, root_versions: Array[untyped], tree: AssociationTree, traversal: AssociationTraversal, ?range_start: untyped, ?range_end: untyped, ?prepared: PreparedActivityIndex?) -> void
+    # : (untyped, root_versions: Array[untyped], tree: AssociationTree, ?range_start: untyped, ?range_end: untyped, ?prepared: PreparedActivityIndex?) -> void
+    def initialize: (untyped, root_versions: Array[untyped], tree: AssociationTree, ?range_start: untyped, ?range_end: untyped, ?prepared: PreparedActivityIndex?) -> void
 
     # : () -> Array[ActivityEvent]
     def call: () -> Array[ActivityEvent]
@@ -37,17 +37,23 @@ module PaperTrailDiff
     # : (Hash[Symbol, untyped], untyped, String) -> Hash[String, untyped]
     def through_groups: (Hash[Symbol, untyped], untyped, String) -> Hash[String, untyped]
 
+    # Every target the owners pointed at in the range, not only those their own
+    # changes there recorded: an author renamed under an article nobody edited
+    # is still that article's activity.
     # : (untyped, Array[untyped], untyped) -> Hash[String, untyped]
     def belongs_to_groups: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
 
+    # : (untyped, Array[untyped], untyped) -> Hash[String, untyped]
+    def unprepared_belongs_to_groups: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
+
     # : (untyped, Array[untyped], untyped) -> Hash[String, untyped]
     def direct_child_groups: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
 
     # : (untyped, Array[untyped], untyped) -> Hash[String, untyped]
     def habtm_groups: (untyped, Array[untyped], untyped) -> Hash[String, untyped]
 
-    # : (Array[untyped], untyped) -> Hash[String, untyped]
-    def identity_groups: (Array[untyped], untyped) -> Hash[String, untyped]
+    # : (Array[untyped], untyped) ?{ (untyped, untyped) -> bool } -> Hash[String, untyped]
+    def identity_groups: (Array[untyped], untyped) ?{ (untyped, untyped) -> bool } -> Hash[String, untyped]
 
     # : (untyped, Array[untyped]) -> Hash[Symbol, untyped]
     def group: (untyped, Array[untyped]) -> Hash[Symbol, untyped]

data/sig/generated/paper_trail_diff/association_activity_edge.rbs

@@ -0,0 +1,148 @@
+# Generated from lib/paper_trail_diff/association_activity_edge.rb with RBS::Inline
+
+module PaperTrailDiff
+  # One association edge read backwards for a window: given the ids of records
+  # on its far side, the query for the owners that held them while it was open.
+  #
+  # `filter_type` is the type of the column those ids are compared with, and
+  # `type` that of the owner column the query selects, so a caller can keep a
+  # subquery only where the database can compare the two.
+  class AssociationActivityEdge
+    attr_reader column: untyped
+
+    attr_reader type: Symbol?
+
+    attr_reader filter_type: Symbol?
+
+    # : (untyped, TimeRange?) -> void
+    def initialize: (untyped, TimeRange?) -> void
+
+    # : () -> bool
+    def available?: () -> bool
+
+    # : (untyped) -> untyped
+    def relation: (untyped) -> untyped
+
+    private
+
+    @owner: untyped
+
+    @reflection: untyped
+
+    @time_range: TimeRange?
+
+    # The window plus the state when it opened, which is what
+    # VersionAssociationCandidateScope selects for an activity analysis.
+    # : (untyped, untyped) -> untyped
+    def candidates: (untyped, untyped) -> untyped
+
+    # : (untyped, String) -> Symbol?
+    def column_type: (untyped, String) -> Symbol?
+
+    # A relation is compared as its SQL; ids are compared as values.
+    # : (untyped) -> untyped
+    def arel_value: (untyped) -> untyped
+
+    # The owners a child pointed at when the window opened or after a change
+    # inside it, as PT-AT recorded them on the child's own versions.
+    class Child < AssociationActivityEdge
+      # : (untyped, TimeRange?) -> void
+      def initialize: (untyped, TimeRange?) -> void
+
+      # : (untyped) -> untyped
+      def relation: (untyped) -> untyped
+
+      private
+
+      @associations: untyped
+
+      @versions: untyped
+
+      # : () -> Array[String?]
+      def owner_types: () -> Array[String?]
+    end
+
+    # The owners that pointed at a target when the window opened or after a
+    # change inside it, as PT-AT recorded them on the owners' versions.
+    class BelongsTo < AssociationActivityEdge
+      # : (untyped, TimeRange?, ?foreign_type: String?) -> void
+      def initialize: (untyped, TimeRange?, ?foreign_type: String?) -> void
+
+      # The types a polymorphic key's rows name, the only way to know its targets.
+      # : () -> Array[String]
+      def target_types: () -> Array[String]
+
+      # The owners that pointed at a target of this edge's type when the window
+      # opened or after a change inside it, whichever target that was.
+      # : () -> untyped
+      def typed_owners: () -> untyped
+
+      # : (untyped) -> untyped
+      def relation: (untyped) -> untyped
+
+      private
+
+      @associations: untyped
+
+      @foreign_type: String?
+
+      @versions: untyped
+
+      # : (Hash[Symbol, untyped]) -> untyped
+      def owner_rows: (Hash[Symbol, untyped]) -> untyped
+    end
+
+    # The owners a HABTM join row links to a target now. A join table has no
+    # model to type its columns, so the owner column is read by quoted name.
+    class LiveHabtm < AssociationActivityEdge
+      # : (untyped, TimeRange?) -> void
+      def initialize: (untyped, TimeRange?) -> void
+
+      # : (untyped) -> untyped
+      def relation: (untyped) -> untyped
+
+      private
+
+      @table: untyped
+
+      # : () -> Hash[String, Symbol?]
+      def join_columns: () -> Hash[String, Symbol?]
+
+      # Some adapters take the quoted name as a plain string too, but a raw SQL
+      # check may not, so it is marked as SQL; no SQLite spec can tell.
+      # mutant:disable
+      # : () -> untyped
+      def quoted_owner_column: () -> untyped
+
+      # Arel ships no signatures; see VersionQuery. Any spelling of the
+      # constant finds the same module.
+      # mutant:disable
+      # : () -> untyped
+      def arel: () -> untyped
+
+      # Active Record 7.1 has no `with_connection`; see VersionAssociationCandidateScope.
+      # Only that version takes the fallback, so no spec run on a newer one can
+      # tell its mutations apart.
+      # mutant:disable
+      # : [T] () { (untyped) -> T } -> T
+      def connected: [T] () { (untyped) -> T } -> T
+    end
+
+    # The owners whose versions PT-AT recorded a HABTM target with, keyed by
+    # the transaction each version was saved in.
+    class RecordedHabtm < AssociationActivityEdge
+      # : (untyped, TimeRange?) -> void
+      def initialize: (untyped, TimeRange?) -> void
+
+      # : () -> bool
+      def available?: () -> bool
+
+      # : (untyped) -> untyped
+      def relation: (untyped) -> untyped
+
+      @associations: untyped
+
+      @versions: untyped
+    end
+  end
+end