paper_trail_diff 0.11.0 → 0.13.0

data/sig/generated/paper_trail_diff/prepared_history.rbs

@@ -3,10 +3,12 @@
 module PaperTrailDiff
   # Batched record states and relationship candidates for one activity range.
   class PreparedHistory
+    attr_reader activity_index: PreparedActivityIndex?
+
     DIRECT_RESOLVERS: untyped
 
-    # : (PreparedRecordIndex) -> void
-    def initialize: (PreparedRecordIndex) -> void
+    # : (PreparedRecordIndex, ?activity_index: PreparedActivityIndex?) -> void
+    def initialize: (PreparedRecordIndex, ?activity_index: PreparedActivityIndex?) -> void
 
     # : (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
     def merge_edge: (untyped, untyped, Hash[String, Hash[Symbol, untyped]]) -> void
@@ -23,6 +25,12 @@ module PaperTrailDiff
     # : (untyped, untyped, untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def record_transition: (untyped, untyped, untyped) -> [ Hash[untyped, untyped], Hash[untyped, untyped] ]?
 
+    # : (untyped, untyped, untyped, ?direct: bool) -> [bool, untyped]
+    def record_after: (untyped, untyped, untyped, ?direct: bool) -> [ bool, untyped ]
+
+    # : (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
+    def snapshot_states: (PreparedRecordState, untyped, untyped) -> [ bool, Array[PreparedRecordState] ]
+
     # : (untyped, untyped, untyped, habtm_boundary: untyped) -> [bool, Array[untyped]]
     def resolve: (untyped, untyped, untyped, habtm_boundary: untyped) -> [ bool, Array[untyped] ]
 
@@ -34,14 +42,13 @@ module PaperTrailDiff
 
     @records: PreparedRecordIndex
 
+    @state_reader: PreparedStateAssociationReader
+
     @unsupported: Hash[Array[String], bool]
 
     # : (untyped, untyped) -> bool
     def supported?: (untyped, untyped) -> bool
 
-    # : (untyped) -> bool
-    def default_scoped?: (untyped) -> bool
-
     # : (untyped, untyped, untyped, untyped) -> Array[untyped]?
     def direct_records: (untyped, untyped, untyped, untyped) -> Array[untyped]?
 
@@ -51,9 +58,6 @@ module PaperTrailDiff
     # : (untyped, untyped, untyped, untyped) -> Array[untyped]
     def resolve_children: (untyped, untyped, untyped, untyped) -> Array[untyped]
 
-    # : (untyped, untyped, untyped, untyped) -> Array[untyped]?
-    def resolve_habtm: (untyped, untyped, untyped, untyped) -> Array[untyped]?
-
     # : (untyped, untyped, untyped) -> Array[untyped]?
     def belongs_to_records: (untyped, untyped, untyped) -> Array[untyped]?
 
@@ -78,9 +82,6 @@ module PaperTrailDiff
     # : (untyped) -> String?
     def scalar_foreign_key: (untyped) -> String?
 
-    # : (untyped, untyped) -> untyped
-    def belongs_to_class: (untyped, untyped) -> untyped
-
     # : (untyped, untyped) -> Array[String]
     def owner_types: (untyped, untyped) -> Array[String]
 
@@ -92,8 +93,5 @@ module PaperTrailDiff
 
     # : (untyped, untyped) -> Array[String]
     def edge_key: (untyped, untyped) -> Array[String]
-
-    # : (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
-    def merge_groups: (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]
   end
 end

data/sig/generated/paper_trail_diff/prepared_history_loader.rbs

@@ -23,6 +23,8 @@ module PaperTrailDiff
 
     @root_ids: Array[untyped]
 
+    @root_versions: Array[untyped]
+
     @traversal: AssociationTraversal
 
     @tree: AssociationTree

data/sig/generated/paper_trail_diff/prepared_record_index.rbs

@@ -23,6 +23,12 @@ module PaperTrailDiff
 
     # : (untyped, Hash[untyped, untyped]) -> void
     def initialize_attributes: (untyped, Hash[untyped, untyped]) -> void
+
+    # A live fallback and a version decoded from history must agree on what
+    # the stored history could represent, or the gap between them reads as a
+    # change.
+    # : (untyped, Hash[untyped, untyped]) -> Hash[untyped, untyped]
+    def stored_attributes: (untyped, Hash[untyped, untyped]) -> Hash[untyped, untyped]
   end
 
   # Extracts a version's scalar state without constructing a disposable AR object.
@@ -62,9 +68,19 @@ module PaperTrailDiff
     # : (untyped) -> untyped
     def record_before: (untyped) -> untyped
 
+    # : (untyped) -> PreparedRecordState?
+    def state_before: (untyped) -> PreparedRecordState?
+
+    # A handled nil is known absence, not permission to query the current row.
+    # : (untyped, ?direct: bool) -> [bool, untyped]
+    def record_after: (untyped, ?direct: bool) -> [ bool, untyped ]
+
     # : () -> Array[untyped]
     def records: () -> Array[untyped]
 
+    # : () -> Array[PreparedRecordState]
+    def states: () -> Array[PreparedRecordState]
+
     # : (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def transition: (untyped) -> [ Hash[untyped, untyped], Hash[untyped, untyped] ]?
 
@@ -87,6 +103,11 @@ module PaperTrailDiff
     # 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.
+    #
+    # "At or after" is decided by the version order rather than the timestamp
+    # alone. A version written in the same instant as the boundary but before
+    # it already took effect there; reading its pre-change state would put the
+    # boundary on the wrong side of a change it follows.
     # : (untyped) -> Integer?
     def boundary_index: (untyped) -> Integer?
 
@@ -108,20 +129,42 @@ module PaperTrailDiff
     # : (untyped, Array[untyped]) -> void
     def load: (untyped, Array[untyped]) -> void
 
+    # : (untyped, Array[untyped], Array[untyped]) -> void
+    def seed: (untyped, Array[untyped], Array[untyped]) -> void
+
     # : (untyped, untyped, untyped) -> untyped
     def record_before: (untyped, untyped, untyped) -> untyped
 
+    # : (untyped, untyped, untyped) -> [bool, PreparedRecordState?]
+    def snapshot_state_before: (untyped, untyped, untyped) -> [ bool, PreparedRecordState? ]
+
     # : (untyped, untyped, untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def transition: (untyped, untyped, untyped) -> [ Hash[untyped, untyped], Hash[untyped, untyped] ]?
 
+    # : (untyped, untyped, untyped, ?direct: bool) -> [bool, untyped]
+    def record_after: (untyped, untyped, untyped, ?direct: bool) -> [ bool, untyped ]
+
     # : (untyped, Array[untyped]) -> Array[untyped]
     def records_for: (untyped, Array[untyped]) -> Array[untyped]
 
+    # : (untyped, Array[untyped], String) -> Array[untyped]
+    def attribute_values_for: (untyped, Array[untyped], String) -> Array[untyped]
+
+    # : (untyped, untyped) -> Array[untyped]
+    def versions_for_id: (untyped, untyped) -> Array[untyped]
+
     # : (untyped, untyped) -> bool
     def loaded?: (untyped, untyped) -> bool
 
     private
 
+    # : (untyped, String) -> bool
+    def generated_reader?: (untyped, String) -> bool
+
+    @direct_loader: DirectRecordStateLoader
+
+    @direct_states: Hash[PreparedRecordState, PreparedRecordState?]
+
     @end_time: untyped
 
     @seeded_live_records: Hash[Array[String], untyped]
@@ -157,12 +200,6 @@ module PaperTrailDiff
     # : (untyped) -> untyped
     def window_condition: (untyped) -> untyped
 
-    # : (untyped) -> untyped
-    def first_after_range: (untyped) -> untyped
-
-    # : (untyped, untyped) -> untyped
-    def preceding_trailing_version: (untyped, untyped) -> untyped
-
     # : (untyped, Array[untyped]) -> Array[untyped]
     def available_live_records: (untyped, Array[untyped]) -> Array[untyped]
 

data/sig/generated/paper_trail_diff/prepared_snapshot_builder.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/paper_trail_diff/prepared_snapshot_builder.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Normalizes supported recorded graphs without historical ActiveRecord instances.
+  class PreparedSnapshotBuilder
+    # : (AssociationTraversal) -> void
+    def initialize: (AssociationTraversal) -> void
+
+    # : (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, history: PreparedHistory?) -> [bool, RecordSnapshot?]
+    def call: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer, history: PreparedHistory?) -> [ bool, RecordSnapshot? ]
+
+    private
+
+    @loader: DirectRecordStateLoader
+
+    @traversal: AssociationTraversal
+
+    # : (PreparedRecordState, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory?, path: String, ?incoming: untyped) -> [bool, RecordSnapshot?]
+    def build: (PreparedRecordState, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory?, path: String, ?incoming: untyped) -> [ bool, RecordSnapshot? ]
+
+    # : (PreparedRecordState, untyped, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory, String) -> [bool, AssociationSnapshot?]
+    def association: (PreparedRecordState, untyped, untyped, AssociationTree, SnapshotNormalizer, PreparedHistory, String) -> [ bool, AssociationSnapshot? ]
+  end
+end

data/sig/generated/paper_trail_diff/prepared_state_association_reader.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/paper_trail_diff/prepared_state_association_reader.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Reads plain direct edges without creating AR records for their members.
+  class PreparedStateAssociationReader
+    # : (PreparedRecordIndex, untyped) -> void
+    def initialize: (PreparedRecordIndex, untyped) -> void
+
+    # : (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
+    def call: (PreparedRecordState, untyped, untyped) -> [ bool, Array[PreparedRecordState] ]
+
+    private
+
+    @edges: untyped
+
+    @records: PreparedRecordIndex
+
+    # : (untyped) -> bool
+    def supported?: (untyped) -> bool
+
+    # : (PreparedRecordState, untyped, untyped) -> [bool, Array[PreparedRecordState]]
+    def children: (PreparedRecordState, untyped, untyped) -> [ bool, Array[PreparedRecordState] ]
+
+    # : (untyped, PreparedRecordState) -> Array[untyped]
+    def ids_for: (untyped, PreparedRecordState) -> Array[untyped]
+
+    # : (PreparedRecordState, PreparedRecordState, untyped) -> bool
+    def member?: (PreparedRecordState, PreparedRecordState, untyped) -> bool
+
+    # : (PreparedRecordState, untyped, untyped) -> bool
+    def matching_type?: (PreparedRecordState, untyped, untyped) -> bool
+  end
+end

data/sig/generated/paper_trail_diff/root_version_plan.rbs

@@ -32,6 +32,11 @@ module PaperTrailDiff
     # version present only to reveal what the last of them produced.
     attr_reader mutations: Array[untyped]
 
+    # Whether a wall-clock window closes on the root's own destruction. Its
+    # final state is then the absence the destroy left, just as a window
+    # closing on current state ends at the live record.
+    attr_reader closes_on_destroy: bool
+
     # Adjacent boundaries, which is what an unfiltered range reports.
     # : (Array[untyped], ?context_version: untyped) -> RootVersionPlan
     def self.contiguous: (Array[untyped], ?context_version: untyped) -> RootVersionPlan
@@ -39,12 +44,20 @@ module PaperTrailDiff
     # : () -> RootVersionPlan
     def self.empty: () -> RootVersionPlan
 
-    # : (versions: Array[untyped], steps: Array[[untyped, untyped]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped) -> void
-    def initialize: (versions: Array[untyped], steps: Array[[ untyped, untyped ]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped) -> void
+    # No root version to report or replay: only descendants moved, and the
+    # live record is the root's state throughout.
+    # : (untyped) -> RootVersionPlan
+    def self.closing_on: (untyped) -> RootVersionPlan
+
+    # : (versions: Array[untyped], steps: Array[[untyped, untyped]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped, ?closes_on_destroy: bool) -> void
+    def initialize: (versions: Array[untyped], steps: Array[[ untyped, untyped ]], ?context_version: untyped, ?reconstruction_versions: Array[untyped]?, ?mutations: Array[untyped]?, ?closing_record: untyped, ?closes_on_destroy: bool) -> void
 
     # : () -> bool
     def empty?: () -> bool
 
+    # : () -> RootVersionPlan
+    def closing_on_destroy: () -> RootVersionPlan
+
     # What the range's final state is read from, which is the live record when
     # the window closes on current state and the last version otherwise.
     # : () -> untyped

data/sig/generated/paper_trail_diff/root_version_selection.rbs

@@ -44,7 +44,9 @@ module PaperTrailDiff
     def contiguous_plan: (untyped) -> RootVersionPlan
 
     # An activity view still needs a root to reconstruct from even when no root
-    # version falls inside the window, because descendants may have moved.
+    # version falls inside the window, because descendants may have moved. With
+    # no later version, a window closing on current state reads the root from
+    # the live record, which is then its state throughout the window.
     # : () -> RootVersionPlan
     def without_selection: () -> RootVersionPlan
 
@@ -83,6 +85,11 @@ module PaperTrailDiff
     # : () -> untyped
     def revealing_version: () -> untyped
 
+    # A window with nothing after its last selected mutation can only close on
+    # that mutation being the record's destruction.
+    # : (untyped) -> bool
+    def closes_on_destroy?: (untyped) -> bool
+
     # A range closing on the record's own destruction needs no later version:
     # nothing can follow it, so demanding one would reject the range forever.
     # : () -> bool

data/sig/generated/paper_trail_diff/scoped_analysis.rbs

@@ -16,9 +16,21 @@ module PaperTrailDiff
 
     attr_reader unreachable: Array[Array[String]]
 
-    # : (analyses: Hash[Array[String], Analysis], unreachable: Array[Array[String]]) -> void
-    def initialize: (analyses: Hash[Array[String], Analysis], unreachable: Array[Array[String]]) -> void
+    # The live records the selection loaded, in the order it loaded them. The
+    # gem already has them; withholding them only makes a caller query the same
+    # rows again to attach its own presentation data. A destroyed root has no
+    # record to hand back, so `roots` and `unreachable` stay complementary.
+    attr_reader roots: Array[untyped]
 
+    # Requested missing-root analyses, kept separate because live SQL conditions
+    # cannot prove which deleted rows matched. nil means no destroy history.
+    attr_reader deleted: Hash[Array[String], Analysis?]
+
+    # : (analyses: Hash[Array[String], Analysis], unreachable: Array[Array[String]], ?roots: Array[untyped], ?deleted: Hash[Array[String], Analysis?]) -> void
+    def initialize: (analyses: Hash[Array[String], Analysis], unreachable: Array[Array[String]], ?roots: Array[untyped], ?deleted: Hash[Array[String], Analysis?]) -> void
+
+    # Two elements, not three: `roots` is reached by name so that existing
+    # destructuring keeps working.
     # : () -> [Hash[Array[String], Analysis], Array[Array[String]]]
     def to_ary: () -> [ Hash[Array[String], Analysis], Array[Array[String]] ]
   end

data/sig/generated/paper_trail_diff/scoped_analysis_builder.rbs

@@ -0,0 +1,22 @@
+# Generated from lib/paper_trail_diff/scoped_analysis_builder.rb with RBS::Inline
+
+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: (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped) -> void
+
+    # : () -> ScopedAnalysis
+    def call: () -> ScopedAnalysis
+
+    @analyzer: untyped
+
+    @deleted_analyzer: untyped
+
+    @include_deleted: bool
+
+    @limit: Integer
+
+    @selection: ScopedRootSelection
+  end
+end

data/sig/generated/paper_trail_diff/scoped_root_selection.rbs

@@ -25,6 +25,8 @@ 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: ::Integer
+
     # A plain class rather than Data.define, which arrived in Ruby 3.2 while this
     # gem supports 3.1.
     class Result
@@ -36,20 +38,43 @@ module PaperTrailDiff
       def initialize: (records: Array[untyped], unreachable: Array[Array[String]]) -> void
     end
 
-    # : (untyped, time_range: TimeRange?, limit: Integer) -> void
-    def initialize: (untyped, time_range: TimeRange?, limit: Integer) -> void
+    # : (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer) -> void
+    def initialize: (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer) -> void
 
     # : () -> Result
     def call: () -> Result
 
     private
 
+    @historical_filter: untyped
+
     @limit: Integer
 
     @scope: untyped
 
     @time_range: TimeRange?
 
+    # 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: () -> Result
+
+    # 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?: () -> bool
+
+    # Changed in the window but without a row, found with an anti-join instead
+    # of comparing two plucked lists.
+    # : () -> Array[String]
+    def missing_ids: () -> Array[String]
+
+    # : () -> untyped
+    def window_versions: () -> untyped
+
     # Accepts a model class as readily as a relation: `Article` and
     # `Article.where(...)` both name a population, and `all` is what makes them
     # the same kind of thing.
@@ -70,10 +95,25 @@ module PaperTrailDiff
     # : (Array[String]) -> Array[String]
     def live_ids: (Array[String]) -> Array[String]
 
-    # Loading one past the limit is what turns an oversized page into an error
-    # rather than a silently truncated report.
-    # : (Array[String]) -> Array[untyped]
-    def selected_records: (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: (untyped) -> Array[untyped]
+
+    # : (untyped, Integer) -> Array[untyped]
+    def record_page: (untyped, Integer) -> Array[untyped]
+
+    # 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: () -> untyped
+
+    # : (Integer) -> Integer
+    def page_limit: (Integer) -> Integer
+
+    # : (Integer) -> void
+    def reject_oversized!: (Integer) -> void
 
     # : (String) -> Array[String]
     def identity: (String) -> Array[String]

data/sig/generated/paper_trail_diff/snapshot.rbs

@@ -113,6 +113,10 @@ module PaperTrailDiff
     # : () -> RecordReference
     def reference: () -> RecordReference
 
+    # A copy holding a different state for one association.
+    # : (String, AssociationSnapshot) -> RecordSnapshot
+    def with_association: (String, AssociationSnapshot) -> RecordSnapshot
+
     # : () -> Hash[Symbol, untyped]
     def to_h: () -> Hash[Symbol, untyped]
 

data/sig/generated/paper_trail_diff/snapshot_normalizer.rbs

@@ -37,8 +37,15 @@ module PaperTrailDiff
     # : (untyped, tree: AssociationTree, path: String) -> snapshot_attributes
     def attributes_for: (untyped, tree: AssociationTree, path: String) -> snapshot_attributes
 
+    # 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: (PreparedRecordState, tree: AssociationTree, path: String, ?incoming: untyped, ?associations: snapshot_associations) -> RecordSnapshot
+
     private
 
+    # : (String, RecordSnapshot) -> RecordSnapshot
+    def pool_state: (String, RecordSnapshot) -> RecordSnapshot
+
     @excluded_attributes: Hash[Array[untyped], Array[String]]
 
     @ignore_policy: IgnorePolicy
@@ -66,6 +73,12 @@ module PaperTrailDiff
     # : (untyped, Array[untyped], String) -> Array[String]
     def build_excluded_attributes: (untyped, Array[untyped], String) -> Array[String]
 
+    # `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: (untyped) -> Array[String]
+
     # : (Array[untyped]) -> Array[String]
     def relationship_columns: (Array[untyped]) -> Array[String]
 

data/sig/generated/paper_trail_diff/step.rbs

@@ -22,7 +22,13 @@ module PaperTrailDiff
     # : () -> bool
     def empty?: () -> bool
 
-    # : () -> Hash[Symbol, untyped]
-    def to_h: () -> Hash[Symbol, untyped]
+    # The root event whose change this step reports.
+    # : () -> ActivityBoundary
+    def source_boundary: () -> ActivityBoundary
+
+    # 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: bool) -> Hash[Symbol, untyped]
   end
 end

data/sig/generated/paper_trail_diff/stored_time_precision.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/paper_trail_diff/stored_time_precision.rb with RBS::Inline
+
+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: ::Integer
+
+    JSON_COLUMN_TYPES: untyped
+
+    # Fractional digits a model's history keeps for times, or nil when the
+    # history is stored losslessly.
+    # : (untyped) -> Integer?
+    def self?.digits: (untyped) -> Integer?
+
+    # : (Hash[untyped, untyped], Integer?) -> Hash[untyped, untyped]
+    def self?.apply: (Hash[untyped, untyped], Integer?) -> Hash[untyped, untyped]
+
+    # : (untyped, Integer) -> untyped
+    def self?.truncate: (untyped, Integer) -> untyped
+
+    # : (untyped) -> bool
+    def self?.json_history?: (untyped) -> bool
+
+    # : () -> bool
+    def self?.json_serializer?: () -> bool
+  end
+end

data/sig/generated/paper_trail_diff/support.rbs

@@ -43,6 +43,13 @@ module PaperTrailDiff
     # : (untyped) -> bool
     def self?.versioned?: (untyped) -> bool
 
+    # `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 self?.record_id: (untyped, untyped) -> untyped
+
     # : (untyped) -> bool
     def self?.sequential_id?: (untyped) -> bool
 

data/sig/generated/paper_trail_diff/time_activity_timeline_builder.rbs

@@ -29,6 +29,9 @@ module PaperTrailDiff
     # : () -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
     def history_and_versions: () -> [ ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped ]
 
+    # : () -> void
+    def reject_live_habtm!: () -> void
+
     # : (RootVersionPlan, untyped) -> [ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped]
     def history_for: (RootVersionPlan, untyped) -> [ ActivityHistory, RootVersionPlan, ActivityStep?, RecordSnapshot?, untyped ]
 
@@ -40,8 +43,10 @@ module PaperTrailDiff
     # : (Array[untyped], untyped) -> Array[ActivityEvent]
     def events_through: (Array[untyped], untyped) -> Array[ActivityEvent]
 
-    # : (Array[untyped], Array[ActivityEvent]) -> ActivityHistory
-    def build_history: (Array[untyped], Array[ActivityEvent]) -> ActivityHistory
+    # 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: (Array[untyped], Array[ActivityEvent], ?current: untyped) -> ActivityHistory
 
     # : (ActivityHistory, ActivityStep?) -> Array[ActivityStep]
     def activity_steps: (ActivityHistory, ActivityStep?) -> Array[ActivityStep]

data/sig/generated/paper_trail_diff/time_range.rbs

@@ -22,10 +22,19 @@ module PaperTrailDiff
     # : (untyped) -> untyped
     def trailing_scope: (untyped) -> untyped
 
+    # 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: (untyped) -> Hash[String, untyped]
+
     private
 
     @exclude_end: bool
 
+    # : (untyped) -> untyped
+    def after_end: (untyped) -> untyped
+
     # : () -> Range[Time]
     def query_range: () -> Range[Time]
 

data/sig/generated/paper_trail_diff/time_version_range.rbs

@@ -6,9 +6,6 @@ module PaperTrailDiff
     # : (untyped, time_range: TimeRange, ?version_scope: untyped, ?live_endpoint: untyped) -> void
     def initialize: (untyped, time_range: TimeRange, ?version_scope: untyped, ?live_endpoint: untyped) -> void
 
-    # : (?context_required: bool) -> Array[untyped]
-    def select: (?context_required: bool) -> Array[untyped]
-
     # : (?context_required: bool) -> RootVersionPlan
     def select_plan: (?context_required: bool) -> RootVersionPlan
 
@@ -22,9 +19,6 @@ module PaperTrailDiff
 
     @version_scope: untyped
 
-    # : () -> untyped
-    def versions_relation: () -> untyped
-
     # : (untyped) -> untyped
     def trailing_version: (untyped) -> untyped
 

data/sig/generated/paper_trail_diff/timeline_builder.rbs

@@ -3,8 +3,8 @@
 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
-    def initialize: (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: (untyped, from: untyped, to: untyped, snapshotter: untyped, ?within: untyped, ?version_scope: untyped, ?plan: RootVersionPlan?, ?live_endpoint: untyped) -> void
 
     # : () -> Array[Step]
     def build: () -> Array[Step]