rigortype 0.3.9 → 0.4.0

data/sig/rigor/effects/summary.rbs

@@ -0,0 +1,50 @@
+module Rigor
+  module Effects
+    # One method's direct effect record: the labels its own body contributes, grouped by the origin
+    # that claimed them, plus the declared (`<=`) lane, the exhaustiveness bit, and the taint causes.
+    class Summary
+      TRIVIAL_BOUND: LabelSet
+
+      # The pure-modulo-frame-ownership summary: no origins, nothing declared, exhaustive, untainted.
+      def self.empty: () -> Summary
+
+      # A summary carrying a single taint and no labels — the fail-soft answer for a unit the collector
+      # could not finish.
+      def self.tainted: (String cause, ?String? detail) -> Summary
+
+      # sig-gen gap: #1154 — `initialize` normalizes the `bundles:`/`declared_bundles:` kwargs through
+      # `normalize_bundles` (join-merging per origin), so the readers do not trace to the parameters.
+      attr_reader bundles: Hash[Origin, LabelSet]
+      # sig-gen gap: #1154 — as above.
+      attr_reader declared_bundles: Hash[Origin, LabelSet]
+      # Unmarked residue — `proven`/`declared` are flattened from the bundle tables by `initialize`,
+      # not assigned from a parameter, so #1154 does not cover them (same shape as
+      # `Registry#additional_initializers`).
+      attr_reader declared: LabelSet
+      attr_reader proven: LabelSet
+      # sig-gen gap: #1154 — `causes` are `[cause, detail]` pairs normalized in `initialize`.
+      attr_reader causes: Array[[String, String?]]
+
+      def initialize: (?bundles: Hash[Origin, LabelSet], ?declared_bundles: Hash[Origin, LabelSet],
+                       ?exhaustive: bool, ?causes: Array[[String, String?]], ?unclaimed: bool) -> void
+
+      # Whether every call this method makes was resolved.
+      def exhaustive?: () -> bool
+
+      # Whether this method made a call nothing described — read by `rigor sig-gen`'s annotation
+      # emission alone (#391).
+      def unclaimed?: () -> bool
+
+      # Whether the report omits this row by default (#386).
+      def trivial?: () -> bool
+
+      # Union in every lane — reopenings and multi-file contributors fold through this.
+      def join: (Summary other) -> Summary
+
+      def ==: (untyped other) -> bool
+      alias eql? ==
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+  end
+end

data/sig/rigor/effects/taint_cause.rbs

@@ -0,0 +1,12 @@
+module Rigor
+  module Effects
+    # The closed enum of reasons a summary is not exhaustive (ADR-103 WD14). A reporting vocabulary,
+    # never a diagnostic one.
+    module TaintCause
+      ALL: Array[String]
+
+      # `cause.to_s` is looked up, so any object is a fair question.
+      def self?.valid?: (untyped cause) -> bool
+    end
+  end
+end

data/sig/rigor/environment.rbs

@@ -15,10 +15,8 @@ module Rigor
     attr_reader hkt_registry: untyped?
     # Issue #784 — `[error_class_name, first_message_line, raw_frame_or_nil, stage]` when either stage of
     # the HKT-registry build raised at its seam (`:scan`, the RBS `type`-alias scan; `:overlay`, the
-    # plugin-manifest aggregation — #791), nil when both built or were never demanded. Declared `untyped?`
-    # like its neighbours:
-    # `rigor sig-gen` emits nothing for this delegating reader, and the tuple shape is documented here.
-    def hkt_scan_failure: () -> untyped?
+    # plugin-manifest aggregation — #791), nil when both built or were never demanded.
+    def hkt_scan_failure: () -> [String, String, String?, Symbol]?
 
     def self.default: () -> Environment
     def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?source_rbs_synthesis_reporter: untyped?, ?bundler_bundle_path: String?, ?bundler_auto_detect: bool, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> Environment
@@ -31,6 +29,9 @@ module Rigor
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?
+    # sig-gen gap: #1154 — the answer comes through `rbs_loader`, an `attr_reader` over an ivar assigned in
+    # `initialize` from a parameter, which reaches `untyped`.
+    def global_for_name: (String | Symbol name, ?builtin: bool) -> Type::t?
     def class_known?: (String | Symbol name) -> bool
     def rbs_module?: (String | Symbol name) -> bool
     def singleton_extended_modules: (String | Symbol name) -> Array[String]
@@ -59,7 +60,7 @@ module Rigor
 
       def self.default: () -> RbsLoader
       def self.reset_default!: () -> void
-      def self.build_env_for: (libraries: Array[String], signature_paths: Array[String | _ToPath]) -> untyped
+      def self.build_env_for: (libraries: Array[String], signature_paths: Array[String | _ToPath]) -> ::RBS::Environment
       def self.vendored_gem_sig_paths: () -> Array[Pathname]
       def self.capability_role_sig_paths: () -> ([Pathname] | [])
       def self.vendored_gem_names: () -> Array[String]
@@ -67,10 +68,10 @@ module Rigor
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath], ?cache_store: untyped?) -> void
       def class_known?: (String | Symbol name) -> bool
       def rbs_module?: (String | Symbol name) -> bool
-      def instance_definition: (String | Symbol class_name) -> untyped?
-      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
-      def singleton_definition: (String | Symbol class_name) -> untyped?
-      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
+      def instance_definition: (String | Symbol class_name) -> ::RBS::Definition?
+      def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> ::RBS::Definition::Method?
+      def singleton_definition: (String | Symbol class_name) -> ::RBS::Definition?
+      def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> ::RBS::Definition::Method?
       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
@@ -79,7 +80,8 @@ module Rigor
       def singleton_extended_module_names: (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
+      def each_known_class_name: () { (String name) -> void } -> void
+                              | () -> ::Enumerator[String, void]
     end
 
     class RbsHierarchy

data/sig/rigor/inference/optimistic_origin.rbs

@@ -0,0 +1,10 @@
+module Rigor
+  module Inference
+    module OptimisticOrigin
+      # sig-gen gap: #1150 — sig-gen types the `BoundMark#miss` member read `untyped`, so it skips this reader
+      # (sig.skipped.untyped-return). The answer is the recorded `true` / `false` / `nil`, or the `UNKNOWN_MISS`
+      # sentinel; declaring it is what lets sig-gen type `Scope#optimistic_local_miss` / `#optimistic_ivar_miss`.
+      def self?.bound_miss: (untyped mark) -> Object?
+    end
+  end
+end

data/sig/rigor/inference.rbs

@@ -23,8 +23,10 @@ module Rigor
       class ClassFrame
         attr_reader name: String
         attr_reader singleton: bool
-        def self.new: (name: String, singleton: bool) -> ClassFrame
-        def initialize: (name: String, singleton: bool) -> void
+        # sig-gen gap: #1150 — `Data.define` members carry no type.
+        attr_reader refinement: bool
+        def self.new: (name: String, singleton: bool, ?refinement: bool) -> ClassFrame
+        def initialize: (name: String, singleton: bool, ?refinement: bool) -> void
       end
 
       def initialize: (scope: Scope, ?tracer: FallbackTracer?, ?on_enter: (^(untyped, Scope) -> void)?, ?class_context: Array[ClassFrame]) -> void
@@ -113,7 +115,7 @@ module Rigor
       def self?.value_pattern_certainty: (Type::t subject_type, untyped pattern_value) -> (:yes | :no | :maybe)
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
-      def self?.analyse: (untyped node, Scope scope) -> untyped
+      def self?.analyse: (untyped node, Scope scope) -> [Scope, Scope]?
       def self?.subclass_of?: (String rigor_class_name, String target_class_name, untyped context) -> bool
       def self?.class_ordering: (String lhs, String rhs, untyped context) -> Symbol
       def self?.trusted_equality_literal?: (untyped literal) -> bool
@@ -170,7 +172,7 @@ module Rigor
       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?.finalize_constant_writes: (Hash[String, Hash[String, untyped]] writes) -> [Hash[String, Type::Constant], Hash[String, Set[String]]]
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void
     end
 

data/sig/rigor/plugin/additional_initializer.rbs

@@ -0,0 +1,36 @@
+module Rigor
+  module Plugin
+    # ADR-38 declaration — methods/def-blocks that establish ivar state like `initialize` does, so
+    # the read-before-write nil soundness gate does not widen their ivars. See
+    # lib/rigor/plugin/additional_initializer.rb for the full contract.
+    class AdditionalInitializer
+      # sig-gen gap: #1154 — `attr_reader` rows over ivars assigned from `initialize` parameters are
+      # skipped (untyped return); the constructor validates `receiver_constraint` is a non-empty
+      # String and normalizes both lists with `map(&:to_sym)`, so the stored types are hand-written.
+      attr_reader receiver_constraint: String
+
+      # sig-gen gap: #1154 — as above.
+      attr_reader methods: Array[Symbol]
+
+      # sig-gen gap: #1154 — as above.
+      attr_reader block_methods: Array[Symbol]
+
+      # The validators accept Symbol or non-empty String elements; `initialize` normalizes to
+      # Symbol before storing. At least one of `methods:`/`block_methods:` must be non-empty.
+      def initialize: (receiver_constraint: String, ?methods: Array[Symbol | String], ?block_methods: Array[Symbol | String]) -> void
+
+      def covers_method?: (Symbol method_name) -> bool
+
+      def covers_block_method?: (Symbol method_name) -> bool
+
+      def to_h: () -> Hash[String, String | Array[String]]
+
+      def ==: (untyped other) -> bool
+
+      # `alias eql? ==` — the alias row has no sig-gen shape, so it stays unmarked residue.
+      def eql?: (untyped other) -> bool
+
+      def hash: () -> Integer
+    end
+  end
+end

data/sig/rigor/plugin/base.rbs

@@ -17,11 +17,11 @@ class Rigor::Plugin::Base
   def self.producer: (untyped id, ?watch: untyped, ?serialize: untyped, ?deserialize: untyped, ?generation_cap: untyped) { (untyped params) -> untyped } -> Symbol
   def self.producers: () -> Hash[Symbol, untyped]
 
-  def self.node_rule: (untyped node_type) { (*untyped) -> untyped } -> untyped
+  def self.node_rule: (untyped node_type) { (*untyped) -> untyped } -> Class
   def self.node_rules: () -> Array[untyped]
 
-  def self.node_file_context: () { (untyped root, untyped scope) -> untyped } -> untyped
-  def self.node_file_context_block: () -> untyped
+  def self.node_file_context: () { (untyped root, untyped scope) -> untyped } -> void
+  def self.node_file_context_block: () -> (^(untyped root, untyped scope) -> untyped)?
 
   def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?, ?file_methods: (^(untyped path) -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.dynamic_returns: () -> Array[untyped]
@@ -44,22 +44,45 @@ class Rigor::Plugin::Base
   def init: (untyped services) -> nil
   def prepare: (untyped services) -> nil
   def diagnostics_for_file: (path: untyped, scope: untyped, root: untyped) -> Array[untyped]
+  # authored: hook-contract widening — the element type comes from a plugin gem sig-gen never
+  # sees, so no engine work would let it answer; the declared `Array[Rigor::Plugin::TemplateUnit]`
+  # over a bare-`[]` default body is the author's contract.
+  def template_units_for_file: (path: untyped, source: untyped) -> Array[untyped]
+  # authored: hook-contract widening — the element type comes from a plugin gem sig-gen never
+  # sees, so no engine work would let it answer; the declared record contract over a bare-`[]`
+  # default body is the author's.
+  def declared_members: (untyped class_name) -> Array[untyped]
 
   # Engine-executed dispatch over the declared DSLs.
   def node_rule_diagnostics: (path: untyped, scope: untyped, root: untyped) -> Array[untyped]
-  def dynamic_return_type: (call_node: untyped, scope: untyped, receiver_type: untyped) -> untyped
+  # sig-gen gap: #1007 — the true `return result if result` branch (base.rb:594) flows through an
+  # `instance_exec`'d, plugin-supplied Proc that sig-gen's inference does not fold into the return
+  # join, so it proposes the literal fallback `nil` instead of the honest contract.
+  def dynamic_return_type: (call_node: untyped, scope: untyped, receiver_type: untyped) -> Rigor::Type::t?
   def narrowing_facts_for: (call_node: untyped, scope: untyped) -> Array[untyped]
 
   # Authoring helpers.
-  def diagnostic: (untyped node, path: untyped, message: untyped, ?severity: untyped, ?rule: untyped, ?location: untyped) -> untyped
+  def diagnostic: (untyped node, path: untyped, message: untyped, ?severity: untyped, ?rule: untyped, ?location: untyped) -> Rigor::Analysis::Diagnostic
   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 disclose_once: (untyped key, message: untyped, ?severity: untyped, ?rule: untyped) -> nil
+  def emit_once: (untyped key, untyped diagnostics) -> nil
+  def run_disclosure_records: () -> Array[untyped]
   def manifest: () -> Rigor::Plugin::Manifest
   def signature_paths: () -> Array[String]
-  def protocol_contracts: () -> untyped
+  # Defaults to `manifest.protocol_contracts`; a plugin MAY override to fold per-project config in,
+  # but the contract (an Array of ProtocolContract) holds either way.
+  def protocol_contracts: () -> Array[Rigor::Plugin::ProtocolContract]
+  # The ADR-103 effect surfaces delegate to the manifest by default; a plugin MAY override
+  # `effect_attributions` to fold per-project config in, but the contract holds either way.
+  def effect_labels: () -> Array[String]
+  def effect_attributions: () -> Array[Rigor::Plugin::EffectAttribution]
+  def effect_edges: () -> Array[Rigor::Plugin::EffectEdge]
+  def effect_entry_points: () -> Array[Rigor::Plugin::EffectEntryPoints]
+  def effect_ancestry: () -> Array[Rigor::Plugin::EffectAncestry]
   def io_boundary: () -> Rigor::Plugin::IoBoundary
-  def cache_for: (untyped producer_id, ?params: untyped, ?descriptor: untyped) -> untyped
+  def cache_for: (untyped producer_id, ?params: untyped, ?descriptor: untyped) -> Proc
   def plugin_entry: () -> untyped
 end

data/sig/rigor/plugin/effect_ancestry.rbs

@@ -0,0 +1,27 @@
+module Rigor
+  module Plugin
+    # One `effect_ancestry:` row: an ancestry edge the plugin's own gem introduces and the project's
+    # source never writes down (ADR-103 WD17, #465). `parent:` need only be a true ancestor, not the
+    # immediate superclass. Bundled plugins only — `Effects::PluginFacts` enforces it. Frozen value
+    # object.
+    class EffectAncestry
+      # sig-gen gap: #1154 — validated in `initialize` from the parameter of the same name
+      # (`to_s`-normalized, frozen), so sig-gen proposes the raw parameter shape.
+      attr_reader child: String
+      # sig-gen gap: #1154 — same shape as `child`.
+      attr_reader parent: String
+      # sig-gen gap: #1154 — same shape; `why:` is required and validated non-empty.
+      attr_reader why: String
+
+      def initialize: (child: untyped, parent: untyped, why: untyped) -> void
+
+      def to_h: () -> Hash[String, untyped]
+
+      def ==: (untyped other) -> bool
+      # `alias eql? ==` — the alias row has no sig-gen shape, so it stays unmarked
+      # residue.
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+    end
+  end
+end

data/sig/rigor/plugin/effect_attribution.rbs

@@ -0,0 +1,66 @@
+module Rigor
+  module Plugin
+    # One `effect_attributions:` row: the receiver spelling, the selector, and the labels the call
+    # contributes to the declared lane — plus the optional `narrow:`/`callee:`/`taint:`/`responds:`
+    # modifiers the engine owns the strategy for (#393/#1048/#1065). Frozen value object.
+    class EffectAttribution
+      # A receiver spelled as a `Constant::Path` — the class-name form.
+      CLASS_NAME: Regexp
+      # A receiver path: a constant head followed by one or more sends (`Rails.cache`).
+      RECEIVER_PATH: Regexp
+      # A self path: implicit self followed by one or more receiver-less sends (`self.flash.now`).
+      SELF_PATH: Regexp
+      # What a self path is rooted at, once the `self.` head is stripped.
+      SELF_HEAD: String
+      # The taint causes a plugin row may name — a closed subset of `Effects::TaintCause::ALL`.
+      TAINT_CAUSES: Array[String]
+
+      # sig-gen gap: #1154 — normalized/validated in `initialize` from the parameter of the same
+      # name (`to_s`-coerced, frozen), so sig-gen proposes the raw parameter shape.
+      attr_reader receiver: String
+      # sig-gen gap: #1154 — `to_sym`-normalized from the `method:` parameter.
+      attr_reader method: Symbol
+      attr_reader singleton: bool
+      # sig-gen gap: #1154 — `Array()`-normalized, deduplicated and frozen from `labels:`.
+      attr_reader labels: Array[String]
+      # sig-gen gap: #1154 — `to_s`-normalized from the `narrow:` parameter.
+      attr_reader narrow: String?
+      attr_reader discharge: bool
+      # sig-gen gap: #1154 — `to_s`-normalized from the `within:` parameter.
+      attr_reader within: String?
+      attr_reader on_result: bool
+      # sig-gen gap: #1154 — `to_s`-normalized from the `taint:` parameter.
+      attr_reader taint: String?
+      # sig-gen gap: #1154 — `to_s`-normalized from the `callee:` parameter.
+      attr_reader callee: String?
+      # sig-gen gap: #1154 — normalized from the `callee_fallbacks:` parameter.
+      attr_reader callee_fallbacks: Hash[String, Array[String]]?
+      attr_reader responds: bool
+      # sig-gen gap: #1154 — `to_s`-normalized from the `why:` parameter.
+      attr_reader why: String
+
+      # The coercion-facing constructor: every parameter is `to_s`/`to_sym`/`Array()`-normalized,
+      # so `untyped` is the honest parameter type throughout.
+      def initialize: (receiver: untyped, method: untyped, labels: untyped, why: untyped,
+                       ?singleton: untyped, ?narrow: untyped, ?discharge: untyped,
+                       ?within: untyped, ?on_result: untyped, ?taint: untyped, ?callee: untyped,
+                       ?callee_fallbacks: untyped, ?responds: untyped) -> void
+
+      # Whether {#receiver} is a receiver path (`Rails.cache`) rather than a class name or a
+      # self path.
+      def receiver_path?: () -> bool
+      # Whether {#receiver} is a self path (`self.flash.now`).
+      def self_path?: () -> bool
+
+      # The key an origin and a report spell this row as.
+      def key: () -> String
+      def to_h: () -> Hash[String, untyped]
+
+      def ==: (untyped other) -> bool
+      # `alias eql? ==` — the alias row has no sig-gen shape, so it stays unmarked
+      # residue.
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+    end
+  end
+end

data/sig/rigor/plugin/effect_edge.rbs

@@ -0,0 +1,33 @@
+module Rigor
+  module Plugin
+    # One `effect_edges:` row: a framework-edge strategy naming the base `receiver` a plugin points
+    # the engine at, the `target` strategy slot, and an optional method-level `selector`. Frozen
+    # value object.
+    class EffectEdge
+      # The closed set of framework-edge strategies the engine implements.
+      TARGETS: Array[Symbol]
+
+      # sig-gen gap: #1154 — validated/normalized in `initialize` from the parameter of the same
+      # name, so sig-gen proposes the raw parameter shape.
+      attr_reader receiver: String
+      # sig-gen gap: #1154 — `to_sym`-normalized from the `method:` parameter.
+      attr_reader method: Symbol?
+      attr_reader singleton: bool
+      # sig-gen gap: #1154 — validated against `TARGETS` in `initialize`.
+      attr_reader target: (:activerecord_callbacks | :perform_now | :mailer_body)
+      # sig-gen gap: #1154 — `to_s`-normalized from the `why:` parameter.
+      attr_reader why: String
+
+      def initialize: (receiver: untyped, target: untyped, why: untyped, ?method: untyped,
+                       ?singleton: untyped) -> void
+
+      def to_h: () -> Hash[String, untyped]
+
+      def ==: (untyped other) -> bool
+      # `alias eql? ==` — the alias row has no sig-gen shape, so it stays unmarked
+      # residue.
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+    end
+  end
+end

data/sig/rigor/plugin/effect_entry_points.rbs

@@ -0,0 +1,25 @@
+module Rigor
+  module Plugin
+    # One `effect_entry_points:` row: a named set of globs marking project files whose methods are
+    # framework entry points (ADR-103 WD6). Frozen value object; {#globs} are deduplicated and
+    # sorted in `initialize`.
+    class EffectEntryPoints
+      # sig-gen gap: #1154 — `to_s`-normalized in `initialize` from the `name:` parameter.
+      attr_reader name: String
+      # sig-gen gap: #1154 — deduplicated/sorted/frozen in `initialize` from `globs:`.
+      attr_reader globs: Array[String]
+      # sig-gen gap: #1154 — `to_s`-normalized in `initialize` from `why:`.
+      attr_reader why: String
+
+      def initialize: (name: untyped, globs: untyped, ?why: untyped) -> void
+
+      def to_h: () -> Hash[String, untyped]
+
+      def ==: (untyped other) -> bool
+      # `alias eql? ==` — the alias row has no sig-gen shape, so it stays unmarked
+      # residue.
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+    end
+  end
+end

data/sig/rigor/plugin/io_boundary.rbs

@@ -4,7 +4,7 @@ class Rigor::Plugin::IoBoundary
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
   def list_directory: (untyped) -> Array[String]
-  # sig-gen gap: #959 — the generator pins the empty-summary literal (`count: 0, first_path: nil`); the
+  # sig-gen gap: #1156 — the generator pins the empty-summary literal (`count: 0, first_path: nil`); the
   # record's fields are the running count and the first refused path, nil when nothing was refused.
   def refusal_summary: () -> { count: Integer, first_path: String?, nearest_root: String? }?
   def open_url: (untyped url) -> String

data/sig/rigor/plugin/loader.rbs

@@ -12,9 +12,9 @@ module Rigor
       attr_reader services: untyped
       attr_reader requirer: ^(String) -> untyped
 
-      def self.load: (configuration: Configuration, services: untyped, ?requirer: ^(String) -> untyped) -> untyped
-      def initialize: (services: untyped, ?requirer: ^(String) -> untyped) -> void
-      def load: (Array[String | Hash[untyped, untyped]] entries) -> untyped
+      def self.load: (configuration: Configuration, services: untyped, ?requirer: ^(String) -> untyped, ?feature_resolver: untyped) -> Registry
+      def initialize: (services: untyped, ?requirer: ^(String) -> untyped, ?feature_resolver: untyped) -> void
+      def load: (Array[String | Hash[untyped, untyped]] entries) -> Registry
     end
   end
 end

data/sig/rigor/plugin/manifest.rbs

@@ -3,35 +3,74 @@ class Rigor::Plugin::Manifest::Consumption
 end
 
 class Rigor::Plugin::Manifest
-  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?target_gems: 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
+  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?target_gems: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?rbs_complete_ancestors: 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: Array[Rigor::Plugin::ProtocolContract], ?source_rbs_synthesizer: untyped, ?additional_initializers: Array[Rigor::Plugin::AdditionalInitializer], ?effect_root: String?, ?effect_labels: Array[String], ?effect_attributions: Array[Rigor::Plugin::EffectAttribution], ?effect_edges: Array[Rigor::Plugin::EffectEdge], ?effect_entry_points: Array[Rigor::Plugin::EffectEntryPoints], ?effect_ancestry: Array[Rigor::Plugin::EffectAncestry], ?template_globs: untyped) -> void
 
   # Public attribute readers (the full `attr_reader` surface). Plugins
   # read `manifest.id` / `manifest.protocol_contracts` etc.; declaring
   # them keeps the contract surface resolvable so ADR-43 ancestor
   # resolution does not surface a false `call.undefined-method` on a
-  # real reader. Identity fields are typed; the structured slots stay
-  # `untyped` per the sparse `sig/` tree.
+  # real reader. Slots whose element classes are sig-covered carry the
+  # validated element type (the `validate_*!` constructors prove it);
+  # the rest stay `untyped` per the sparse `sig/` tree.
   def id: () -> String
   def version: () -> String
   def description: () -> String?
   def config_schema: () -> untyped
   def config_defaults: () -> Hash[String, untyped]
   def target_gems: () -> Array[String]
-  def produces: () -> untyped
-  def consumes: () -> untyped
-  def owns_receivers: () -> untyped
-  def open_receivers: () -> untyped
-  def type_node_resolvers: () -> untyped
+  # sig-gen gap: #1154 — an `attr_reader` over an ivar assigned in `initialize` from a parameter the
+  # manifest validates but does not type, so inference reaches `untyped` where the contract is
+  # `Array[String]` (the same gap every other reader in this block carries).
+  def template_globs: () -> Array[String]
+  def produces: () -> Array[Symbol]
+  def consumes: () -> Array[Rigor::Plugin::Manifest::Consumption]
+  def owns_receivers: () -> Array[String]
+  def open_receivers: () -> Array[String]
+  def rbs_complete_ancestors: () -> Array[String]
+  def type_node_resolvers: () -> Array[Rigor::Plugin::TypeNodeResolver]
   def block_as_methods: () -> untyped
   def heredoc_templates: () -> untyped
   def nested_class_templates: () -> untyped
   def trait_registries: () -> untyped
   def hkt_registrations: () -> untyped
   def hkt_definitions: () -> untyped
-  def signature_paths: () -> untyped
-  def protocol_contracts: () -> untyped
+  def signature_paths: () -> Array[String]
+  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
+  # `validate_protocol_contracts!` requires every element `is_a?(ProtocolContract)`.
+  def protocol_contracts: () -> Array[Rigor::Plugin::ProtocolContract]
+  # ADR-32 WD6/WD12 — any object responding to `call`, and its result is a documented multi-shape
+  # outcome (`String` / nil / `[:error, msg]` / `[:ok, src, msgs]`), not `String?` — `untyped` is the
+  # honest claim until the outcome has a sig'd shape.
   def source_rbs_synthesizer: () -> untyped
-  def additional_initializers: () -> untyped
+  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
+  # the validator (`validate_additional_initializers!`) requires every element
+  # `is_a?(AdditionalInitializer)`, so the element type is hand-written.
+  def additional_initializers: () -> Array[Rigor::Plugin::AdditionalInitializer]
+
+  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter
+  # (`to_s`-normalized); `validate_effect_root!` bounds the spelling.
+  def effect_root: () -> String?
+  # sig-gen gap: #1154 — `attr_reader` over an ivar normalized in `initialize` from a parameter;
+  # `validate_effect_labels!` requires non-empty `String` elements.
+  def effect_labels: () -> Array[String]
+  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
+  # `validate_effect_attributions!` requires every element `is_a?(EffectAttribution)`.
+  def effect_attributions: () -> Array[Rigor::Plugin::EffectAttribution]
+  # sig-gen gap: #1154 — same shape; `validate_effect_edges!` requires `is_a?(EffectEdge)`.
+  def effect_edges: () -> Array[Rigor::Plugin::EffectEdge]
+  # sig-gen gap: #1154 — same shape; `validate_effect_entry_points!` requires
+  # `is_a?(EffectEntryPoints)`.
+  def effect_entry_points: () -> Array[Rigor::Plugin::EffectEntryPoints]
+  # sig-gen gap: #1154 — same shape; `validate_effect_ancestry!` requires `is_a?(EffectAncestry)`.
+  def effect_ancestry: () -> Array[Rigor::Plugin::EffectAncestry]
+
+  # The identity opening a root when this plugin's labels join the run's vocabulary: the
+  # `effect_root` for a bundled first-party plugin that declares one, the plugin `id` otherwise.
+  def effect_owner: () -> String
+  # Whether this plugin's `effect_attributions:` may carry `discharge: true` (ADR-103 WD6).
+  def effect_discharge_allowed?: () -> bool
+  # Whether the plugin contributes anything to the effect surfaces at all.
+  def effects?: () -> bool
 
   def validate_config: (untyped) -> Array[String]
   def to_h: () -> Hash[String, untyped]

data/sig/rigor/plugin/protocol_contract.rbs

@@ -0,0 +1,68 @@
+module Rigor
+  module Plugin
+    # ADR-28 declaration — "every instance/singleton method named `method_name` in a file matching
+    # `path_glob` carries the declared parameter + return-type protocol" (provide-and-check). See
+    # lib/rigor/plugin/protocol_contract.rb for the full contract.
+    class ProtocolContract
+      VALID_SEVERITIES: Array[Symbol]
+
+      # One positional-parameter provision: zero-based index + fully-qualified type name.
+      class ParamType < ::Data
+        # sig-gen gap: #1150 — `Data.define` member reads carry no type; `coerce_param_type` proves
+        # `index` is a non-negative Integer and `type_name` a non-empty String, so the member rows
+        # are hand-written.
+        def index: () -> Integer
+
+        # sig-gen gap: #1150 — as above.
+        def type_name: () -> String
+
+        # sig-gen gap: #1150 — as above.
+        def self.new: (index: Integer, type_name: String) -> instance | (Integer index, String type_name) -> instance
+
+        # sig-gen gap: #1150 — as above.
+        def self.[]: (index: Integer, type_name: String) -> instance | (Integer index, String type_name) -> instance
+      end
+
+      # sig-gen gap: #1154 — `attr_reader` rows over ivars assigned in `initialize`; each is
+      # validated/normalized first (`dup.freeze`/`to_sym`/truthiness collapse/coerce), so the
+      # stored types are hand-written.
+      attr_reader path_glob: String
+
+      # sig-gen gap: #1154 — as above (`to_sym` normalizes the accepted Symbol|String).
+      attr_reader method_name: Symbol
+
+      # `singleton ? true : false` collapses any truthy input to bool — sig-gen already infers
+      # `false | true`, so this row is generated-equivalent rather than a #1154 gap.
+      attr_reader singleton: bool
+
+      # sig-gen gap: #1154 — as above (`coerce_param_types` guarantees `Array[ParamType]`).
+      attr_reader param_types: Array[ParamType]
+
+      # sig-gen gap: #1154 — as above (nil or a non-empty `dup.freeze`d String).
+      attr_reader return_type_name: String?
+
+      # sig-gen gap: #1154 — as above (`VALID_SEVERITIES.include?(to_sym)` bounds the stored value
+      # to the three declared literals).
+      attr_reader severity: :error | :warning | :info
+
+      # `method_name`/`severity` accept String too (both are `to_sym`'d); `param_types` entries are
+      # ParamType or a Hash with `index`/`type_name` keys (String or Symbol keys accepted by the
+      # coercion). `singleton` is documented Boolean; the impl collapses any truthy value.
+      def initialize: (path_glob: String, method_name: Symbol | String, ?return_type_name: String?, ?param_types: Array[ParamType | Hash[untyped, untyped]], ?singleton: bool, ?severity: Symbol | String) -> void
+
+      # Copy with `path_glob` replaced — plugin config-folding hook for the convention path.
+      def with_path_glob: (String glob) -> ProtocolContract
+
+      # Values are String/bool/nil or the per-param `Hash[String, Integer | String]` rows — kept
+      # `untyped` to match the manifest's `to_h` convention.
+      def to_h: () -> Hash[String, untyped]
+
+      def ==: (untyped other) -> bool
+
+      # `alias eql? ==` — no sig-gen shape for alias rows; unmarked residue.
+      def eql?: (untyped other) -> bool
+
+      def hash: () -> Integer
+    end
+  end
+end