rigortype 0.3.6 → 0.3.7

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq.rb

@@ -33,6 +33,11 @@ module Rigor
     #    schedule and forward the rest. Mismatches emit `wrong-arity`.
     # 2. **Missing schedule** — `perform_in()` / `perform_at()` with zero arguments emit `missing-schedule`.
     #
+    # ## What it types
+    #
+    # `perform_async` / `perform_in` / `perform_at` on a **discovered** worker return the job id, a
+    # `String` (#534) — see {JID_TYPE} for why the nil arm of `Sidekiq::Client#push` is not in the answer.
+    #
     # ## What it contributes to `rigor unused`
     #
     # The workers a schedule file names under `class:` and nothing else (ADR-102 WD3 / #367) — see
@@ -51,8 +56,12 @@ module Rigor
         id: "sidekiq",
         # Bumped 2026-08-16 — publishes `:reachability_roots` for `rigor unused` (ADR-102 WD3): the workers
         # a schedule file enqueues by name, which no `perform_async` call site writes down.
-        version: "0.2.0",
-        description: "Validates Sidekiq `Worker.perform_async` argument arity.",
+        # Bumped 2026-09-01 (#534 item 4) — the enqueue methods return the jid `String`.
+        # Bumped 2026-09-02 (#621) — worker keys are de-rooted at the producer and a reopened class's
+        # `#perform` envelope is merged rather than clobbered, so a cached 0.3.0 index can carry the
+        # any-arity row the merge replaces (and miss a schedule's reachability root under a rooted name).
+        version: "0.4.0",
+        description: "Validates Sidekiq `Worker.perform_async` argument arity and types the jid it returns.",
         config_schema: {
           "worker_search_paths" => { kind: :array, default: ["app/workers", "app/sidekiq"] },
           "worker_marker_modules" => { kind: :array, default: %w[Sidekiq::Job Sidekiq::Worker] },
@@ -144,6 +153,56 @@ module Rigor
         diagnostics_for(Analyzer.violations_for(call_node: node, worker_index: index), path: path, node: node)
       end
 
+      # Issue #534 item 4 — the enqueue methods return the job id. `Sidekiq::Client#push` ends with
+      # `payload["jid"]`, a 24-character hex `String`, and `perform_async` / `perform_in` / `perform_at`
+      # all reach it through `Setter#perform_async`. The corpus sweep counted ~90 mastodon sites reading
+      # `Dynamic[top]`.
+      #
+      # `perform_inline` is deliberately absent: it runs the job in-process and returns whatever the
+      # project's own `#perform` returns, which is a different question this plugin does not answer.
+      JID_ENTRY_METHODS = %i[perform_async perform_in perform_at].freeze
+
+      # ## Why `String` and not `String?` — adjudicated 2026-09-01, both arms measured
+      #
+      # `push` returns nil rather than a jid when a client middleware halts the chain
+      # (`payload = middleware.invoke(...) { normed }; if payload … end`), so `String | nil` is the
+      # complete reading. It is not the one that ships, and the reason is the same ordering that kept
+      # `Parameters#[]` out of rigor-actionpack (#578) — measured on a fixture of the shapes real code
+      # writes, in both directions:
+      #
+      # - **`String?`** puts `call.possible-nil-receiver` at ERROR severity on the assigned-then-used
+      #   shape — `jid = W.perform_async(id); jid.length` — which is the ordinary way to record the id you
+      #   just got. The rule restricts itself to local-variable-read receivers, so the chained
+      #   `W.perform_async(id).to_s` stays silent while the assigned form does not; the assigned form is
+      #   the only one worth typing at all. (It fires per *method*, not per use: `jid.to_s` is silent
+      #   because `NilClass` has `to_s`. That makes the noise unpredictable rather than absent.)
+      # - **`String`** draws nothing on any shape in the fixture, including the defensive `return unless
+      #   jid` and `if (jid = W.perform_async(id))` guards — the truthiness fold needs the flow to prove
+      #   a constant, and it does not fire on these.
+      #
+      # The nil arm is real but reachable only through a project's own client middleware returning false
+      # from `#call`, which is rare, deliberate, and exactly the situation where the project knows to
+      # check. Claiming non-nil there costs a missed `possible-nil-receiver` on code that already has to
+      # be written defensively; claiming nullable costs an error on the common code that does not. The
+      # spec pins both directions, and the `String?` arm is verified to go red on the assigned shape.
+      JID_TYPE = "String"
+
+      dynamic_return methods: JID_ENTRY_METHODS do |call_node, _scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+
+        index = producer_value(:worker_index)
+        next nil if index.nil? || index.empty?
+
+        # The gate is the DISCOVERED worker set, not the method name: a project's own
+        # `SomeOtherThing.perform_async` that is not a Sidekiq job keeps its own answer.
+        class_name = Analyzer.constant_receiver_name(call_node.receiver)
+        next nil if class_name.nil?
+        # `WorkerIndex#known?` de-roots the query itself (#621) — no retry arm here.
+        next nil unless index.known?(class_name)
+
+        Rigor::Type::Combinator.nominal_of(JID_TYPE)
+      end
+
       private
 
       def load_error_diagnostic(path)

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog_walker.rb

@@ -180,8 +180,8 @@ module Rigor
           return nil unless node.is_a?(Prism::CallNode) && node.receiver.nil?
           return nil unless VISIBILITY_MACROS.include?(node.name)
 
-          args = node.arguments&.arguments
-          return nil unless args&.size == 1 && args.first.is_a?(Prism::DefNode)
+          args = node.arguments&.arguments || []
+          return nil unless args.size == 1 && args.first.is_a?(Prism::DefNode)
 
           args.first
         end

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet.rb

@@ -450,7 +450,9 @@ module Rigor
       #   `[".rbi"]` for Sorbet RBI tree).
       def harvest_path(root, catalog, sigil_by_path, parse_errors_by_path, extensions)
         absolute = canonicalize(root)
-        if File.directory?(absolute)
+        # ADR-45 WD1b (#613) — boundary-probed: an `sorbet/rbi` tree (or a configured source root) that
+        # does not exist yet is a recorded dependency, so creating it invalidates the warm run.
+        if io_boundary.directory?(absolute)
           extensions.each do |ext|
             # ADR-88 WD2 — deterministic fold order matters now that the catalog VALUE is digested into the
             # incremental fact-surface fingerprint: a duplicate `(class, method, kind)` sig's last-wins winner
@@ -461,7 +463,7 @@ module Rigor
               harvest_file(canonicalize(path), catalog, sigil_by_path, parse_errors_by_path)
             end
           end
-        elsif File.file?(absolute) && extensions.any? { |ext| absolute.end_with?(ext) }
+        elsif io_boundary.file?(absolute) && extensions.any? { |ext| absolute.end_with?(ext) }
           # `paths:` may list individual files (the demos do this); walk them directly rather than skipping.
           harvest_file(absolute, catalog, sigil_by_path, parse_errors_by_path)
         end

data/sig/rigor/analysis/baseline.rbs

@@ -9,7 +9,7 @@ module Rigor
       # Load a baseline file from disk.
       # Returns `nil` when `path` is nil (no baseline configured).
       # Raises {LoadError} on malformed or unsupported content.
-      def self.load: (::String? path) -> Baseline?
+      def self.load: (::String? path, ?project_root: ::String) -> Baseline?
 
       # Build a baseline from a current run's diagnostic stream.
       def self.from_diagnostics: (untyped diagnostics, ?match_mode: :rule | :message) -> Baseline

data/sig/rigor/environment.rbs

@@ -62,7 +62,10 @@ module Rigor
       def singleton_definition: (String | Symbol class_name) -> untyped?
       def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
       def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
+      def project_declared_classes: () -> Set[String]
+      def project_declared_class?: (String | Symbol class_name) -> bool
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
+      def ancestor_names_for: (String | Symbol class_name) -> Array[String]
       def constant_type: (String name) -> Type::t?
       def constant_names: () -> Array[String]
       def each_known_class_name: () { (String name) -> void } -> untyped

data/sig/rigor/inference.rbs

@@ -136,7 +136,7 @@ module Rigor
     end
 
     module RbsTypeTranslator
-      def self.translate: (untyped rbs_type, ?self_type: Type::t?, ?instance_type: Type::t?, ?type_vars: Hash[Symbol, Type::t]) -> Type::t
+      def self.translate: (untyped rbs_type, ?self_type: Type::t?, ?instance_type: Type::t?, ?type_vars: Hash[Symbol, Type::t], ?alias_expander: untyped) -> Type::t
     end
 
     class Fallback
@@ -173,6 +173,9 @@ module Rigor
       def self?.discovered_project_index_for_paths: (Array[String] paths, ?buffer: untyped) -> Hash[Symbol, untyped]
       def self?.discovered_project_index_incremental: (Array[String] paths, seed_bundles: Hash[String, untyped], ?buffer: untyped) -> Hash[Symbol, untyped]
       def self?.collect_class_decls: (untyped node, Array[String] qualified_prefix, Hash[String, Type::t] accumulator) -> void
+      def self?.constant_writes_for_file: (untyped root) -> Hash[String, untyped]
+      def self?.constant_literal_value: (untyped rvalue) -> Array[untyped]?
+      def self?.finalize_constant_writes: (Hash[String, Hash[String, untyped]] writes) -> [Hash[String, Type::t], Hash[String, Set[String]]]
       def self?.qualified_name_for: (untyped constant_path_node) -> String?
       def self?.render_constant_path: (untyped node) -> String
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void

data/sig/rigor/plugin/io_boundary.rbs

@@ -1,6 +1,8 @@
 class Rigor::Plugin::IoBoundary
   def initialize: (policy: untyped, plugin_id: untyped, ?http_client: untyped) -> void
   def read_file: (untyped) -> String
+  def file?: (untyped) -> bool
+  def directory?: (untyped) -> bool
   def open_url: (untyped url) -> String
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).
   def cache_descriptor: () -> untyped

data/sig/rigor/reflection.rbs

@@ -2,11 +2,13 @@ module Rigor
   module Reflection
     def self?.class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
     def self?.rbs_class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
+    def self?.project_declared_class?: (String | Symbol class_name, ?scope: Scope?, ?environment: Environment?) -> bool
     def self?.class_ordering: (String | Symbol lhs, String | Symbol rhs, ?scope: Scope) -> Symbol
     def self?.nominal_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Nominal?
     def self?.singleton_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Singleton?
     def self?.constant_type_for: (String | Symbol constant_name, ?scope: Scope) -> Type::t?
-    def self?.resolve_constant_type: (String | Symbol name, ?scope: Scope) -> Type::t?
+    def self?.resolve_constant_type: (String | Symbol name, ?scope: Scope, ?rooted: bool) -> Type::t?
+    def self?.lexical_nesting_chain: (Scope scope) -> Array[String]
     def self?.instance_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped
     def self?.singleton_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped
     def self?.instance_definition: (String | Symbol class_name, ?scope: Scope) -> untyped

data/sig/rigor/scope.rbs

@@ -12,6 +12,7 @@ module Rigor
     attr_reader local_origins: Hash[Symbol, Symbol]
     attr_reader ivar_origins: Hash[Symbol, Symbol]
     attr_reader void_origins: Hash[untyped, Inference::VoidOrigin]
+    attr_reader plugin_typed_calls: Hash[untyped, bool]
     attr_reader optimistic_origins: Hash[untyped, Symbol]
     attr_reader optimistic_locals: Hash[Symbol, Symbol]
     attr_reader optimistic_ivars: Hash[Symbol, Symbol]
@@ -20,6 +21,7 @@ module Rigor
     attr_reader source_path: String?
     attr_reader struct_fold_safe_locals: Set[Symbol]
     attr_reader opaque_block_self: bool
+    attr_reader lexical_nesting: Array[String]?
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # DiscoveryIndex; Scope keeps per-table readers as delegates.
@@ -38,6 +40,11 @@ module Rigor
     def discovered_superclasses: () -> Hash[String, String]
     def discovered_includes: () -> Hash[String, Array[String]]
     def discovered_class_sources: () -> Hash[String, Set[String]]
+    def constant_sources: () -> Hash[String, Set[String]]
+    def published_constant_names: () -> Set[String]
+    def local_constant_names: () -> Set[String]
+    def published_constant?: (String name) -> bool
+    def record_constant_dependency: (String name) -> void
     def data_member_layouts: () -> Hash[String, Array[Symbol]]
     def struct_member_layouts: () -> Hash[String, { members: Array[Symbol], keyword_init: bool }]
     def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
@@ -47,6 +54,9 @@ module Rigor
 
     def record_void_origin: (untyped node, Inference::VoidOrigin origin) -> Scope
 
+    def record_plugin_typed_call: (untyped node) -> Scope
+    def plugin_typed_call?: (untyped node) -> bool
+
     class DiscoveryIndex
       attr_reader declared_types: Hash[untyped, Type::t]
       attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
@@ -56,6 +66,7 @@ module Rigor
       attr_reader in_source_constants: Hash[String, Type::t]
       attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
       attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
+      attr_reader discovered_def_nestings: Hash[untyped, Array[String]]
       attr_reader discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]]
       attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
       attr_reader discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]]
@@ -63,6 +74,9 @@ module Rigor
       attr_reader discovered_superclasses: Hash[String, String]
       attr_reader discovered_includes: Hash[String, Array[String]]
       attr_reader discovered_class_sources: Hash[String, Set[String]]
+      attr_reader constant_sources: Hash[String, Set[String]]
+      attr_reader published_constant_names: Set[String]
+      attr_reader local_constant_names: Set[String]
       attr_reader data_member_layouts: Hash[String, Array[Symbol]]
       attr_reader struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }]
       attr_reader param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
@@ -70,7 +84,7 @@ module Rigor
 
       EMPTY: DiscoveryIndex
 
-      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?run_generation: Object?) -> DiscoveryIndex
+      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?run_generation: Object?) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -90,6 +104,7 @@ module Rigor
     def initialize: (environment: Environment, locals: Hash[Symbol, Type::t], ?fact_store: Analysis::FactStore, ?self_type: Type::t?, ?ivars: Hash[Symbol, Type::t], ?cvars: Hash[Symbol, Type::t], ?globals: Hash[Symbol, Type::t], ?discovery: DiscoveryIndex, ?source_path: String?, ?dynamic_origins: Hash[untyped, Symbol]) -> void
     def with_source_path: (String? path) -> Scope
     def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
+    def with_lexical_nesting: (Array[String]? chain) -> Scope
     def struct_fold_safe?: (String | Symbol name) -> bool
     def entering_opaque_block: () -> Scope
     def opaque_block_self?: () -> bool
@@ -123,8 +138,17 @@ module Rigor
     def class_cvars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
     def discovered_method?: (String | Symbol class_name, String | Symbol method_name, Symbol kind) -> bool
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
+    def user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> [untyped?, String?]
+    def discovered_method_through_ancestors?: (String | Symbol? class_name, String | Symbol method_name, Symbol kind, ?name_memo: Hash[untyped, untyped]) -> bool
+    def enqueue_ancestors: (String current, Array[String] queue, Hash[untyped, untyped] name_memo, ?mixins: bool) -> void
+    def ancestor_name_candidates: (String | Symbol subclass_qualified, String | Symbol raw_ancestor) -> Array[String]
+
+    # Issue #530 — public so the external-gem ancestry probe asks the same question the walk does.
+    def known_user_class?: (String | Symbol name) -> bool
     def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
+    def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> [untyped?, String?]
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
+    def user_singleton_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def top_level_def_for: (String | Symbol method_name) -> untyped?
     def bindable_top_level_def_for: (String | Symbol method_name) -> untyped?
     def toplevel?: () -> bool

data/sig/rigor/type.rbs

@@ -1,6 +1,6 @@
 module Rigor
   module Type
-    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Tuple | HashShape | DataClass | DataInstance | StructClass | StructInstance
+    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Refined | Intersection | Tuple | HashShape | DataClass | DataInstance | StructClass | StructInstance | BoundMethod | Result | Maybe | App
 
     type accepts_mode = :strict | :gradual | :loose
 
@@ -36,6 +36,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> "#<Rigor::Type::Top>"
     end
@@ -49,6 +50,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> "#<Rigor::Type::Bot>"
     end
@@ -63,12 +65,16 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
 
     class Constant
+      SCALAR_CLASSES: Array[Class]
+      RBS_LITERAL_CLASSES: Hash[Class, String]
       attr_reader value: untyped
+      def freezable_carrier?: (untyped value) -> bool
       def initialize: (untyped value) -> void
       def describe: (?Symbol verbosity) -> String
       def erase_to_rbs: () -> String
@@ -77,6 +83,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -84,6 +91,8 @@ module Rigor
     class IntegerRange
       NEG_INFINITY: Symbol
       POS_INFINITY: Symbol
+      INFINITIES: Array[Symbol]
+      ALIAS_NAMES: Hash[[Integer | Symbol, Integer | Symbol], String]
       attr_reader min: (Integer | Symbol)
       attr_reader max: (Integer | Symbol)
       def initialize: ((Integer | Symbol) min, (Integer | Symbol) max) -> void
@@ -101,6 +110,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -116,6 +126,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -130,6 +141,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -144,6 +156,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -159,6 +172,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -175,6 +189,7 @@ module Rigor
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def matches?: (untyped value) -> bool?
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -190,6 +205,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -204,6 +220,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -218,6 +235,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -241,6 +259,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -256,6 +275,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -273,6 +293,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -289,6 +310,7 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
     end
@@ -306,8 +328,78 @@ module Rigor
       def dynamic: () -> Trinary
       def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
       def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Result
+      attr_reader ok_type: Type::t
+      attr_reader err_type: Type::t
+      alias success_type ok_type
+      alias failure_type err_type
+      def initialize: (Type::t ok_type, Type::t err_type) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class Maybe
+      attr_reader value_type: Type::t
+      def initialize: (Type::t value_type) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class App
+      URI_SEPARATOR: String
+      attr_reader uri: Symbol
+      attr_reader args: Array[Type::t]
+      attr_reader bound: Type::t
+      def initialize: (Symbol uri, Array[Type::t] args, bound: Type::t) -> void
+      def describe: (?Symbol verbosity) -> String
+      def erase_to_rbs: () -> String
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
       def hash: () -> Integer
       def inspect: () -> String
+      def reduce: (untyped registry, ?fuel: Integer?) -> Type::t
+    end
+
+    module PlainLattice
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+    end
+
+    module AcceptanceRouter
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+    end
+
+    module AnonymousClassName
+      PREFIX: String
+      def self?.build: (String | Symbol label, String key) -> String
+      def self?.match?: (untyped class_name) -> bool
+      def self?.display: (String class_name) -> String
     end
 
     class AcceptsResult
@@ -374,6 +466,8 @@ module Rigor
       def self?.data_instance_of: (members: Hash[Symbol, Type::t], ?class_name: String?) -> DataInstance
       def self?.struct_class_of: (members: Array[Symbol], ?class_name: String?, ?keyword_init: bool) -> StructClass
       def self?.struct_instance_of: (members: Hash[Symbol, Type::t], ?class_name: String?) -> StructInstance
+      def self?.result_of: (Type::t ok_type, Type::t err_type) -> Result
+      def self?.maybe_of: (Type::t value_type) -> Maybe
       def self?.union: (*Type::t types) -> Type::t
       def self?.key_of: (Type::t type) -> Type::t
       def self?.value_of: (Type::t type) -> Type::t

data/sig/rigor.rbs

@@ -141,6 +141,22 @@ module Rigor
       # #387 — the loaded plugins' compiled effect contributions, read by `rigor effects` so the snapshot's
       # vocabulary is the one the collection window scanned under. Same `untyped` reasoning again.
       def effect_plugin_facts: () -> untyped
+      # The incremental session's read surface (ADR-46 / ADR-67 / ADR-103) — `IncrementalSession`
+      # drives a live Runner through these between rechecks. Typed `untyped` like the cache / effects
+      # readers above until their namespaces are sig-covered.
+      def return_summaries: () -> untyped
+      def param_inferred_types: () -> untyped
+      def effect_collections_by_path: () -> untyped
+      def collect_param_inference_table: (untyped files) -> untyped
+      def evaluate_return_types: (untyped paths, untyped specs) -> untyped
+    end
+  end
+
+  module ValueSemantics
+    def self.included: (Module base) -> void
+
+    module ClassMethods
+      def value_fields: (*Symbol fields) -> void
     end
   end
 end