rigortype 0.1.18 → 0.2.0

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

@@ -63,7 +63,7 @@ module Rigor
         }
       )
 
-      producer :worker_index do |_params|
+      producer :worker_index, watch: -> { [[@worker_search_paths, "**/*.rb"]] } do |_params|
         WorkerDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @worker_search_paths,
@@ -74,46 +74,33 @@ module Rigor
       def init(_services)
         @worker_search_paths = Array(config.fetch("worker_search_paths")).map(&:to_s)
         @worker_marker_modules = Array(config.fetch("worker_marker_modules")).map(&:to_s)
-        @worker_index = nil
-        @load_error = nil
       end
 
       # File-level only: the load-error emission. The per-call arity
       # validation runs over the engine-owned walk via the node_rule
       # below (ADR-37). The worker index is lazily loaded + memoised by
-      # worker_index_or_nil, shared by both surfaces.
+      # `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
-        index = worker_index_or_nil
-        return [load_error_diagnostic(path)] if index.nil? && @load_error
+        index = producer_value(:worker_index)
+        return [load_error_diagnostic(path)] if index.nil? && producer_error(:worker_index)
 
         []
       end
 
       node_rule Prism::CallNode do |node, _scope, path|
-        index = worker_index_or_nil
+        index = producer_value(:worker_index)
         next [] if index.nil? || index.empty?
 
-        Analyzer.violations_for(call_node: node, worker_index: index).map do |violation|
-          diagnostic(node, path: path, message: violation.message, severity: violation.severity, rule: violation.rule)
-        end
+        diagnostics_for(Analyzer.violations_for(call_node: node, worker_index: index), path: path, node: node)
       end
 
       private
 
-      def worker_index_or_nil
-        return @worker_index if @worker_index
-
-        descriptor = glob_descriptor(@worker_search_paths, "**/*.rb")
-        @worker_index = cache_for(:worker_index, params: {}, descriptor: descriptor).call
-      rescue StandardError => e
-        @load_error = "rigor-sidekiq: failed to discover workers: #{e.class}: #{e.message}"
-        nil
-      end
-
       def load_error_diagnostic(path)
+        error = producer_error(:worker_index)
         Rigor::Analysis::Diagnostic.new(
           path: path, line: 1, column: 1,
-          message: @load_error,
+          message: "rigor-sidekiq: failed to discover workers: #{error.class}: #{error.message}",
           severity: :warning,
           rule: "load-error"
         )

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

@@ -74,7 +74,7 @@ module Rigor
         block_as_methods: [
           Rigor::Plugin::Macro::BlockAsMethod.new(
             receiver_constraint: "Sinatra::Base",
-            verbs: %i[get post put delete head options patch link unlink]
+            method_names: %i[get post put delete head options patch link unlink]
           )
         ]
       )

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

@@ -168,9 +168,8 @@ module Rigor
         # contribution mirrors `T.must` minus the nil-stripping:
         # the call's return type is the inner expression's
         # inferred type. The companion diagnostic is emitted by
-        # the plugin's `diagnostics_for_file` hook through
-        # {RevealTypeRecognizer}; the recogniser here is
-        # contribution-only.
+        # the plugin's `diagnostics_for_file` hook; this
+        # method handles the contribution only.
         def resolve_reveal_type(call_node, scope)
           inner = nth_argument(call_node, 0)
           return Rigor::Type::Combinator.untyped if inner.nil? || scope.nil?

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

@@ -4,22 +4,18 @@ module Rigor
   module Plugin
     class Sorbet < Rigor::Plugin::Base
       # Frozen description of one Sorbet `sig` block as parsed by
-      # {SigParser}. Holds enough to reconstruct the method's
-      # call-site return type (slice 1's deliverable) plus the
-      # parameter shape and modifier list (kept for slice 2+ when
-      # we begin checking call-site argument types and override
-      # compatibility).
+      # {SigParser}. Holds the return type, parameter shape, and
+      # modifier list. Call-site argument-type checking and
+      # override-compatibility validation are deferred; only the
+      # return-type contribution is active.
       #
       # `kind` distinguishes `def foo` (`:instance`) from
       # `def self.foo` / `class << self; def foo; end`
       # (`:singleton`).
       #
-      # `modifiers` is the set of `sig`-level modifiers we
-      # observed: `:abstract`, `:override`, `:overridable`,
-      # `:final`. Slice 1 records them but does not act on them;
-      # later slices wire `:abstract` into the existing
-      # `def.return-type-mismatch` check and `:override` into
-      # override-compatibility validation.
+      # `modifiers` records the `sig`-level flags observed:
+      # `:abstract`, `:override`, `:overridable`, `:final`.
+      # Currently stored but not acted on.
       MethodSignature = Data.define(
         :class_name, :method_name, :kind, :params, :return_type, :modifiers
       )

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

@@ -26,9 +26,8 @@ module Rigor
       # whatever it recognises (`params` / `returns` / `void` /
       # `abstract` / `override` / `overridable` / `final` /
       # `type_parameters` / `checked` / `on_failure`) into a
-      # frozen result hash. Slice 1 wires the parsed structure
-      # into {MethodSignature}; later slices will start *acting*
-      # on the modifiers and `type_parameters`.
+      # frozen result hash stored in {MethodSignature}. Modifiers
+      # and `type_parameters` are recorded but not yet acted on.
       #
       # The parser is intentionally tolerant — unknown chain
       # nodes degrade to "the rest of the chain is opaque" rather
@@ -93,8 +92,8 @@ module Rigor
             when :params
               accumulator[:params].merge!(parse_params(current))
             when :type_parameters
-              # Slice 1: recognise to suppress the degraded
-              # path; widen translation in slice 3.
+              # Recognised to suppress the degraded path;
+              # payload intentionally discarded (deferred).
             when *RECOGNISED_MODIFIERS
               accumulator[:modifiers] << current.name
             when *RUNTIME_ONLY_STEPS

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

@@ -17,15 +17,12 @@ module Rigor
       # default) when no sigil is present, matching how Sorbet
       # treats sigil-less files.
       #
-      # Slice 5 of ADR-11 uses this purely at catalog-harvest
-      # time: `# typed: ignore` files are skipped entirely (the
-      # plugin records no sigs from them). The other levels are
-      # detected for forward compatibility but treated
-      # identically — per-call-site sigil honouring (e.g. only
-      # firing `T.let` recognition in `# typed: true`+ files)
-      # requires threading the file path through
-      # the per-call recognition path, which lives behind a
-      # future plugin-contract widening slice.
+      # ADR-11 slice 5 uses this at catalog-harvest time:
+      # `# typed: ignore` files are skipped entirely; other
+      # levels gate both sig contributions (`:true`/`:strict`/
+      # `:strong` only) and per-call assertion recognition
+      # (`T.let` / `T.cast` / `T.must` / etc.) via
+      # `Sorbet#assertion_enforced_here?`.
       module SigilDetector
         # Sorbet's strictness-level names. Stored as symbols to
         # match the analyzer's existing convention for level

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

@@ -9,14 +9,6 @@ module Rigor
       # block's `params(...)` and `returns(...)` clauses) into
       # Rigor's internal type carriers.
       #
-      # Slice 1 covered the minimum vocabulary that lets a
-      # typical `sig { params(x: Integer).returns(String) }`
-      # round-trip; slice 3 widens it to cover the dense middle
-      # of Sorbet's surface — generic class applications
-      # (`T::Array[E]`, `T::Hash[K, V]`, etc.), class-object
-      # types (`T.class_of(C)`, `T::Class[T]`), tuples, and
-      # shapes:
-      #
       # | Sorbet form              | Rigor carrier                            |
       # | ------------------------ | ---------------------------------------- |
       # | `Integer` etc.           | `Nominal["Integer"]`                     |
@@ -42,10 +34,9 @@ module Rigor
       #
       # Anything else (`T.proc`, `T.attached_class`,
       # `T.self_type`, `T.type_parameter`, `T::Struct` / `T::Enum`
-      # subclasses, …) degrades to `Dynamic[top]`. The degraded
-      # path stays silent for now per ADR-11's slice plan; a
-      # later slice surfaces the gap as a `dynamic.sorbet.unsupported`
-      # diagnostic.
+      # subclasses, …) degrades silently to `Dynamic[top]`. The
+      # `dynamic.sorbet.unsupported` diagnostic for degraded
+      # forms is deferred.
       module TypeTranslator
         BOOLEAN_NAME = "Boolean"
 
@@ -235,9 +226,8 @@ module Rigor
         # analogue (Singleton names a specific class); the
         # closest faithful translation is `Singleton[name]`
         # when `T` is a constant, or `Singleton[Object]` for
-        # broader applications. Lossy translation; emitted as
-        # `dynamic.sorbet.degraded` once slice 3's diagnostic
-        # surface lands.
+        # broader applications. Lossy — the `dynamic.sorbet.degraded`
+        # diagnostic for this case is deferred.
         def translate_t_class_subscript(args)
           inner = args.first
           return Rigor::Type::Combinator.singleton_of("Class") if inner.nil?

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

@@ -29,11 +29,10 @@ module Rigor
     #   nesting; `def self.foo` is recognised as a singleton
     #   method.
     #
-    # Slice 1 vocabulary is the bare minimum to round-trip the
-    # most common sig shapes; the {TypeTranslator} table
-    # documents what's covered. Anything else (T.proc / T::Array
-    # / T.class_of / T::Struct) degrades silently to
-    # `Dynamic[top]` for now — slice 3 widens the translator.
+    # The {TypeTranslator} table documents coverage. Most of
+    # Sorbet's vocabulary translates; remaining gaps (`T.proc`,
+    # `T::Struct` subclasses, `T.attached_class`, etc.) degrade
+    # silently to `Dynamic[top]`.
     #
     # Architecture: per-run `Catalog` is built lazily on first
     # access by walking every configured `paths:` entry's `.rb`
@@ -99,20 +98,15 @@ module Rigor
         # `false` to record every file's sigs regardless of
         # sigil (current behaviour pre-this-config).
         @enforce_sigil = config.fetch("enforce_sigil")
-        # ADR-11 deferred follow-up — per-call-site assertion
-        # gating. Catalog harvest's `@sigil_by_path` cache is
-        # consulted at every per-call recognition so
-        # `T.let` / `T.cast` / `T.must` / `T.bind` /
-        # `T.assert_type!` only fire in files Sorbet itself
-        # would enforce (`# typed: true` / `:strict` /
-        # `:strong`). When `@enforce_sigil` is off (the user
-        # opted out at harvest time), the gate also opens at
-        # every call site — current behaviour. Files whose
-        # sigil hasn't been observed yet (e.g. the catalog
-        # hasn't run, or the call site is in a fixture /
-        # synthetic path the harvest didn't see) treat
-        # missing-info as enforced — failing-open is friendlier
-        # for spec ergonomics than failing-closed.
+        # Per-call-site assertion gating: `@sigil_by_path` (built
+        # during catalog harvest) is consulted so `T.let` /
+        # `T.cast` / `T.must` / `T.bind` / `T.assert_type!` only
+        # fire in files Sorbet itself would enforce (`:true` /
+        # `:strict` / `:strong`). With `enforce_sigil: false` the
+        # gate is open everywhere. Missing-sigil paths (synthetic
+        # fixtures, out-of-tree call sites) default to enforced —
+        # failing-open suits spec ergonomics better than
+        # failing-closed. See `assertion_enforced_here?`.
         @sigil_by_path = {}
         @catalog = nil
         @parse_errors_by_path = {}
@@ -160,8 +154,7 @@ module Rigor
         diagnostics
       end
 
-      # ADR-52 slice 4 — the per-call return-type path, migrated off
-      # the legacy `flow_contribution_for` hook onto the
+      # ADR-52 slice 4 — per-call return-type path via the
       # method-name-gated `dynamic_return` DSL. The recognised name
       # set is only known at run time (the catalog's `def` names come
       # from the lazy catalog build), so it is declared as a
@@ -170,17 +163,15 @@ module Rigor
       # resolved Symbol Set. The gate is a safe over-approximation —
       # a project method merely *named* `cast` or `find` passes it
       # and is declined by the block's own `T.`-receiver / catalog
-      # checks, exactly as the ungated hook used to decline.
+      # checks.
       dynamic_return methods: -> { recognised_method_names } do |call_node, scope|
         contribution_return_type(call_node, scope)
       end
 
       # ADR-52 slice 4 — `T.bind(self, T)`'s self-narrowing fact,
-      # migrated off the legacy hook's `post_return_facts` slot onto
-      # the method-gated `type_specifier` DSL (once
-      # `flow_contribution_for` is gone, the statement evaluator
-      # consults only this path for narrowing facts). The
-      # return-type half (`Constant[nil]`) flows through the
+      # contributed via the method-gated `type_specifier` DSL. The
+      # statement evaluator consults this path for narrowing facts.
+      # The return-type half (`Constant[nil]`) flows through the
       # `dynamic_return` rule above; the block re-checks the `T.`
       # receiver via the recogniser, so an unrelated `bind` call
       # contributes nothing.
@@ -190,8 +181,8 @@ module Rigor
 
       private
 
-      # ADR-52 slice 4 — the run-time method-name gate for the
-      # `dynamic_return` rule: the static assertion vocabulary
+      # Run-time method-name gate for the `dynamic_return` rule
+      # (ADR-52 slice 4): the static assertion vocabulary
       # (`T.let` / `T.cast` / …), `T.absurd`, and every method name
       # the catalog carries a sig for.
       def recognised_method_names
@@ -202,20 +193,17 @@ module Rigor
         names
       end
 
-      # The migrated body of the legacy `flow_contribution_for` —
-      # same recognition order, but returns the bare `Rigor::Type`
-      # the `dynamic_return` contract expects. Resolves the receiver
-      # in two passes:
+      # Main contribution body for the `dynamic_return` rule.
+      # Returns the bare `Rigor::Type` the contract expects.
+      # Resolves the receiver in three passes:
       #
       # 1. Constant receiver (`User.find(...)`) → singleton-side
       #    catalog lookup.
       # 2. Nominal receiver-type (`user.name` where `user`'s
       #    inferred type is `Nominal["User"]`) → instance-side
       #    catalog lookup.
-      #
-      # Implicit-self calls (no receiver, current-class method)
-      # are deferred to slice 2 — slice 1 covers the common case
-      # where the sig is on the called method's own class.
+      # 3. Implicit-self (receiver-less inside a method body) →
+      #    current-class lookup via `implicit_self_lookup`.
       def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 
@@ -286,9 +274,8 @@ module Rigor
         contribution&.post_return_facts
       end
 
-      # ADR-11 deferred follow-up — per-call-site assertion
-      # gating. With `enforce_sigil: false`, the gate is fully
-      # open (matches the pre-feature behaviour). With
+      # Per-call-site assertion gating (ADR-11). With
+      # `enforce_sigil: false` the gate is fully open. With
       # `enforce_sigil: true` (default), the caller file's
       # sigil must reach `:true` / `:strict` / `:strong` for
       # assertions to fire. Three honest fallbacks:
@@ -329,9 +316,34 @@ module Rigor
           chain_lookup(singleton_target, method_name, anchor_kind: :singleton, mixin_kind: :extend)
         elsif receiver
           instance_chain_lookup(receiver, method_name, scope)
+        else
+          implicit_self_lookup(method_name, scope)
         end
       end
 
+      # ADR-11 slice 2 — implicit-self calls.
+      # A receiver-less call inside a method body resolves against the
+      # engine's own `scope.self_type`: `Nominal[Foo]` inside an
+      # instance method (instance-side lookup), `Singleton[Foo]` inside
+      # a `def self.x` body (singleton-side lookup, `extend` mixins).
+      # Without this, an enforced sig on a sibling method was invisible
+      # to in-class calls — the engine's body-inference tiers then
+      # re-typed the sibling's body, overriding an explicit
+      # `T.untyped` opt-out (the dispatcher's plugin tier had already
+      # run and declined). Anything else (toplevel / Dynamic / DSL
+      # self) contributes nothing and the dispatcher continues.
+      def implicit_self_lookup(method_name, scope)
+        self_type = scope&.self_type
+        case self_type
+        when Rigor::Type::Singleton
+          chain_lookup(self_type.class_name, method_name, anchor_kind: :singleton, mixin_kind: :extend)
+        when Rigor::Type::Nominal
+          chain_lookup(self_type.class_name, method_name, anchor_kind: :instance, mixin_kind: :include)
+        end
+      rescue StandardError
+        nil
+      end
+
       def instance_chain_lookup(receiver_node, method_name, scope)
         return nil if scope.nil?
 

data/sig/rigor/analysis/fact_store.rbs

@@ -2,6 +2,9 @@ module Rigor
   module Analysis
     module CheckRules
       def self?.diagnose: (path: String, root: untyped, scope_index: Hash[untyped, Scope]) -> Array[Diagnostic]
+      def self?.build_node_collectors: (String path, untyped scope_index) -> Hash[Symbol, untyped]
+      def self?.node_collector_driver: (Hash[Symbol, untyped] collectors) -> untyped
+      def self?.shadow_verify_converged_collectors: (String path, untyped root, untyped scope_index, Hash[Symbol, untyped]? collectors) -> void
     end
 
     class FactStore

data/sig/rigor/inference/builtins/method_catalog.rbs

@@ -1,4 +1,4 @@
 class Rigor::Inference::Builtins::MethodCatalog
   def initialize: (path: String, ?mutating_selectors: Hash[String, Set[untyped]]) -> void
-  def reset!: () -> nil
+  def reset!: () -> Hash[String, untyped]
 end

data/sig/rigor/plugin/base.rbs

@@ -14,7 +14,7 @@ class Rigor::Plugin::Base
   # the no-arg `manifest` reads the cached value back.
   def self.manifest: (**untyped fields) -> Rigor::Plugin::Manifest
 
-  def self.producer: (untyped id, ?serialize: untyped, ?deserialize: untyped) { (untyped params) -> untyped } -> Symbol
+  def self.producer: (untyped id, ?watch: untyped, ?serialize: untyped, ?deserialize: untyped) { (untyped params) -> untyped } -> Symbol
   def self.producers: () -> Hash[Symbol, untyped]
 
   def self.node_rule: (untyped node_type) { (*untyped) -> untyped } -> untyped
@@ -50,11 +50,14 @@ class Rigor::Plugin::Base
 
   # Authoring helpers.
   def diagnostic: (untyped node, path: untyped, message: untyped, ?severity: untyped, ?rule: untyped, ?location: untyped) -> untyped
+  def diagnostics_for: (untyped violations, path: untyped, ?node: untyped) -> Array[untyped]
+  def read_fact: (plugin_id: untyped, name: untyped) -> untyped
+  def producer_value: (untyped id, ?params: untyped) -> untyped
+  def producer_error: (untyped id) -> untyped
   def manifest: () -> Rigor::Plugin::Manifest
   def signature_paths: () -> Array[String]
   def protocol_contracts: () -> untyped
   def io_boundary: () -> Rigor::Plugin::IoBoundary
   def cache_for: (untyped producer_id, ?params: untyped, ?descriptor: untyped) -> untyped
-  def glob_descriptor: (untyped roots, *untyped patterns) -> untyped
   def plugin_entry: () -> untyped
 end

data/sig/rigor/plugin/manifest.rbs

@@ -3,7 +3,7 @@ class Rigor::Plugin::Manifest::Consumption
 end
 
 class Rigor::Plugin::Manifest
-  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?external_files: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: untyped, ?source_rbs_synthesizer: untyped, ?additional_initializers: untyped) -> void
+  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: untyped, ?source_rbs_synthesizer: untyped, ?additional_initializers: untyped) -> void
 
   # Public attribute readers (the full `attr_reader` surface). Plugins
   # read `manifest.id` / `manifest.protocol_contracts` etc.; declaring
@@ -25,7 +25,6 @@ class Rigor::Plugin::Manifest
   def heredoc_templates: () -> untyped
   def nested_class_templates: () -> untyped
   def trait_registries: () -> untyped
-  def external_files: () -> untyped
   def hkt_registrations: () -> untyped
   def hkt_definitions: () -> untyped
   def signature_paths: () -> untyped

data/sig/rigor/scope.rbs

@@ -11,6 +11,7 @@ module Rigor
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
+    attr_reader struct_fold_safe_locals: Set[Symbol]
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # DiscoveryIndex; Scope keeps per-table readers as delegates.
@@ -22,12 +23,15 @@ module Rigor
     def in_source_constants: () -> Hash[String, Type::t]
     def discovered_methods: () -> Hash[String, Hash[Symbol, Symbol]]
     def discovered_def_nodes: () -> Hash[String, Hash[Symbol, untyped]]
+    def discovered_singleton_def_nodes: () -> Hash[String, Hash[Symbol, untyped]]
     def discovered_def_sources: () -> Hash[String, Hash[Symbol, String]]
     def discovered_method_visibilities: () -> Hash[String, Hash[Symbol, Symbol]]
     def discovered_superclasses: () -> Hash[String, String]
     def discovered_includes: () -> Hash[String, Array[String]]
     def discovered_class_sources: () -> Hash[String, Set[String]]
     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]]
 
     class DiscoveryIndex
       attr_reader declared_types: Hash[untyped, Type::t]
@@ -38,16 +42,19 @@ 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_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]]
       attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
       attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
       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 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]]
 
       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_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]]) -> 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_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]]) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -66,6 +73,8 @@ 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?) -> void
     def with_source_path: (String? path) -> Scope
+    def with_struct_fold_safe: (Set[Symbol] locals) -> Scope
+    def struct_fold_safe?: (String | Symbol name) -> bool
     def with_discovery: (DiscoveryIndex index) -> Scope
     def local: (String | Symbol name) -> Type::t?
     def ivar: (String | Symbol name) -> Type::t?
@@ -75,16 +84,24 @@ module Rigor
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
     def with_cvar: (String | Symbol name, Type::t type) -> Scope
     def with_global: (String | Symbol name, Type::t type) -> Scope
+    def declaration_sourced: () -> Set[[Symbol, Symbol]]
+    def seed_declaration_sourced_ivar: (String | Symbol name, Type::t type) -> Scope
+    def with_declaration_sourced_local: (String | Symbol name, Type::t type) -> Scope
+    def with_local_declaration_mark: (String | Symbol name) -> Scope
+    def declaration_sourced?: (Symbol kind, String | Symbol name) -> bool
+    def forget_match_globals: () -> Scope
     def class_ivars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
     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 singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def top_level_def_for: (String | Symbol method_name) -> untyped?
     def toplevel?: () -> bool
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
     def superclass_of: (String | Symbol class_name) -> String?
     def data_member_layout: (String | Symbol class_name) -> Array[Symbol]?
+    def struct_member_layout: (String | Symbol class_name) -> { members: Array[Symbol], keyword_init: bool }?
     def includes_of: (String | Symbol class_name) -> Array[String]
     def indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Type::t?
     def with_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key, Type::t type) -> Scope

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
+    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Tuple | HashShape | DataClass | DataInstance | StructClass | StructInstance
 
     type accepts_mode = :strict | :gradual | :loose
 
@@ -277,6 +277,39 @@ module Rigor
       def inspect: () -> String
     end
 
+    class StructClass
+      attr_reader members: Array[Symbol]
+      attr_reader class_name: String?
+      attr_reader keyword_init: bool
+      def initialize: (Array[Symbol] members, ?String? class_name, ?keyword_init: bool) -> 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 hash: () -> Integer
+      def inspect: () -> String
+    end
+
+    class StructInstance
+      attr_reader members: Hash[Symbol, Type::t]
+      attr_reader class_name: String?
+      def initialize: (Hash[Symbol, Type::t] members, ?String? class_name) -> void
+      def member_names: () -> Array[Symbol]
+      def member_type: (Symbol name) -> Type::t?
+      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 hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class AcceptsResult
       attr_reader trinary: Trinary
       attr_reader mode: accepts_mode
@@ -339,9 +372,12 @@ module Rigor
       def self?.hash_shape_of: (?Hash[untyped, Type::t]? pairs, **untyped options) -> HashShape
       def self?.data_class_of: (members: Array[Symbol], ?class_name: String?) -> DataClass
       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?.union: (*Type::t types) -> Type::t
       def self?.key_of: (Type::t type) -> Type::t
       def self?.value_of: (Type::t type) -> Type::t
+      def self?.widen_value_pinned: (Type::t type) -> Type::t
       def self?.int_mask: (Array[Integer] flags) -> Type::t?
       def self?.int_mask_of: (Type::t type) -> Type::t?
       def self?.indexed_access: (Type::t type, Type::t key) -> Type::t

data/sig/rigor.rbs

@@ -11,7 +11,7 @@ module Rigor
     attr_reader cache_path: String
     attr_reader baseline_path: String?
 
-    def self.load: (?String path) -> Configuration
+    def self.load: (?String? path) -> Configuration
     def self.discover: () -> String?
     def self.load_with_includes: (String path, ?visited: Set[String]) -> Hash[String, untyped]
     def initialize: (?Hash[String, untyped] data) -> void

data/skills/rigor-baseline-reduce/references/01-classify.md

@@ -28,6 +28,33 @@ signal — each hint has an `id`:
 | `project-monkey-patch` | A DSL / monkey-patch Rigor can't see. | Escalate — a `pre_eval:` entry or a plugin clears the whole cluster. |
 | `activerecord-relation-misinference` | Likely an engine gap. | Treat sites as candidate false positives (Phase 2). |
 
+### `rigor triage --format json` `.selectors` — the by-(class, method) axis
+
+Beside `hints`, the triage JSON carries a `selectors` array: one row
+per dispatch target the diagnostics cluster on, built from the
+structured `receiver_type` / `method_name` fields (never message
+parsing). Each row is `{receiver, method, count, files, rules}`. Use
+it to pick *which sites within a rule* to sample first — and to tell a
+systemic cause from a scatter of real bugs — with `jq`, not eyeballing
+the stream:
+
+```sh
+# the dispatch targets responsible for the most diagnostics
+rigor triage --format json | jq -r '.selectors[:15][] | "\(.count)\t\(.files)f\t\(.receiver)#\(.method)"'
+# one method, one receiver, spread across many files → systemic
+# (a plugin / pre_eval clears it) rather than N independent bugs
+rigor triage --format json | jq '.selectors[] | select(.files >= 4)'
+# narrow to a rule you are about to work, ranked by concentration
+rigor triage --format json \
+  | jq '[.selectors[] | select(.rules["call.possible-nil-receiver"])] | sort_by(-.count)'
+```
+
+Read it as: **high `count` × high `files` = a systemic selector**
+(escalate as a decision — one fix clears the cluster); **low `count` =
+a candidate genuine bug** to sample directly in Phase 2. The `receiver`
+is a normalised class (`"hi".squish` and `name.squish` both bucket
+under `String#squish`), so a single idiom does not scatter across rows.
+
 ### `rigor baseline dump --format json` — the bucket list
 
 ```sh