rigortype 0.1.3 → 0.1.4

data/lib/rigor/inference/method_dispatcher.rb

@@ -12,6 +12,7 @@ require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/block_folding"
 require_relative "method_dispatcher/file_folding"
 require_relative "method_dispatcher/kernel_dispatch"
+require_relative "method_dispatcher/method_folding"
 
 module Rigor
   module Inference
@@ -61,11 +62,18 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/ParameterLists
+      def dispatch(receiver_type:, method_name:, arg_types:,
                    block_type: nil, environment: nil,
                    call_node: nil, scope: nil)
         return nil if receiver_type.nil?
 
+        bound_method_result = MethodFolding.try_backward(
+          receiver: receiver_type, method_name: method_name, args: arg_types,
+          block_type: block_type, environment: environment,
+          call_node: call_node, scope: scope
+        )
+        return bound_method_result if bound_method_result
+
         precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
         return precise if precise
 
@@ -84,7 +92,10 @@ module Rigor
           receiver: receiver_type, method_name: method_name, args: arg_types,
           environment: environment, block_type: block_type
         )
-        return rbs_result if rbs_result
+        if rbs_result
+          record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
+          return rbs_result
+        end
 
         # ADR-10 slice 2b-ii — dependency-source inference tier.
         # Sits BELOW RBS dispatch (RBS / RBS::Inline / generated
@@ -98,6 +109,21 @@ module Rigor
         dep_source_result = try_dependency_source(receiver_type, method_name, environment)
         return dep_source_result if dep_source_result
 
+        # v0.1.3 — discovered-method dispatch tier. When the
+        # receiver class has no RBS BUT scope_indexer recorded
+        # `def method_name` for that class (or singleton), the
+        # call dispatches to `Dynamic[top]` rather than falling
+        # through to the user-class fallback. Sits below RBS /
+        # dependency-source so authoritative signatures still win.
+        # The scope-indexer-built table records every project-side
+        # `def`, `define_method`, and `alias_method`; the
+        # `discovered_method?` consult here closes the
+        # fail-soft-event hot spot on implicit-self calls
+        # (`sibling_private(...)`) inside `lib/rigor/`'s own
+        # internals (analyser private helpers don't have RBS).
+        discovered_result = try_discovered_method(receiver_type, method_name, scope)
+        return discovered_result if discovered_result
+
         # Slice 7 phase 10 — user-class ancestor fallback. When
         # the receiver is `Nominal[T]` or `Singleton[T]` for a
         # class not in the RBS environment (typically a
@@ -112,6 +138,58 @@ module Rigor
         try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type)
       end
 
+      # v0.1.3 — discovered-method dispatch tier. `scope` carries
+      # the `discovered_methods` table built once per program by
+      # `ScopeIndexer` (a `Hash[String, Hash[Symbol, :instance |
+      # :singleton]]`). When the receiver names a discovered
+      # class AND the requested method is recorded for that
+      # class's appropriate kind, return `Type::Combinator.untyped`
+      # — the dispatcher cannot infer a more precise return type
+      # from the bare `def` shape, but the call site stops being a
+      # fail-soft hot spot.
+      #
+      # Returns `nil` when scope / receiver class is unavailable,
+      # when the method is not in the discovered table, OR when
+      # `discovered_def_nodes` carries a re-typable body for the
+      # method (so the downstream
+      # `ExpressionTyper#try_user_method_inference` tier can
+      # re-type the body for a precise return type rather than
+      # collapsing to `Dynamic[top]` here).
+      #
+      # The tier does NOT gate on `rbs_class_known?`. RBS dispatch
+      # already had its turn upstream and returned `nil` (otherwise
+      # we wouldn't be here). When RBS knows the class but the
+      # particular method is missing from the sig — common for
+      # internal helpers and for auto-generated stubs that emit
+      # `class X` without enumerating every method — falling
+      # through to the user-class fallback would mistakenly fire
+      # `call.undefined-method`. Honoring the discovered table
+      # here keeps the sibling-private call resolution working
+      # under partial RBS coverage.
+      def try_discovered_method(receiver_type, method_name, scope)
+        return nil if scope.nil?
+
+        class_name, kind = discovered_method_lookup(receiver_type)
+        return nil if class_name.nil?
+        return nil unless scope.discovered_method?(class_name, method_name, kind)
+        return nil if kind == :instance && scope.user_def_for(class_name, method_name)
+
+        Type::Combinator.untyped
+      end
+
+      # Resolves the `(class_name, kind)` pair scope_indexer keys
+      # its `discovered_methods` table on. `Nominal[X]` looks up
+      # instance methods on X; `Singleton[X]` looks up singleton
+      # methods on X. Other carriers return `[nil, nil]` so the
+      # tier declines.
+      def discovered_method_lookup(receiver_type)
+        case receiver_type
+        when Type::Nominal then [receiver_type.class_name, :instance]
+        when Type::Singleton then [receiver_type.class_name, :singleton]
+        else [nil, nil]
+        end
+      end
+
       # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
       # slice 7. Walks every loaded plugin's
       # `#flow_contribution_for(call_node:, scope:)` hook,
@@ -177,6 +255,71 @@ module Rigor
         budget_silence_result(class_name, index, environment)
       end
 
+      # ADR-10 slice 5c — record a
+      # `dynamic.dependency-source.boundary-cross` event when
+      # RBS dispatch resolves a call AND the receiver class
+      # belongs to a `mode: :full` opt-in gem whose Walker
+      # also catalogued the same `(class_name, method_name)`.
+      # The dispatcher still returns the RBS answer (per
+      # ADR-10's tier order: authoritative-source wins), but
+      # the reporter accumulates the crossing for end-of-run
+      # audit diagnostics.
+      #
+      # Five honest fall-throughs keep the gate narrow:
+      #
+      # - environment / index / reporter missing — slice 5c
+      #   needs all three.
+      # - receiver has no nominal class name (Dynamic-only
+      #   carriers) — nothing to look up.
+      # - receiver class doesn't belong to a `mode: :full` gem
+      #   — the user didn't opt this gem into the distinct
+      #   dispatch path.
+      # - the gem-source catalog has no entry for the method —
+      #   only RBS knows about it; nothing to cross.
+      # - the RBS-side result is itself `Dynamic[Top]` — the
+      #   "agreement" is trivially `untyped ≈ untyped`, no
+      #   meaningful divergence to flag.
+      def record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
+        class_name = boundary_cross_class_name(receiver_type, environment, rbs_result)
+        return if class_name.nil?
+
+        index = environment.dependency_source_index
+        return unless index.full_mode?(class_name)
+        return unless index.contribution_for(class_name: class_name, method_name: method_name)
+
+        environment.boundary_cross_reporter.record(
+          class_name: class_name, method_name: method_name,
+          gem_name: index.gem_for(class_name),
+          rbs_display: rbs_display_for(rbs_result)
+        )
+      end
+
+      # Composite preflight for {#record_boundary_cross_if_applicable}.
+      # Returns the receiver class name only when every prerequisite
+      # for emitting the diagnostic is satisfied (environment carries
+      # an index + reporter, receiver is a nominal carrier, RBS-side
+      # result is not the trivial `Dynamic[Top]` envelope). Returns
+      # `nil` to short-circuit otherwise.
+      def boundary_cross_class_name(receiver_type, environment, rbs_result)
+        return nil if environment.nil?
+        return nil if environment.dependency_source_index.nil?
+        return nil if environment.dependency_source_index.empty?
+        return nil if environment.boundary_cross_reporter.nil?
+        return nil if rbs_result_untyped?(rbs_result)
+
+        dep_source_class_name(receiver_type)
+      end
+
+      def rbs_result_untyped?(rbs_result)
+        rbs_result.is_a?(Type::Dynamic) && rbs_result.static_facet.is_a?(Type::Top)
+      end
+
+      def rbs_display_for(rbs_result)
+        return "untyped" if rbs_result.nil?
+
+        rbs_result.respond_to?(:describe) ? rbs_result.describe : rbs_result.inspect
+      end
+
       def budget_silence_result(class_name, index, _environment)
         return nil unless index.budget_overrun_strategy == :dependency_silence
 
@@ -242,6 +385,7 @@ module Rigor
           ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
+          MethodFolding.try_forward(receiver: receiver_type, method_name: method_name, args: arg_types) ||
           BlockFolding.try_fold(
             receiver: receiver_type, method_name: method_name, args: arg_types, block_type: block_type
           )

data/lib/rigor/inference/method_parameter_binder.rb

@@ -32,7 +32,6 @@ module Rigor
     # `#singleton_method`.
     #
     # See docs/internal-spec/inference-engine.md for the binding contract.
-    # rubocop:disable Metrics/ClassLength
     class MethodParameterBinder
       # @param environment [Rigor::Environment]
       # @param class_path [String, nil] the qualified name of the class
@@ -175,7 +174,7 @@ module Rigor
       # `non-empty-array[Integer]` describe the parameter binding
       # they actually want, not its element type.
       def apply_param_overrides(types, slots, rbs_method)
-        override_map = RbsExtended.param_type_override_map(rbs_method)
+        override_map = RbsExtended.param_type_override_map(rbs_method, environment: @environment)
         return if override_map.empty?
 
         slots.each do |slot|
@@ -275,6 +274,5 @@ module Rigor
         end
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rigor/inference/narrowing.rb

@@ -376,7 +376,7 @@ module Rigor
       # the predicate shape is recognised, or `nil` to signal "no
       # narrowing" so the public surface can fall back to the entry
       # scope.
-      def analyse(node, scope) # rubocop:disable Metrics/CyclomaticComplexity
+      def analyse(node, scope)
         case node
         when Prism::ParenthesesNode
           analyse_parentheses(node, scope)
@@ -445,7 +445,6 @@ module Rigor
         # intersects each half with the integer-domain parts of
         # `current_type`. Non-integer parts of a Union receiver
         # (nil, String, …) survive unchanged.
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def complement_integer_range(current_type, range)
           halves = integer_range_complement_halves(range)
           parts = current_type.is_a?(Type::Union) ? current_type.members : [current_type]
@@ -466,7 +465,6 @@ module Rigor
 
           Type::Combinator.union(*survivors)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # Returns the two open halves of an IntegerRange's
         # complement: the left half `int<-∞, a-1>` (when `a` is
@@ -1337,7 +1335,7 @@ module Rigor
           method_def = resolve_rbs_extended_method(node, scope)
           return nil if method_def.nil?
 
-          contribution = RbsExtended.read_flow_contribution(method_def)
+          contribution = RbsExtended.read_flow_contribution(method_def, environment: scope.environment)
           return nil if contribution.nil?
 
           result = Rigor::FlowContribution::Merger.merge([contribution])

data/lib/rigor/inference/rbs_type_translator.rb

@@ -41,7 +41,6 @@ module Rigor
     #   `Nominal[C]` regardless of which method body we are in.
     # When either argument is omitted, the corresponding token degrades
     # to Dynamic[Top].
-    # rubocop:disable Metrics/ModuleLength
     module RbsTypeTranslator
       # Hash-based dispatch keeps `translate` linear and dodges the
       # bookkeeping costs of a 20-arm `case` (RuboCop AbcSize/CCN/Length
@@ -214,6 +213,5 @@ module Rigor
         end
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rigor/inference/scope_indexer.rb

@@ -57,9 +57,19 @@ module Rigor
         # `Scope#with_local` / `#with_fact` / `#with_self_type`
         # propagates it across every derived scope.
         declared_types, discovered_classes = build_declaration_artifacts(root)
+        # Merge the indexer's findings on top of whatever the
+        # base scope already carries so callers that seed
+        # cross-file class knowledge (e.g. the ADR-14
+        # `SigGen::ObservationCollector` pre-walking project
+        # `lib/` before scanning `spec/`) keep their seeds
+        # alongside the per-file declarations the indexer
+        # itself discovers. Indexer-found entries win on
+        # collision — same-file declarations are the most
+        # specific authority.
+        merged_classes = default_scope.discovered_classes.merge(discovered_classes)
         seeded_scope = default_scope
                        .with_declared_types(declared_types)
-                       .with_discovered_classes(discovered_classes)
+                       .with_discovered_classes(merged_classes)
 
         # Slice 7 phase 2. Pre-pass over every class/module body
         # to collect the per-class ivar accumulator. Seeded after
@@ -300,7 +310,7 @@ module Rigor
         accumulator.freeze
       end
 
-      def walk_constant_writes(node, qualified_prefix, default_scope, accumulator) # rubocop:disable Metrics/CyclomaticComplexity
+      def walk_constant_writes(node, qualified_prefix, default_scope, accumulator)
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -348,7 +358,7 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def walk_methods(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -385,7 +395,7 @@ module Rigor
           walk_methods(child, qualified_prefix, in_singleton_class, accumulator)
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
@@ -430,7 +440,6 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def walk_def_nodes(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -462,8 +471,6 @@ module Rigor
           walk_def_nodes(child, qualified_prefix, in_singleton_class, accumulator)
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-
       # v0.0.3 A — sentinel key under which `record_def_node`
       # files DefNodes that live outside any class / module
       # body (top-level helpers, `def`s nested inside DSL
@@ -646,7 +653,6 @@ module Rigor
 
       # Builds a map `{class_name => {new_name_sym => old_name_sym}}` by
       # walking the tree for `AliasMethodNode` nodes inside class bodies.
-      # rubocop:disable Metrics/CyclomaticComplexity
       def collect_class_alias_map(node, qualified_prefix, accumulator)
         return accumulator unless node.is_a?(Prism::Node)
 
@@ -667,7 +673,6 @@ module Rigor
         node.compact_child_nodes.each { |child| collect_class_alias_map(child, qualified_prefix, accumulator) }
         accumulator
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def record_alias_map_entry(alias_node, qualified_prefix, accumulator)
         return if qualified_prefix.empty?

data/lib/rigor/inference/statement_evaluator.rb

@@ -889,7 +889,7 @@ module Rigor
       # or nil otherwise. Centralised so each per-matcher
       # decoder can short-circuit on a non-matching outer
       # call.
-      def rspec_expectation_target(call_node) # rubocop:disable Metrics/CyclomaticComplexity
+      def rspec_expectation_target(call_node)
         receiver = call_node.receiver
         return nil unless receiver.is_a?(Prism::CallNode) && receiver.name == :expect
         return nil unless receiver.receiver.nil?
@@ -967,7 +967,7 @@ module Rigor
         method_def = resolve_call_method(call_node, current_scope)
         return current_scope if method_def.nil?
 
-        contribution = RbsExtended.read_flow_contribution(method_def)
+        contribution = RbsExtended.read_flow_contribution(method_def, environment: current_scope.environment)
         return current_scope if contribution.nil?
 
         result = Rigor::FlowContribution::Merger.merge([contribution])
@@ -1034,7 +1034,7 @@ module Rigor
         end
       end
 
-      def resolve_call_method(call_node, current_scope) # rubocop:disable Metrics/PerceivedComplexity
+      def resolve_call_method(call_node, current_scope)
         receiver_node = call_node.receiver
         receiver_type =
           if receiver_node
@@ -1120,7 +1120,7 @@ module Rigor
         end
       end
 
-      def lookup_post_return_arg(call_node, method_def, target_name) # rubocop:disable Metrics/CyclomaticComplexity
+      def lookup_post_return_arg(call_node, method_def, target_name)
         # Plugin-source contributions arrive without an
         # authoritative method_def (the plugin recognised the
         # call shape directly). Parameter-targeting falls back
@@ -1394,6 +1394,8 @@ module Rigor
              .with_class_ivars(scope.class_ivars)
              .with_class_cvars(scope.class_cvars)
              .with_program_globals(scope.program_globals)
+             .with_discovered_methods(scope.discovered_methods)
+             .with_discovered_method_visibilities(scope.discovered_method_visibilities)
       end
 
       def singleton_def?(def_node)
@@ -1501,7 +1503,7 @@ module Rigor
       EXIT_CALL_NAMES = %i[raise throw exit abort fail].freeze
       private_constant :EXIT_CALL_NAMES
 
-      def branch_unconditionally_exits?(node) # rubocop:disable Metrics/CyclomaticComplexity
+      def branch_unconditionally_exits?(node)
         return false if node.nil?
 
         case node
@@ -1607,7 +1609,6 @@ module Rigor
       # Returns an array of `[Symbol, Rigor::Type]` pairs for every
       # variable captured by `pattern`. Unrecognised pattern nodes
       # contribute no bindings (fail-soft).
-      # rubocop:disable Metrics/CyclomaticComplexity
       def collect_in_pattern_bindings(subject, pattern, scope)
         case pattern
         when Prism::CapturePatternNode
@@ -1629,7 +1630,6 @@ module Rigor
           []
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def collect_array_pattern_bindings(pattern, scope)
         bindings = [*pattern.requireds, *pattern.posts].flat_map do |elem|

data/lib/rigor/plugin/io_boundary.rb

@@ -137,7 +137,6 @@ module Rigor
     # to the same `#get(url, timeout:, max_bytes:)` shape so the
     # tests don't require network access.
     class DefaultHttpClient
-      # rubocop:disable Metrics/MethodLength
       def get(url, timeout:, max_bytes:)
         require "net/http"
         require "uri"
@@ -169,7 +168,6 @@ module Rigor
         end
         body
       end
-      # rubocop:enable Metrics/MethodLength
     end
   end
 end

data/lib/rigor/plugin/loader.rb

@@ -81,7 +81,7 @@ module Rigor
       #   "rigor-rails"
       #   { "gem" => "rigor-rails", "id" => "rails", "config" => {...} }
       #   { gem: "rigor-rails", id: "rails", config: {...} }
-      def normalise_entry(raw, index) # rubocop:disable Metrics/CyclomaticComplexity
+      def normalise_entry(raw, index)
         case raw
         when String
           { gem: raw, id: nil, config: {} }
@@ -136,7 +136,7 @@ module Rigor
         )
       end
 
-      def lookup_plugin_class!(entry, newly_registered) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      def lookup_plugin_class!(entry, newly_registered)
         if entry[:id]
           plugin_class = Plugin.registered_for(entry[:id])
           unless plugin_class

data/lib/rigor/plugin/manifest.rb

@@ -11,7 +11,7 @@ module Rigor
     # The fields are pinned by ADR-2 § "Registration, Configuration,
     # and Caching"; the v0.1.0 plugin contract surface treats this
     # struct as the public manifest shape.
-    class Manifest # rubocop:disable Metrics/ClassLength
+    class Manifest
       # Same regex {Rigor::Cache::Store::VALID_PRODUCER_ID} uses,
       # so plugin ids round-trip through cache producer ids and
       # `plugin.<id>.<rule>` diagnostic identifiers without escape.
@@ -31,19 +31,19 @@ module Rigor
       # topological sort + missing-producer detection (slice 5);
       # slice 4 carries the declarations on the manifest but the
       # loader does not yet enforce them.
-      Consumption = Data.define(:plugin_id, :name, :optional) do
+      class Consumption < Data.define(:plugin_id, :name, :optional)
         def initialize(plugin_id:, name:, optional: false)
           super(plugin_id: plugin_id.to_s, name: name.to_sym, optional: optional ? true : false)
         end
       end
 
       attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes,
-                  :owns_receivers
+                  :owns_receivers, :type_node_resolvers
 
       def initialize( # rubocop:disable Metrics/ParameterLists
         id:, version:,
         description: nil, protocols: [], config_schema: {},
-        produces: [], consumes: [], owns_receivers: []
+        produces: [], consumes: [], owns_receivers: [], type_node_resolvers: []
       )
         validate_id!(id)
         validate_version!(version)
@@ -51,15 +51,18 @@ module Rigor
         validate_config_schema!(config_schema)
         validate_produces!(produces)
         validate_owns_receivers!(owns_receivers)
+        validate_type_node_resolvers!(type_node_resolvers)
 
-        assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers)
+        assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
+                      type_node_resolvers)
         freeze
       end
 
       private
 
-      # rubocop:disable Metrics/ParameterLists,Metrics/AbcSize
-      def assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers)
+      # rubocop:disable Metrics/ParameterLists
+      def assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
+                        type_node_resolvers)
         @id = id.dup.freeze
         @version = version.dup.freeze
         @description = description.nil? ? nil : description.to_s.dup.freeze
@@ -68,8 +71,9 @@ module Rigor
         @produces = produces.map(&:to_sym).freeze
         @consumes = coerce_consumes(consumes)
         @owns_receivers = owns_receivers.map { |c| c.to_s.dup.freeze }.freeze
+        @type_node_resolvers = type_node_resolvers.dup.freeze
       end
-      # rubocop:enable Metrics/ParameterLists,Metrics/AbcSize
+      # rubocop:enable Metrics/ParameterLists
 
       public
 
@@ -105,7 +109,8 @@ module Rigor
           "config_schema" => config_schema.to_h { |k, v| [k, v.to_s] },
           "produces" => produces.map(&:to_s),
           "consumes" => consumes.map { |c| consumption_hash(c) },
-          "owns_receivers" => owns_receivers
+          "owns_receivers" => owns_receivers,
+          "type_node_resolvers" => type_node_resolvers.map { |r| r.class.name }
         }
       end
 
@@ -187,6 +192,22 @@ module Rigor
               "got #{owns_receivers.inspect}"
       end
 
+      # ADR-13 slice 2 — `type_node_resolvers:` declares the
+      # plugin-supplied `TypeNodeResolver` instances the parser
+      # consults (in slice 3) when an RBS::Extended payload's
+      # named- or generic-type head misses the built-in registry.
+      # Slice 2 carries the declarations on the manifest and the
+      # registry exposes them in registration order; the parser
+      # integration that actually drives the chain lands in
+      # slice 3.
+      def validate_type_node_resolvers!(resolvers)
+        return if resolvers.is_a?(Array) && resolvers.all?(TypeNodeResolver)
+
+        raise ArgumentError,
+              "plugin manifest type_node_resolvers must be an Array of " \
+              "Rigor::Plugin::TypeNodeResolver instances, got #{resolvers.inspect}"
+      end
+
       def coerce_consumes(consumes)
         unless consumes.is_a?(Array)
           raise ArgumentError, "plugin manifest consumes must be an Array, got #{consumes.inspect}"

data/lib/rigor/plugin/registry.rb

@@ -44,6 +44,17 @@ module Rigor
         !load_errors.empty?
       end
 
+      # ADR-13 slice 2 — flat ordered list of every loaded
+      # plugin's manifest-declared {TypeNodeResolver} instances,
+      # in plugin registration order. Slice 3 wires this into
+      # the parser's resolver chain; until then the method is a
+      # read-side aggregator only. The first non-nil
+      # `#resolve(node, scope)` return wins per ADR-13 WD3 / WD5
+      # — registration order is the user's lever.
+      def type_node_resolvers
+        plugins.flat_map { |plugin| plugin.manifest.type_node_resolvers }
+      end
+
       EMPTY = new.freeze
     end
   end

data/lib/rigor/plugin/services.rb

@@ -42,7 +42,7 @@ module Rigor
     class Services
       attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy, :fact_store
 
-      def initialize( # rubocop:disable Metrics/ParameterLists
+      def initialize(
         reflection:, type:, configuration:,
         cache_store: nil, trust_policy: nil, fact_store: nil
       )

data/lib/rigor/plugin/type_node_resolver.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # Plugin-supplied resolver for custom named / generic type
+    # vocabulary in RBS::Extended payloads. ADR-13 § "Decision".
+    #
+    # Subclasses override {#resolve} to return a
+    # {Rigor::Type::Base} when the node matches the vocabulary
+    # the resolver covers, or `nil` to fall through to the next
+    # resolver in the chain (and finally to the built-in / RBS
+    # fallback). The base implementation returns `nil` so an
+    # unimplemented subclass is a safe no-op.
+    #
+    # Resolvers are registered through their plugin's manifest
+    # under the `type_node_resolvers:` slot:
+    #
+    #   class RigorTypescriptUtilityTypes < Rigor::Plugin::Base
+    #     manifest(
+    #       id: "typescript-utility-types",
+    #       version: "0.1.0",
+    #       type_node_resolvers: [Resolvers::Pick.new,
+    #                             Resolvers::Omit.new]
+    #     )
+    #   end
+    #
+    # Slice 2 of the ADR-13 envelope (this file) ships the base
+    # class + manifest hook + registry aggregation. The parser-
+    # side wiring that actually consults the resolver chain
+    # arrives in slice 3, when {Rigor::TypeNode::NameScope} and
+    # the dispatcher between {Rigor::Builtins::ImportedRefinements::Parser}
+    # and the chain land. Until then resolvers can be unit-tested
+    # in isolation but never run for a real `%a{rigor:v1:...}`
+    # payload.
+    #
+    # Resolvers SHOULD be stateless and re-entrant; the registry
+    # builds the chain once per `Analysis::Runner.run` and may
+    # consult any resolver multiple times for the same node.
+    class TypeNodeResolver
+      # @param node [Rigor::TypeNode::Identifier, Rigor::TypeNode::Generic]
+      #   the parser-emitted node the chain is asking about.
+      # @param scope [Rigor::TypeNode::NameScope] companion
+      #   value object (slice 3); slice 2 invocations MAY pass
+      #   `nil` because the chain doesn't exist yet.
+      # @return [Rigor::Type::Base, nil] resolved type, or `nil`
+      #   to fall through.
+      def resolve(node, scope) # rubocop:disable Lint/UnusedMethodArgument
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/plugin.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "plugin/type_node_resolver"
 require_relative "plugin/manifest"
 require_relative "plugin/access_denied_error"
 require_relative "plugin/trust_policy"