paper_trail_diff 0.14.0 → 0.15.0

data/sig/generated/paper_trail_diff/approximate_paths.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/paper_trail_diff/approximate_paths.rb with RBS::Inline
+
+module PaperTrailDiff
+  # The requested paths prepared history cannot read exactly, each with why.
+  # PT-AT reads such a path instead, one record at a time, when the caller
+  # passes `allow_approximate: true`.
+  module ApproximatePaths
+    # : (AssociationTraversal, untyped) -> Array[[String, String]]
+    def self.call: (AssociationTraversal, untyped) -> Array[[ String, String ]]
+
+    # A has_many through reads its parts' conditions only, at any depth. A
+    # has_one through over a ranked part is refused whole, so its parts, too,
+    # are checked for conditions alone.
+    # : (untyped, ranked: bool) -> String?
+    def self.fallback_reason: (untyped, ranked: bool) -> String?
+
+    # A scope prepared history can read as conditions on stored attributes
+    # is batched like any other path. A polymorphic target's class, and so
+    # its scope, is known only per record.
+    # : (untyped, bool) -> String?
+    def self.reason_for: (untyped, bool) -> String?
+  end
+end

data/sig/generated/paper_trail_diff/association_discovery.rbs

@@ -49,6 +49,11 @@ module PaperTrailDiff
     # : (untyped, root: bool) -> Array[untyped]
     def supported_reflections: (untyped, root: bool) -> Array[untyped]
 
+    # Every request that reads history refuses a path whose target, or a
+    # model its has_many :through goes through, has no versions.
+    # : (untyped) -> bool
+    def unversioned?: (untyped) -> bool
+
     # : (untyped) -> untyped
     def reflection_target: (untyped) -> untyped
 

data/sig/generated/paper_trail_diff/association_key.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/paper_trail_diff/association_key.rb with RBS::Inline
+
+module PaperTrailDiff
+  # PT-AT records which record a child pointed at by that record's id, and
+  # history matches children to owners and targets by id. An association
+  # keyed on another column (`primary_key:`) would read other records'
+  # history, so it is refused.
+  module AssociationKey
+    # Why the association, or a part of a through, cannot be read by id.
+    # : (untyped) -> String?
+    def self.unsupported_reason: (untyped) -> String?
+
+    # The reflection, or the first part of a through, keyed on a column other
+    # than its owner's or target's primary key.
+    # : (untyped) -> untyped
+    def self.keyed_part: (untyped) -> untyped
+
+    # A belongs_to names a key of its target; any other macro, one of its
+    # owner. A polymorphic target has no single primary key to compare with.
+    # : (untyped) -> bool
+    def self.other_key?: (untyped) -> bool
+
+    # Column names are strings once the key is, so the one mutation left,
+    # `eql?` for `==`, answers the same.
+    # mutant:disable
+    # : (untyped, untyped) -> bool
+    def self.same_column?: (untyped, untyped) -> bool
+  end
+end

data/sig/generated/paper_trail_diff/association_traversal.rbs

@@ -39,6 +39,10 @@ module PaperTrailDiff
     # : (untyped, untyped, root: bool) -> String?
     def self.unsupported_reason: (untyped, untyped, root: bool) -> String?
 
+    # History matches records by primary key, within one set of version tables.
+    # : (untyped) -> String?
+    def self.storage_reason: (untyped) -> String?
+
     # PT-AT records a HABTM's membership only when its owner saves a version,
     # in rows keyed by transaction and association name, not by owner. A root
     # checkpoint so holds the root's membership and no one else's: another

data/sig/generated/paper_trail_diff/batch_preload.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/paper_trail_diff/batch_preload.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Which associations Active Record's preloader loads correctly for many
+  # owners at once.
+  module BatchPreload
+    # The preloader applies a limit or offset to all owners' records at once,
+    # not to each owner's, so such an association is loaded per record. A
+    # has_one is no exception. Through a part with a limit, an offset or a
+    # has_one cut, the preloader keeps what the part alone would load, while
+    # the through's own query keeps the part's conditions only.
+    #
+    # The declared scope is read, not a record's association scope: Active
+    # Record adds `limit(1)` to every has_one's, which would load every
+    # has_one per record.
+    # : (untyped) -> bool
+    def self.safe?: (untyped) -> bool
+
+    # : (untyped) -> untyped
+    def self.declared_relation: (untyped) -> untyped
+
+    # : (untyped) -> bool
+    def self.cut_part?: (untyped) -> bool
+
+    # Every part a through passes, at any depth.
+    # : (untyped) -> Array[untyped]
+    def self.through_parts: (untyped) -> Array[untyped]
+  end
+end

data/sig/generated/paper_trail_diff/batched_root_analyzer.rbs

@@ -4,11 +4,12 @@ module PaperTrailDiff
   # Builds one root's Analysis inside a batch, from versions the batch already
   # selected and history it already prepared.
   class BatchedRootAnalyzer
-    # : (tree: AssociationTree, timeline_snapshotter: untyped, activity_snapshotter: untyped, preparer: untyped, activity: bool, ?within: untyped, ?snapshots: bool, ?group: Symbol?) -> void
-    def initialize: (tree: AssociationTree, timeline_snapshotter: untyped, activity_snapshotter: untyped, preparer: untyped, activity: bool, ?within: untyped, ?snapshots: bool, ?group: Symbol?) -> void
+    # : (tree: AssociationTree, timeline_snapshotter: untyped, activity_snapshotter: untyped, preparer: untyped, activity: bool, view: ActivityView, ?within: untyped) -> void
+    def initialize: (tree: AssociationTree, timeline_snapshotter: untyped, activity_snapshotter: untyped, preparer: untyped, activity: bool, view: ActivityView, ?within: untyped) -> void
 
-    # : (untyped, RootVersionPlan) -> Analysis
-    def call: (untyped, RootVersionPlan) -> Analysis
+    # `window` is the root's window as the batch moved it to transaction edges.
+    # : (untyped, RootVersionPlan, ?TimeRange?) -> Analysis
+    def call: (untyped, RootVersionPlan, ?TimeRange?) -> Analysis
 
     private
 
@@ -16,19 +17,17 @@ module PaperTrailDiff
 
     @activity_snapshotter: untyped
 
-    @group: Symbol?
-
     @preparer: untyped
 
-    @snapshots: bool
-
     @timeline_snapshotter: untyped
 
     @tree: AssociationTree
 
+    @view: ActivityView
+
     @within: untyped
 
-    # : (untyped, RootVersionPlan) -> Analysis
-    def activity_analysis: (untyped, RootVersionPlan) -> Analysis
+    # : (untyped, RootVersionPlan, TimeRange?) -> Analysis
+    def activity_analysis: (untyped, RootVersionPlan, TimeRange?) -> Analysis
   end
 end

data/sig/generated/paper_trail_diff/batched_root_versions.rbs

@@ -5,8 +5,8 @@ module PaperTrailDiff
   # queries. Only the range forms that mean the same thing for every root are
   # supported: a shared wall-clock window, or each root's own whole history.
   class BatchedRootVersions
-    # : (Array[untyped], time_range: TimeRange?, version_scope: untyped, live_endpoints: Hash[Array[String], untyped]?, context_required: bool) -> void
-    def initialize: (Array[untyped], time_range: TimeRange?, version_scope: untyped, live_endpoints: Hash[Array[String], untyped]?, context_required: bool) -> void
+    # : (Array[untyped], time_range: TimeRange?, version_scope: untyped, live_endpoints: Hash[Array[String], untyped]?, context_required: bool, windows: Hash[Array[String], TimeRange]) -> void
+    def initialize: (Array[untyped], time_range: TimeRange?, version_scope: untyped, live_endpoints: Hash[Array[String], untyped]?, context_required: bool, windows: Hash[Array[String], TimeRange]) -> void
 
     # Returns a plan per record identity.
     # : () -> Hash[Array[String], RootVersionPlan]
@@ -24,14 +24,24 @@ module PaperTrailDiff
 
     @version_scope: untyped
 
+    @windows: Hash[Array[String], TimeRange]
+
     # : (untyped, Array[untyped], Hash[Array[String], RootVersionPlan]) -> void
     def select_model: (untyped, Array[untyped], Hash[Array[String], RootVersionPlan]) -> void
 
+    # Moved windows only start and end earlier, so the versions read for the
+    # widest of them hold each root's own, and the first left past a moved end.
+    # : (Array[String], String, Hash[String, Array[untyped]], Hash[String, untyped]) -> [Array[untyped], untyped]
+    def own_window: (Array[String], String, Hash[String, Array[untyped]], Hash[String, untyped]) -> [ Array[untyped], untyped ]
+
     # : (untyped, Array[untyped]) -> [Hash[String, Array[untyped]], Set[untyped]?, Hash[String, untyped]]
     def model_versions: (untyped, Array[untyped]) -> [ Hash[String, Array[untyped]], Set[untyped]?, Hash[String, untyped] ]
 
-    # : (Array[untyped], Set[untyped]?, untyped, untyped) -> RootVersionPlan
-    def versions_for: (Array[untyped], Set[untyped]?, untyped, untyped) -> RootVersionPlan
+    # : (Array[untyped]) -> TimeRange?
+    def widest_range: (Array[untyped]) -> TimeRange?
+
+    # : (Array[untyped], untyped, Set[untyped]?, untyped) -> RootVersionPlan
+    def versions_for: (Array[untyped], untyped, Set[untyped]?, untyped) -> RootVersionPlan
 
     # The batch already loaded every root, so closing on current state reuses
     # that rather than reading each record again.

data/sig/generated/paper_trail_diff/change_row.rbs

@@ -0,0 +1,86 @@
+# Generated from lib/paper_trail_diff/change_row.rb with RBS::Inline
+
+module PaperTrailDiff
+  # One change from an activity step, flat enough for a history table or an
+  # export: a field that changed, or a record that appeared or disappeared,
+  # with the event the step attributes it to.
+  class ChangeRow
+    attr_reader change: Symbol
+
+    attr_reader association_path: Array[String]
+
+    attr_reader association_kind: Symbol?
+
+    # The record the row is about, or nil for the root itself.
+    attr_reader record: RecordReference?
+
+    # The field the row is about, or nil for a row about a whole record.
+    attr_reader attribute: String?
+
+    attr_reader from: untyped
+
+    attr_reader to: untyped
+
+    # The step's source boundary: for a transaction group, its first event.
+    attr_reader source: ActivityBoundary
+
+    # : (change: Symbol, association_path: Array[String], association_kind: Symbol?, record: RecordReference?, attribute: String?, from: untyped, to: untyped, source: ActivityBoundary) -> void
+    def initialize: (change: Symbol, association_path: Array[String], association_kind: Symbol?, record: RecordReference?, attribute: String?, from: untyped, to: untyped, source: ActivityBoundary) -> void
+
+    # The source's identifying fields sit beside the change rather than nested,
+    # so the hash is one row of a table as it stands.
+    # : () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+
+    private
+
+    # : () -> Hash[Symbol, untyped]
+    def source_fields: () -> Hash[Symbol, untyped]
+  end
+
+  # Flattens one step's diff into change rows, in the diff's walking order.
+  #
+  # A row is about one record. An edited field is `:changed`. A record that
+  # appeared or disappeared is one `:added` or `:removed` row, followed by a
+  # row for each of its fields and for each record it holds, so a table can
+  # list a new comment's body without a second walker. That covers a record
+  # joining or leaving a collection, a to-one target set, cleared or replaced
+  # (the old target removed, then the new one added), and the root's own
+  # creation or deletion.
+  #
+  # Two kinds of entry add nothing a row would show. One that only groups
+  # others (an edited record, an association, a relationship) is left out,
+  # because the rows under it name the same record. A blank field of an added
+  # or removed record is left out too, because the record's own row already
+  # says it appeared or disappeared.
+  class ChangeRows
+    RECORD_ENTRIES: untyped
+
+    # : (Diff, source: ActivityBoundary) -> Array[ChangeRow]
+    def self.call: (Diff, source: ActivityBoundary) -> Array[ChangeRow]
+
+    # : (ActivityBoundary) -> void
+    def initialize: (ActivityBoundary) -> void
+
+    # : (Diff) -> Array[ChangeRow]
+    def call: (Diff) -> Array[ChangeRow]
+
+    private
+
+    @source: ActivityBoundary
+
+    # : (TraversalEntry) -> ChangeRow?
+    def row_for: (TraversalEntry) -> ChangeRow?
+
+    # : (TraversalEntry) -> ChangeRow
+    def changed_row: (TraversalEntry) -> ChangeRow
+
+    # An added record's state is the after side and a removed one's the before
+    # side, so a field's value goes on the side that has it.
+    # : (TraversalEntry, String?) -> ChangeRow
+    def presence_row: (TraversalEntry, String?) -> ChangeRow
+
+    # : (TraversalEntry, Symbol, String?, untyped, untyped) -> ChangeRow
+    def row: (TraversalEntry, Symbol, String?, untyped, untyped) -> ChangeRow
+  end
+end

data/sig/generated/paper_trail_diff/collection_comparator.rbs

@@ -2,6 +2,8 @@
 
 module PaperTrailDiff
   # Compares collection snapshots with a low-allocation path for stable membership.
+  # Snapshots hold their records in type and ID order, so results follow it
+  # without sorting here.
   class CollectionComparator
     # : (AssociationSnapshot, AssociationSnapshot, record_comparer: untyped) -> void
     def initialize: (AssociationSnapshot, AssociationSnapshot, record_comparer: untyped) -> void
@@ -47,22 +49,6 @@ module PaperTrailDiff
     # : (Array[RecordSnapshot]) -> Hash[identity, RecordSnapshot]
     def index_records: (Array[RecordSnapshot]) -> Hash[identity, RecordSnapshot]
 
-    # : (Array[identity]) -> Array[identity]
-    def sorted_identities: (Array[identity]) -> Array[identity]
-
-    # 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) -> Array[untyped]
-
-    # Only the order of the group numbers matters, so moving the lowest one
-    # down or the highest one up changes nothing; the spec checks the order.
-    # mutant:disable
-    # : (untyped) -> Array[untyped]
-    def sortable_id: (untyped) -> Array[untyped]
-
     # : (identity) -> void
     def raise_duplicate_identity!: (identity) -> void
   end

data/sig/generated/paper_trail_diff/configuration.rbs

@@ -5,18 +5,27 @@ module PaperTrailDiff
   class AssociationTree
     attr_reader children: Hash[String, AssociationTree]
 
+    # Takes what `includes` takes: a name, a dotted path, a hash of names to
+    # what to include below them, or an array of any of these.
     # : (untyped) -> AssociationTree
     def self.build: (untyped) -> AssociationTree
 
+    # : (untyped, String?) -> Array[String]
+    private def self.paths: (untyped, String?) -> Array[String]
+
+    # `{ comments: :replies }` names comments as well as their replies.
+    # : (untyped, untyped, String?) -> Array[String]
+    private def self.nested_paths: (untyped, untyped, String?) -> Array[String]
+
+    # : (String?, String | Symbol) -> String
+    private def self.joined: (String?, String | Symbol) -> String
+
     # : (Hash[String, untyped], String) -> void
     private def self.add_path: (Hash[String, untyped], String) -> void
 
     # : (Hash[String, untyped]) -> AssociationTree
     private def self.from_hash: (Hash[String, untyped]) -> AssociationTree
 
-    # : (untyped) -> bool
-    private def self.valid_values?: (untyped) -> bool
-
     # : (Hash[String, AssociationTree]) -> void
     def initialize: (Hash[String, AssociationTree]) -> void
 
@@ -63,5 +72,12 @@ module PaperTrailDiff
 
     # : (String) -> Array[String]
     def attributes_for: (String) -> Array[String]
+
+    # The names to leave out of what a version recorded. A root version is
+    # known to be the root's, so its own path's names apply; any other version
+    # does not say which path reached it, so only the names ignored everywhere
+    # do.
+    # : (root: bool) -> Array[String]
+    def recorded_attributes: (root: bool) -> Array[String]
   end
 end

data/sig/generated/paper_trail_diff/deleted_analysis_batch.rbs

@@ -32,11 +32,11 @@ module PaperTrailDiff
 
     # A root destroyed before the window had no state inside it to read, so
     # only the others take the version after the window as context.
-    # : (Array[untyped], Array[untyped]) -> Hash[Array[String], RootVersionPlan]
-    def plans: (Array[untyped], Array[untyped]) -> Hash[Array[String], RootVersionPlan]
+    # : (Array[untyped], Array[untyped], Hash[Array[String], TimeRange]) -> Hash[Array[String], RootVersionPlan]
+    def plans: (Array[untyped], Array[untyped], Hash[Array[String], TimeRange]) -> Hash[Array[String], RootVersionPlan]
 
-    # : (Array[untyped], bool) -> Hash[Array[String], RootVersionPlan]
-    def plans_for: (Array[untyped], bool) -> Hash[Array[String], RootVersionPlan]
+    # : (Array[untyped], bool, Hash[Array[String], TimeRange]) -> Hash[Array[String], RootVersionPlan]
+    def plans_for: (Array[untyped], bool, Hash[Array[String], TimeRange]) -> Hash[Array[String], RootVersionPlan]
 
     # These records supply identity and model metadata only. Every reported
     # value comes from the batched historical plan; no per-root reify or live
@@ -47,10 +47,10 @@ module PaperTrailDiff
     # : () -> Array[untyped]
     def destroy_versions: () -> Array[untyped]
 
-    # : (Array[untyped]) -> Hash[Symbol, untyped]
-    def preparation_range: (Array[untyped]) -> Hash[Symbol, untyped]
+    # : (Array[untyped], Hash[Array[String], TimeRange]) -> Hash[Symbol, untyped]
+    def preparation_range: (Array[untyped], Hash[Array[String], TimeRange]) -> Hash[Symbol, untyped]
 
-    # : (Array[untyped], Hash[Array[String], RootVersionPlan]) -> void
-    def prepare: (Array[untyped], Hash[Array[String], RootVersionPlan]) -> void
+    # : (Array[untyped], Hash[Array[String], RootVersionPlan], Hash[Array[String], TimeRange]) -> void
+    def prepare: (Array[untyped], Hash[Array[String], RootVersionPlan], Hash[Array[String], TimeRange]) -> void
   end
 end

data/sig/generated/paper_trail_diff/deleted_root_filter.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/paper_trail_diff/deleted_root_filter.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Keeps the deleted roots the relation would have selected, by the state
+  # each held when it was destroyed. A relation's conditions read the live
+  # table, where a destroyed root has no row, so without this a report on one
+  # account's records would include every account's deletions.
+  class DeletedRootFilter
+    # : (untyped) -> void
+    def initialize: (untyped) -> void
+
+    # A root whose destroy PaperTrail did not record has no state to test
+    # and stays, as it has no state to report either. One whose destroy
+    # recorded no state is left out.
+    # : (Array[Array[String]]) -> Array[Array[String]]
+    def call: (Array[Array[String]]) -> Array[Array[String]]
+
+    private
+
+    @condition: ScopeCondition
+
+    @loader: DirectRecordStateLoader
+
+    @relation: untyped
+
+    # A relation delegates class methods to its model, so every mutation here,
+    # which drops `.model`, answers the same.
+    # mutant:disable
+    # : () -> untyped
+    def model: () -> untyped
+
+    # : (Hash[String, untyped]?) -> bool
+    def selected?: (Hash[String, untyped]?) -> bool
+
+    # The state each root held before its latest destroy.
+    # : (Array[String]) -> Hash[String, Hash[String, untyped]?]
+    def destroyed_states: (Array[String]) -> Hash[String, Hash[String, untyped]?]
+
+    # Read directly, with a column `skip:` left out of history as its default,
+    # so a report checks its ceiling before reifying anything. A version the
+    # direct reader declines, such as one naming a column since removed, is
+    # reified. Only the record's own attributes are read, so the association
+    # options, which only spare queries, cannot change an answer.
+    # mutant:disable
+    # : (untyped) -> Hash[String, untyped]?
+    def reified_attributes: (untyped) -> Hash[String, untyped]?
+  end
+end

data/sig/generated/paper_trail_diff/deprecation.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/paper_trail_diff/deprecation.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Warns about options that do nothing any more and will be removed. In a
+  # Rails app, register the deprecator to configure it with the app's own:
+  #
+  #   Rails.application.deprecators[:paper_trail_diff] = PaperTrailDiff.deprecator
+  module Deprecation
+    CLOSE_ON: ::String
+
+    ALLOW_EXPENSIVE: ::String
+
+    RELOAD_LIVE_ENDPOINTS: ::String
+
+    # Required when first used, as the library loads nothing it does not need.
+    # : () -> untyped
+    def self.deprecator: () -> untyped
+
+    # The one value close_on: took. It named what ends a wall-clock window,
+    # so it was meaningless without one, and until it is removed it is still
+    # checked as it was.
+    CLOSE_ON_CURRENT: ::Symbol
+
+    # : (Symbol?, untyped) -> void
+    def self.close_on!: (Symbol?, untyped) -> void
+
+    # : (untyped) -> void
+    def self.allow_expensive!: (untyped) -> void
+
+    # The value to use: the option still works until it is removed, and nil
+    # stands for its old default.
+    # : (untyped) -> untyped
+    def self.reload_live_endpoints!: (untyped) -> untyped
+  end
+end

data/sig/generated/paper_trail_diff/diagnostics.rbs

@@ -41,28 +41,49 @@ module PaperTrailDiff
   end
 
   # Performs read-only checks for known PaperTrail/PT-AT reconstruction hazards.
+  #
+  # The endpoints are a comparison's: two versions, or a version and the
+  # current record, in either order. Two current records read no history, so
+  # nothing is checked.
   class HistoryDiagnostics
-    # : (untyped, untyped, associations: Array[String | Symbol]) -> void
-    def initialize: (untyped, untyped, associations: Array[String | Symbol]) -> void
+    STOPPING_CODES: untyped
+
+    # : (untyped, untyped, associations: association_option, ?allow_approximate: bool) -> void
+    def initialize: (untyped, untyped, associations: association_option, ?allow_approximate: bool) -> void
 
     # : () -> DiagnosticReport
     def call: () -> DiagnosticReport
 
     private
 
-    @from_version: untyped
+    # Each refusal a comparison would raise is an error, so `ok?` is false
+    # exactly when one would. The checks after them read reflections that must
+    # resolve and PT-AT records that must be there.
+    # : (untyped) -> void
+    def inspect_associations: (untyped) -> void
+
+    @allow_approximate: bool
 
     @issues: Array[DiagnosticIssue]
 
-    @to_version: untyped
+    @preparer: TraversalPreparer
+
+    @traversal: AssociationTraversal
 
     @tree: AssociationTree
 
-    # : () -> untyped
-    def validated_model_class: () -> untyped
+    @versions: Array[untyped]
+
+    # The endpoints that are versions, in the order given.
+    # : (untyped, untyped) -> Array[untyped]
+    def validated_versions: (untyped, untyped) -> Array[untyped]
 
     # : (Array[Array[untyped]]) -> void
-    def inspect_targets: (Array[Array[untyped]]) -> void
+    def inspect_polymorphic_targets: (Array[Array[untyped]]) -> void
+
+    # Accepted, but read the way `allow_approximate:` describes.
+    # : (untyped) -> void
+    def inspect_approximate_paths: (untyped) -> void
 
     # : (untyped, Array[Array[untyped]]) -> void
     def inspect_habtm: (untyped, Array[Array[untyped]]) -> void
@@ -72,8 +93,15 @@ module PaperTrailDiff
     # : (untyped, Array[Array[untyped]]) -> void
     def inspect_shared_transactions: (untyped, Array[Array[untyped]]) -> void
 
-    # : () -> void
-    def inspect_version_sequence: () -> void
+    # With the current record as one endpoint there is one version, and the
+    # sequence runs on from it.
+    # : (untyped) -> void
+    def inspect_version_sequence: (untyped) -> void
+
+    # Only a path PT-AT reads can lose a change between tied versions, and a
+    # traversal that does not resolve reads nothing at all.
+    # : (untyped) -> bool
+    def fallback_selected?: (untyped) -> bool
 
     # : (untyped) -> void
     def inspect_checkpoint_timestamp: (untyped) -> void
@@ -81,30 +109,9 @@ module PaperTrailDiff
     # : (Array[String]) -> void
     def inspect_transaction_metadata: (Array[String]) -> void
 
-    # : (untyped, String) -> void
-    def inspect_versioned_model: (untyped, String) -> void
-
-    # : (untyped, String) -> void
-    def inspect_through_model: (untyped, String) -> void
-
-    # : (untyped) -> bool
-    def model_versioned?: (untyped) -> bool
-
     # : (untyped) -> bool
     def synchronized_timestamp_disabled?: (untyped) -> bool
 
-    # : () -> bool
-    def association_tracking_available?: () -> bool
-
-    # : (untyped) -> Array[String]
-    def version_identity: (untyped) -> Array[String]
-
-    # : (untyped) -> String
-    def version_type: (untyped) -> String
-
-    # : () -> String
-    def tracking_unavailable_message: () -> String
-
     # : (Symbol, String, ?String?, ?untyped) -> void
     def add_error: (Symbol, String, ?String?, ?untyped) -> void
 

data/sig/generated/paper_trail_diff/endpoint.rbs

@@ -21,6 +21,15 @@ module PaperTrailDiff
     # : (untyped) -> void
     def self?.validate!: (untyped) -> void
 
+    # The record a method reads the history of: a record, saved or destroyed,
+    # of a model PaperTrail versions.
+    # : (untyped) -> void
+    def self?.validate_root!: (untyped) -> void
+
+    # A relation is named rather than inspected, which would load it.
+    # : (untyped) -> String
+    def self?.described: (untyped) -> String
+
     # : (untyped) -> bool
     def self?.version?: (untyped) -> bool
 
@@ -33,8 +42,8 @@ module PaperTrailDiff
     # : (untyped) -> untyped
     def self?.model_class: (untyped) -> untyped
 
-    # The record's own PaperTrail versions, under whatever name the model gave
-    # the association.
+    # Every PaperTrail version of the record, whatever scope its versions
+    # association has.
     # : (untyped) -> untyped
     def self?.versions: (untyped) -> untyped
 

data/sig/generated/paper_trail_diff/errors.rbs

@@ -54,7 +54,9 @@ module PaperTrailDiff
   class FilterLimitExceededError < Error
   end
 
-  # A batch selected a known expensive association without explicitly opting in.
+  # No longer raised: `allow_approximate: true` alone accepts the paths it
+  # refused. Kept until `allow_expensive:` is removed, so code that rescues it
+  # still loads.
   class UnsupportedBatchPathError < ConfigurationError
   end
 

data/sig/generated/paper_trail_diff/fallback_paths.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/paper_trail_diff/fallback_paths.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Whether a request may read a path with PT-AT's reifier rather than from
+  # loaded history. PT-AT places association changes by timestamp alone, so
+  # only such a path can miss a change between two versions that share one;
+  # loaded history orders those versions by id.
+  module FallbackPaths
+    # A path history reads only approximately counts when it is allowed: a
+    # request that does not allow it is refused before anything is read.
+    # : (AssociationTraversal, untyped, approximate: bool) -> bool
+    def self.any?: (AssociationTraversal, untyped, approximate: bool) -> bool
+
+    # Loaded history cannot index a composite foreign key, and a polymorphic
+    # belongs_to's target, with its default scope, is known only per record.
+    # : (untyped) -> bool
+    def self.per_record?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def self.composite_key?: (untyped) -> bool
+  end
+end

data/sig/generated/paper_trail_diff/historical_filter.rbs

@@ -16,8 +16,10 @@ module PaperTrailDiff
     # : (untyped, predicate: untyped, time_range: TimeRange?, limit: Integer, max_versions: Integer) -> void
     def initialize: (untyped, predicate: untyped, time_range: TimeRange?, limit: Integer, max_versions: Integer) -> void
 
-    # : (Array[String]) -> Array[String]
-    def call: (Array[String]) -> Array[String]
+    # More matches than the limit raise, unless the caller does not count
+    # them: candidates it only lists, such as deleted roots.
+    # : (Array[String], ?counted: bool) -> Array[String]
+    def call: (Array[String], ?counted: bool) -> Array[String]
 
     private
 
@@ -38,6 +40,14 @@ module PaperTrailDiff
     # : (untyped) -> untyped
     def validate_predicate: (untyped) -> untyped
 
+    # Expected and recorded values compare as the attribute casts them, as
+    # `where` reads its values: an enum's symbol names its stored value, and a
+    # `json` or `jsonb` version column, which PaperTrail does not cast, holds
+    # dates and times as strings. Casting also copies a mutable value, so the
+    # filter keeps its own.
+    # : (String, untyped) -> untyped
+    def cast: (String, untyped) -> untyped
+
     # : (untyped) -> Integer
     def validate_budget: (untyped) -> Integer