paper_trail_diff 0.11.0 → 0.13.0

data/sig/generated/paper_trail_diff/batched_root_analyzer.rbs

@@ -4,8 +4,8 @@ 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) -> void
-    def initialize: (tree: AssociationTree, timeline_snapshotter: untyped, activity_snapshotter: untyped, preparer: untyped, activity: bool) -> void
+    # : (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
 
     # : (untyped, RootVersionPlan) -> Analysis
     def call: (untyped, RootVersionPlan) -> Analysis
@@ -16,12 +16,18 @@ module PaperTrailDiff
 
     @activity_snapshotter: untyped
 
+    @group: Symbol?
+
     @preparer: untyped
 
+    @snapshots: bool
+
     @timeline_snapshotter: untyped
 
     @tree: AssociationTree
 
+    @within: untyped
+
     # : (untyped, RootVersionPlan) -> Analysis
     def activity_analysis: (untyped, RootVersionPlan) -> Analysis
   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]?) -> void
-    def initialize: (Array[untyped], time_range: TimeRange?, ?version_scope: untyped, ?live_endpoints: Hash[Array[String], untyped]?) -> void
+    # : (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
 
     # Returns a plan per record identity.
     # : () -> Hash[Array[String], RootVersionPlan]
@@ -14,6 +14,8 @@ module PaperTrailDiff
 
     private
 
+    @context_required: bool
+
     @live_endpoints: Hash[Array[String], untyped]?
 
     @records: Array[untyped]
@@ -47,23 +49,9 @@ module PaperTrailDiff
     # : (untyped, Array[untyped], TimeRange?) -> untyped
     def range_scope: (untyped, Array[untyped], TimeRange?) -> untyped
 
-    # One row per root: the earliest version after the window, found without a
-    # window function so the query stays portable.
     # : (untyped, Array[untyped], TimeRange) -> Hash[String, untyped]
     def trailing_versions: (untyped, Array[untyped], TimeRange) -> Hash[String, untyped]
 
-    # : (untyped, TimeRange) -> untyped
-    def no_earlier_trailing: (untyped, TimeRange) -> untyped
-
-    # Mirrors the window's own end handling, so a version sitting exactly on an
-    # inclusive boundary stays inside the window instead of masking the trailing
-    # version that follows it.
-    # : (untyped, untyped, TimeRange) -> untyped
-    def preceding: (untyped, untyped, TimeRange) -> untyped
-
-    # : (untyped, TimeRange) -> untyped
-    def after_window: (untyped, TimeRange) -> untyped
-
     # : (untyped, Array[untyped]) -> untyped
     def base_scope: (untyped, Array[untyped]) -> untyped
 

data/sig/generated/paper_trail_diff/branch_snapshot_refresher.rbs

@@ -3,8 +3,8 @@
 module PaperTrailDiff
   # Reconstructs selected root branches and merges them into a prior immutable snapshot.
   class BranchSnapshotRefresher
-    # : (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped, record_transition: untyped) -> void
-    def initialize: (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped, record_transition: untyped) -> void
+    # : (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped, record_transition: untyped, ?prepared_record_after: untyped) -> void
+    def initialize: (tree: AssociationTree, ignore_policy: IgnorePolicy, traversal: AssociationTraversal, pool: SnapshotPool, normalizer: SnapshotNormalizer, full_snapshotter: untyped, partial_snapshotter: untyped, association_reader: untyped, record_transition: untyped, ?prepared_record_after: untyped) -> void
 
     # : (untyped, untyped, RecordSnapshot?, event: ActivityEvent) -> RecordSnapshot?
     def advance_root: (untyped, untyped, RecordSnapshot?, event: ActivityEvent) -> RecordSnapshot?

data/sig/generated/paper_trail_diff/deleted_analysis_batch.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/paper_trail_diff/deleted_analysis_batch.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Analyzes missing roots together without pretending that they have live rows.
+  class DeletedAnalysisBatch
+    # : (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, ?version_scope: untyped) -> void
+    def initialize: (untyped, identities: Array[Array[String]], time_range: TimeRange?, analyzer: untyped, history_preparer: untyped, ?version_scope: untyped) -> void
+
+    # : () -> Hash[Array[String], Analysis?]
+    def call: () -> Hash[Array[String], Analysis?]
+
+    private
+
+    # : (Hash[Array[String], Analysis]) -> Hash[Array[String], Analysis?]
+    def with_unavailable: (Hash[Array[String], Analysis]) -> Hash[Array[String], Analysis?]
+
+    @analyzer: untyped
+
+    @history_preparer: untyped
+
+    @identities: Array[Array[String]]
+
+    @model: untyped
+
+    @time_range: TimeRange?
+
+    @version_scope: untyped
+
+    # These records supply identity and model metadata only. Every reported
+    # value comes from the batched historical plan; no per-root reify or live
+    # lookup is needed to get into the comparison engine.
+    # : () -> Array[untyped]
+    def historical_roots: () -> Array[untyped]
+
+    # : () -> 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], RootVersionPlan]) -> void
+    def prepare: (Array[untyped], Hash[Array[String], RootVersionPlan]) -> void
+  end
+end

data/sig/generated/paper_trail_diff/direct_record_state_loader.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/paper_trail_diff/direct_record_state_loader.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Completes plain recorded state without invoking model initialization or writers.
+  # Decline model behavior whose values require an actual ActiveRecord instance.
+  class DirectRecordStateLoader
+    # : () -> void
+    def initialize: () -> void
+
+    # : (untyped) -> PreparedRecordState?
+    def call: (untyped) -> PreparedRecordState?
+
+    # : (PreparedRecordState) -> PreparedRecordState?
+    def complete: (PreparedRecordState) -> PreparedRecordState?
+
+    private
+
+    @defaults: Hash[untyped, Hash[untyped, untyped]]
+
+    @loader: PreparedVersionStateLoader
+
+    @supported: Hash[untyped, bool]
+
+    # : (untyped) -> bool
+    def supported?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def plain_model?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def plain_attributes?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def application_defaults?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def encrypted?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def framework_class?: (untyped) -> bool
+  end
+end

data/sig/generated/paper_trail_diff/endpoint.rbs

@@ -33,6 +33,11 @@ module PaperTrailDiff
     # : (untyped) -> untyped
     def self?.model_class: (untyped) -> untyped
 
+    # The record's own PaperTrail versions, under whatever name the model gave
+    # the association.
+    # : (untyped) -> untyped
+    def self?.versions: (untyped) -> untyped
+
     # : (untyped) -> untyped
     def self?.reload_record: (untyped) -> untyped
 

data/sig/generated/paper_trail_diff/engine.rbs

@@ -18,6 +18,8 @@ module PaperTrailDiff
     # : (AssociationSnapshot?, AssociationSnapshot?) -> void
     private def self.validate_association_kinds!: (AssociationSnapshot?, AssociationSnapshot?) -> void
 
+    # Kinds are symbols, so `!=`, `equal?`, and `eql?` all agree here.
+    # mutant:disable
     # : (AssociationSnapshot?, AssociationSnapshot?) -> bool
     private def self.kinds_differ?: (AssociationSnapshot?, AssociationSnapshot?) -> bool
 
@@ -36,7 +38,7 @@ module PaperTrailDiff
     # : (AssociationSnapshot, AssociationSnapshot) -> CollectionAssociationDiff
     private def self.compare_collection: (AssociationSnapshot, AssociationSnapshot) -> CollectionAssociationDiff
 
-    # : (RecordSnapshot?, RecordSnapshot?) -> bool
-    private def self.same_identity?: (RecordSnapshot?, RecordSnapshot?) -> bool
+    # : (RecordSnapshot?, RecordSnapshot?) -> boolish
+    private def self.same_identity?: (RecordSnapshot?, RecordSnapshot?) -> boolish
   end
 end

data/sig/generated/paper_trail_diff/errors.rbs

@@ -9,6 +9,10 @@ module PaperTrailDiff
   class ConfigurationError < Error
   end
 
+  # Raised when nested data keys cannot be represented by unique string paths.
+  class AmbiguousNestedKeyError < Error
+  end
+
   # Raised when compare endpoints do not belong to the same PaperTrail item.
   class VersionMismatchError < Error
   end
@@ -46,6 +50,14 @@ module PaperTrailDiff
   class BatchLimitExceededError < Error
   end
 
+  # Historical candidate loading exceeded its explicitly bounded work budget.
+  class FilterLimitExceededError < Error
+  end
+
+  # A batch selected a known expensive association without explicitly opting in.
+  class UnsupportedBatchPathError < ConfigurationError
+  end
+
   # Raised when a requested ActiveRecord association does not exist.
   class UnknownAssociationError < Error
   end

data/sig/generated/paper_trail_diff/historical_association_reifier.rbs

@@ -25,6 +25,14 @@ module PaperTrailDiff
     # : (untyped, untyped) -> void
     def reify_has_many: (untyped, untyped) -> void
 
+    # PT-AT's collection-source helper reifies every has_many on each join
+    # record. Walk only the requested source instead, including nested throughs.
+    # : (untyped, untyped) -> void
+    def reify_through: (untyped, untyped) -> void
+
+    # : (untyped, untyped, untyped) -> Array[untyped]
+    def through_members: (untyped, untyped, untyped) -> Array[untyped]
+
     # : (untyped, untyped) -> void
     def reify_habtm: (untyped, untyped) -> void
 

data/sig/generated/paper_trail_diff/historical_filter.rbs

@@ -0,0 +1,75 @@
+# Generated from lib/paper_trail_diff/historical_filter.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Selects roots by the values they held at any point in the window, with an
+  # explicit ceiling on version loading.
+  #
+  # A version records the state *before* its own change, so the versions in
+  # the window supply the state at its start and after every change but the
+  # last. The state after the last change lives in the first version after
+  # the window, or in the live row when nothing follows; a destroy leaves none.
+  class HistoricalFilter
+    DEFAULT_VERSION_LIMIT: ::Integer
+
+    CANDIDATE_BATCH: ::Integer
+
+    # : (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]
+
+    private
+
+    @limit: Integer
+
+    @loaded: Integer
+
+    @max_versions: Integer
+
+    @model: untyped
+
+    @predicate: untyped
+
+    @state_loader: PreparedVersionStateLoader
+
+    @time_range: TimeRange?
+
+    # : (untyped) -> untyped
+    def validate_predicate: (untyped) -> untyped
+
+    # : (untyped) -> Integer
+    def validate_budget: (untyped) -> Integer
+
+    # : (Array[String]) -> Hash[String, Array[untyped]]
+    def candidate_versions: (Array[String]) -> Hash[String, Array[untyped]]
+
+    # : (Array[untyped], untyped) -> bool
+    def held?: (Array[untyped], untyped) -> bool
+
+    # What each candidate held after its last change in the window.
+    # : (Array[String], Hash[String, Array[untyped]]) -> Hash[String, untyped]
+    def closing_states: (Array[String], Hash[String, Array[untyped]]) -> Hash[String, untyped]
+
+    # : (Array[String]) -> Hash[String, untyped]
+    def trailing_versions: (Array[String]) -> Hash[String, untyped]
+
+    # : (Array[String]) -> Hash[String, untyped]
+    def live_records: (Array[String]) -> Hash[String, untyped]
+
+    # : (untyped) -> bool
+    def record_matches?: (untyped) -> bool
+
+    # : (Integer) -> void
+    def account_versions!: (Integer) -> void
+
+    # : (untyped) -> bool
+    def matches?: (untyped) -> bool
+
+    # : (untyped) -> bool
+    def attributes_match?: (untyped) -> bool
+
+    # : () -> void
+    def reject_root_limit!: () -> void
+  end
+end

data/sig/generated/paper_trail_diff/historical_snapshot_store.rbs

@@ -9,8 +9,13 @@ module PaperTrailDiff
     # : (untyped, Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
     def prepare: (untyped, Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
 
-    # : (Array[untyped], Array[untyped]) -> void
-    def prepare_batch: (Array[untyped], Array[untyped]) -> void
+    # : (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def prepare_batch: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+
+    # Missing roots have no live graph to collect. Reading their associations
+    # here would issue a query per root and seed nonexistent rows as live state.
+    # : (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def prepare_deleted_batch: (Array[untyped], Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
 
     # : (untyped, untyped) -> RecordSnapshot?
     def call: (untyped, untyped) -> RecordSnapshot?
@@ -24,9 +29,15 @@ module PaperTrailDiff
     # : (untyped, habtm_version: untyped) -> untyped
     def association_reader: (untyped, habtm_version: untyped) -> untyped
 
+    # : () -> PreparedActivityIndex?
+    def activity_index: () -> PreparedActivityIndex?
+
     # : (untyped) -> [Hash[untyped, untyped], Hash[untyped, untyped]]?
     def record_transition: (untyped) -> [ Hash[untyped, untyped], Hash[untyped, untyped] ]?
 
+    # : (untyped, ?direct: bool) -> [bool, untyped]
+    def record_after: (untyped, ?direct: bool) -> [ bool, untyped ]
+
     private
 
     @live_graph_collector: LiveGraphCollector
@@ -37,6 +48,8 @@ module PaperTrailDiff
 
     @prepared_history: PreparedHistory?
 
+    @prepared_snapshotter: PreparedSnapshotBuilder
+
     @preparer: untyped
 
     @snapshots: Hash[Array[untyped], RecordSnapshot?]
@@ -51,8 +64,8 @@ module PaperTrailDiff
     # : (Array[untyped], Array[untyped]) -> Hash[Symbol, untyped]
     def batch_payload: (Array[untyped], Array[untyped]) -> Hash[Symbol, untyped]
 
-    # : (Array[untyped], Array[untyped]) -> void
-    def register_batch: (Array[untyped], Array[untyped]) -> void
+    # : (Array[untyped], Array[untyped], ?live_records: Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
+    def register_batch: (Array[untyped], Array[untyped], ?live_records: Array[untyped], ?start_at: untyped, ?end_at: untyped) -> void
 
     # : (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?
     def snapshot_from_version: (untyped, untyped, tree: AssociationTree, normalizer: SnapshotNormalizer) -> RecordSnapshot?

data/sig/generated/paper_trail_diff/nested_comparator.rbs

@@ -13,25 +13,29 @@ module PaperTrailDiff
   # names and locales routinely do -- and joining would make `a.b` ambiguous
   # between one key and two.
   #
-  # Arrays are leaves. Their elements carry no identity, so an insertion at the
-  # front makes every later index look changed; reporting "element 2 changed"
-  # would be confidently wrong about a list that merely shifted. The whole array
-  # is reported as one change, which is the same rule the collection comparator
-  # follows for records it cannot identify.
+  # Arrays are reported by membership, not by position -- see ArrayChange. Their
+  # elements carry no identity, so an insertion at the front makes every later
+  # index look changed, and one insertion reads as several edits. What is added
+  # and removed can be answered without claiming any pairing; what cannot is the
+  # same elements in a new order, so that is named rather than passed over.
   #
   # An absent key is not a null one. `{"a": null}` and `{}` mean different
   # things in JSON and an audit trail that conflated them would be lying about
   # one of them, so absence is its own value rather than nil.
   class NestedComparator
     # Stands in for a key that was not there at all.
-    ABSENT: untyped
+    class Absent
+      # : () -> String
+      def inspect: () -> String
 
-    def inspect: () -> untyped
+      # : () -> String
+      def to_s: () -> String
+    end
 
-    def to_s: () -> untyped
+    ABSENT: untyped
 
-    # : (untyped, untyped) -> Hash[Array[String], ValueChange]
-    def self.call: (untyped, untyped) -> Hash[Array[String], ValueChange]
+    # : (untyped, untyped) -> nested_changes
+    def self.call: (untyped, untyped) -> nested_changes
 
     # : (untyped, untyped) -> void
     def initialize: (untyped, untyped) -> void
@@ -39,8 +43,8 @@ module PaperTrailDiff
     # Returns the changed paths, or an empty hash when the pair is not two
     # structures this can look inside. An empty result therefore means "nothing
     # to report at this depth", and the caller still has the whole-value change.
-    # : () -> Hash[Array[String], ValueChange]
-    def call: () -> Hash[Array[String], ValueChange]
+    # : () -> nested_changes
+    def call: () -> nested_changes
 
     private
 
@@ -57,12 +61,21 @@ module PaperTrailDiff
     # : (untyped) -> Hash[untyped, untyped]?
     def structure: (untyped) -> Hash[untyped, untyped]?
 
-    # : (Hash[untyped, untyped], Hash[untyped, untyped], Array[String], Hash[Array[String], ValueChange]) -> void
-    def walk: (Hash[untyped, untyped], Hash[untyped, untyped], Array[String], Hash[Array[String], ValueChange]) -> void
+    # : (Hash[untyped, untyped], Hash[untyped, untyped], Array[String], nested_changes) -> void
+    def walk: (Hash[untyped, untyped], Hash[untyped, untyped], Array[String], nested_changes) -> void
+
+    # : (Hash[untyped, untyped]) -> Hash[String, untyped]
+    def normalize_keys: (Hash[untyped, untyped]) -> Hash[String, untyped]
+
+    # Two arrays are a membership change; anything else is a change to the
+    # value as a whole, including an array facing something that is not one.
+    # : (untyped, untyped) -> nested_change
+    def change_for: (untyped, untyped) -> nested_change
 
-    # Sorted so a report reads the same twice, and stringified because a hash
-    # loaded from JSON and one built in Ruby can key the same field differently.
-    # : (Hash[untyped, untyped], Hash[untyped, untyped]) -> Array[untyped]
-    def keys: (Hash[untyped, untyped], Hash[untyped, untyped]) -> Array[untyped]
+    # Sorted so a report reads the same twice. Both hashes are already keyed by
+    # strings, because a hash loaded from JSON and one built in Ruby can key the
+    # same field differently.
+    # : (Hash[String, untyped], Hash[String, untyped]) -> Array[String]
+    def keys: (Hash[String, untyped], Hash[String, untyped]) -> Array[String]
   end
 end

data/sig/generated/paper_trail_diff/paper_trail_adapter.rbs

@@ -9,8 +9,8 @@ module PaperTrailDiff
     # The only thing a wall-clock window can close on besides a later version.
     CLOSE_ON_CURRENT: ::Symbol
 
-    # : (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool) -> void
-    def initialize: (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool) -> void
+    # : (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool, ?allow_expensive: bool) -> void
+    def initialize: (associations: Array[String | Symbol], ignore: ignore_option, ?reload_live_endpoints: bool, ?allow_expensive: bool) -> void
 
     # : (untyped, untyped) -> Diff
     def compare: (untyped, untyped) -> Diff
@@ -29,18 +29,32 @@ module PaperTrailDiff
     def analyze: (untyped, from: untyped, to: untyped, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?) -> Analysis
 
     # Analyzes many roots over one shared range, preparing their history once.
-    # : (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Hash[identity, Analysis]
-    def analyze_many: (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> Hash[identity, Analysis]
+    # : (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?) -> Hash[identity, Analysis]
+    def analyze_many: (Array[untyped], within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?) -> Hash[identity, Analysis]
 
     # Selects the roots from a relation before running the ordinary batch, so a
     # caller reporting on a population does not have to rediscover which of its
     # members changed. The roots the relation could not reach come back named
     # rather than dropped -- see `PaperTrailDiff.analyze_scope`.
-    # : (untyped, limit: Integer?, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> ScopedAnalysis
-    def analyze_scope: (untyped, limit: Integer?, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?) -> ScopedAnalysis
+    # : (untyped, limit: Integer?, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?, ?historical_filter: untyped, ?max_filter_versions: Integer, ?include_deleted: bool) -> ScopedAnalysis
+    def analyze_scope: (untyped, limit: Integer?, within: untyped, ?activity: bool, ?version_scope: untyped, ?close_on: Symbol?, ?snapshots: bool, ?group: Symbol?, ?historical_filter: untyped, ?max_filter_versions: Integer, ?include_deleted: bool) -> ScopedAnalysis
 
     private
 
+    # : (Array[comparison_input], preparer: untyped) -> ComparisonBatch
+    def comparison_batch: (Array[comparison_input], preparer: untyped) -> ComparisonBatch
+
+    # : (Array[untyped]) -> Hash[identity, untyped]
+    def load_batch_endpoints: (Array[untyped]) -> Hash[identity, untyped]
+
+    # : (untyped, historical: bool) -> void
+    def prepare_batch_model: (untyped, historical: bool) -> void
+
+    @batch_safety: BatchSafety
+
+    # : (untyped, Array[Array[String]], Hash[Symbol, untyped]) -> Hash[Array[String], Analysis?]
+    def analyze_deleted: (untyped, Array[Array[String]], Hash[Symbol, untyped]) -> Hash[Array[String], Analysis?]
+
     @activity_snapshotter: ActivitySnapshotProvider
 
     @association_tree: AssociationTree
@@ -74,21 +88,31 @@ module PaperTrailDiff
     # : (untyped, untyped) -> void
     def notify_ambiguous_association_boundary: (untyped, untyped) -> void
 
-    # `close_on:` names what ends a wall-clock window, so it is meaningless for a
-    # range whose endpoints the caller already gave explicitly.
+    # A window with nothing recorded after its last change ends at the live
+    # record, which holds the state that change produced -- whether the window
+    # ended a moment ago or long before. `close_on: :current` asked for this
+    # before it was the default and is still accepted. It names what ends a
+    # wall-clock window, so it is meaningless for explicit endpoints.
     # : (Symbol?, untyped) -> bool
     def close_on_current?: (Symbol?, untyped) -> bool
 
-    # A destroyed root has no current state to close on, and its own destroy
-    # version already terminates the history.
+    # With neither a window nor endpoints, a range is the record's whole
+    # history through its current saved state; a missing endpoint takes that
+    # side of the same default.
+    # : (untyped, untyped, untyped, untyped) -> [untyped, untyped]
+    def default_range: (untyped, untyped, untyped, untyped) -> [ untyped, untyped ]
+
+    # Only a saved row has current state to close on. A destroyed root's own
+    # destroy version already terminates its history, and a reified or unsaved
+    # instance stands for a state that is not in the table.
     # : (untyped, Symbol?, untyped) -> untyped
     def live_endpoint_for: (untyped, Symbol?, untyped) -> untyped
 
     # : () -> void
     def build_snapshotters: () -> void
 
-    # : (bool) -> BatchedRootAnalyzer
-    def batched_root_analyzer: (bool) -> BatchedRootAnalyzer
+    # : (bool, within: untyped, snapshots: bool, group: Symbol?) -> BatchedRootAnalyzer
+    def batched_root_analyzer: (bool, within: untyped, snapshots: bool, group: Symbol?) -> BatchedRootAnalyzer
 
     # : () -> HistoricalSnapshotStore
     def build_historical_store: () -> HistoricalSnapshotStore
@@ -99,9 +123,6 @@ module PaperTrailDiff
     # : (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?live_endpoint: untyped, ?snapshots: bool, ?group: Symbol?) -> ActivityTimelineBuilder
     def activity_builder: (untyped, from: untyped, to: untyped, within: untyped, ?version_scope: untyped, ?live_endpoint: untyped, ?snapshots: bool, ?group: Symbol?) -> ActivityTimelineBuilder
 
-    # : (untyped) -> void
-    def reject_live_habtm_activity!: (untyped) -> void
-
     # : (untyped) -> RecordSnapshot?
     def snapshot_for_endpoint: (untyped) -> RecordSnapshot?
 

data/sig/generated/paper_trail_diff/prepared_activity_index.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/paper_trail_diff/prepared_activity_index.rb with RBS::Inline
+
+module PaperTrailDiff
+  # Shares association event discovery across every root in a prepared graph.
+  class PreparedActivityIndex
+    # : (PreparedRecordIndex, Array[untyped], start_at: untyped, end_at: untyped) -> void
+    def initialize: (PreparedRecordIndex, Array[untyped], start_at: untyped, end_at: untyped) -> void
+
+    # : (untyped, Array[untyped]) -> void
+    def register: (untyped, Array[untyped]) -> void
+
+    # : (untyped, Array[untyped]) -> Array[untyped]
+    def versions: (untyped, Array[untyped]) -> Array[untyped]
+
+    # : (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
+    def child_ids: (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
+
+    # : (untyped, Array[untyped], untyped, ?transactions: bool) -> Array[untyped]
+    def association_rows: (untyped, Array[untyped], untyped, ?transactions: bool) -> Array[untyped]
+
+    private
+
+    @children: Hash[Array[String], untyped]
+
+    @nodes: Hash[String, Array[untyped]]
+
+    @range: ActivityRange
+
+    @records: PreparedRecordIndex
+
+    @roots: Hash[Array[String], Array[untyped]]
+
+    @rows: Hash[Array[String], Hash[String, Array[untyped]]]
+
+    # : (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
+    def historical_ids: (untyped, Array[untyped], untyped, ActivityRange) -> Array[untyped]
+
+    # : (untyped) -> Array[untyped]
+    def node_ids: (untyped) -> Array[untyped]
+
+    # : (untyped, untyped) -> untyped
+    def child_rows: (untyped, untyped) -> untyped
+
+    # Mirrors VersionAssociationCandidateScope's before-window rule. The loaded
+    # series includes changes to other owners too, so an old membership cannot
+    # survive a later pre-window reassignment just because that owner is absent.
+    # : (untyped, Array[untyped], ActivityRange) -> bool
+    def eligible_child?: (untyped, Array[untyped], ActivityRange) -> bool
+
+    # : (untyped, untyped, bool) -> Hash[String, Array[untyped]]
+    def load_association_rows: (untyped, untyped, bool) -> Hash[String, Array[untyped]]
+
+    # : (Array[untyped], bool) -> Array[untyped]
+    def version_ids: (Array[untyped], bool) -> Array[untyped]
+  end
+end

data/sig/generated/paper_trail_diff/prepared_edge_loader.rbs

@@ -46,6 +46,9 @@ module PaperTrailDiff
     # : (untyped, Array[untyped], untyped, String) -> Hash[String, Array[untyped]]
     def historical_child_ids: (untyped, Array[untyped], untyped, String) -> Hash[String, Array[untyped]]
 
+    # : (untyped, Array[Array[untyped]]) -> Array[Array[untyped]]
+    def typed_child_ids: (untyped, Array[Array[untyped]]) -> Array[Array[untyped]]
+
     # : (untyped, Array[untyped], untyped, String) -> untyped
     def historical_child_relation: (untyped, Array[untyped], untyped, String) -> untyped
 
@@ -55,9 +58,6 @@ module PaperTrailDiff
     # : (untyped, Array[untyped], untyped, String) -> Hash[String, Array[untyped]]
     def live_child_ids: (untyped, Array[untyped], untyped, String) -> Hash[String, Array[untyped]]
 
-    # : (untyped, untyped) -> untyped
-    def target_class: (untyped, untyped) -> untyped
-
     # : (Hash[String, Hash[Symbol, untyped]], untyped, untyped) -> void
     def add_identity: (Hash[String, Hash[Symbol, untyped]], untyped, untyped) -> void