rigortype 0.3.8 → 0.4.0

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

@@ -3,6 +3,10 @@ class Rigor::Plugin::IoBoundary
   def read_file: (untyped) -> String
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
+  def list_directory: (untyped) -> Array[String]
+  # 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
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).
   def cache_descriptor: () -> untyped

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,34 +3,74 @@ 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, ?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 produces: () -> untyped
-  def consumes: () -> untyped
-  def owns_receivers: () -> untyped
-  def open_receivers: () -> untyped
-  def type_node_resolvers: () -> untyped
+  def target_gems: () -> Array[String]
+  # 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

data/sig/rigor/plugin/registry.rbs

@@ -8,9 +8,70 @@ class Rigor::Plugin::Registry
   def self.materialize: (blueprints: untyped, services: untyped) -> Rigor::Plugin::Registry
 
   def initialize: (?plugins: untyped, ?load_errors: untyped, ?blueprints: untyped) -> void
-  def find: (String | Symbol id) -> untyped
+  def find: (String | Symbol id) -> Rigor::Plugin::Base?
   def ids: () -> Array[String]
   def empty?: () -> bool
   def any_load_errors?: () -> bool
   def type_node_resolvers: () -> Array[untyped]
+  def rbs_complete_ancestors: () -> Array[String]
+  def rbs_complete_ancestor?: (untyped class_name) -> bool
+
+  # Newly declared — the attr_reader was absent from the sig. `compile_aggregates` builds the ivar
+  # with `flat_map` over the manifests (not from an `initialize` parameter, so this is unmarked
+  # residue like the `rbs_complete_ancestors` sibling rather than a #1154 row); the element type is
+  # `AdditionalInitializer`, enforced per manifest by `validate_additional_initializers!`.
+  attr_reader additional_initializers: Array[Rigor::Plugin::AdditionalInitializer]
+
+  # Newly declared — same unmarked-residue shape as `additional_initializers` (a
+  # `compile_aggregates` flat_map ivar, not an initialize-parameter read).
+  attr_reader protocol_contracts: Array[Rigor::Plugin::ProtocolContract]
+
+  # The subset of `protocol_contracts` whose `path_glob` matches `path` (memoised per path).
+  def contracts_for_path: (untyped path) -> Array[Rigor::Plugin::ProtocolContract]
+
+  # ADR-103 WD2/WD6/WD10/WD14 — every loaded plugin's effect contribution, in registration order.
+  # Lazy and memoised like `contracts_for_path`: computing it can force a plugin's project-facts
+  # read, which a run with effects off must never pay. Unmarked residue — a memoised
+  # `filter_map` aggregate, not an `initialize`-parameter read.
+  def effect_contributions: () -> Array[Contribution]
+
+  # One plugin's effect contribution, flattened off whichever surface answered it. Carries the two
+  # authority answers — `owner`, the label root this plugin may open, and `discharge_allowed`,
+  # whether its attributions may discharge — so nothing downstream re-derives who is first-party.
+  class Contribution < ::Data
+    # sig-gen gap: #1150 — a `Data.define` member; sig-gen proposes `untyped`.
+    attr_reader id: String
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader owner: String
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader requested_root: String?
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader discharge_allowed: bool
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader labels: Array[String]
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader attributions: Array[EffectAttribution]
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader edges: Array[EffectEdge]
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader entry_points: Array[EffectEntryPoints]
+    # sig-gen gap: #1150 — a `Data.define` member.
+    attr_reader ancestry: Array[EffectAncestry]
+
+    # sig-gen gap: #1150 — member constructor. The custom `initialize` defaults `ancestry:`;
+    # the positional arm `Data` dispatches bypasses it, so only the kwargs arm is declared
+    # (same shape as `Effects::PluginFacts::Row`).
+    def self.new: (id: String, owner: String, requested_root: String?, discharge_allowed: bool,
+                   labels: Array[String], attributions: Array[EffectAttribution],
+                   edges: Array[EffectEdge], entry_points: Array[EffectEntryPoints],
+                   ?ancestry: Array[EffectAncestry]) -> instance
+    # sig-gen gap: #1150 — as above.
+    def self.[]: (id: String, owner: String, requested_root: String?, discharge_allowed: bool,
+                  labels: Array[String], attributions: Array[EffectAttribution],
+                  edges: Array[EffectEdge], entry_points: Array[EffectEntryPoints],
+                  ?ancestry: Array[EffectAncestry]) -> instance
+
+    # Whether the row carries nothing — no labels, attributions, edges, entry points, or ancestry.
+    def empty?: () -> bool
+  end
 end

data/sig/rigor/plugin.rbs

@@ -3,6 +3,6 @@ module Rigor
     def self.register: (Class plugin_class) -> Class
     def self.registered_for: (String | Symbol id) -> Class?
     def self.registered: () -> Hash[String, Class]
-    def self.unregister!: (?(String | Symbol)? id) -> untyped
+    def self.unregister!: (?(String | Symbol)? id) -> void
   end
 end

data/sig/rigor/rbs_extended.rbs

@@ -51,7 +51,7 @@ module Rigor
     # (`RBS::Definition::Method#annotations`, or a declaration / member's own `#annotations`); the result
     # is a `Rigor::Effects::Envelope`, or nil when the list carries neither purity spelling.
     def self?.pure_annotation?: (String? string) -> bool
-    def self?.read_effect_envelope: (untyped annotations, owner_key: String, ?source: Symbol, ?registry: untyped, ?reporter: untyped) -> untyped?
+    def self?.read_effect_envelope: (untyped annotations, owner_key: String, ?source: Symbol, ?registry: untyped, ?reporter: untyped) -> Effects::Envelope?
 
     class ParamOverride
       attr_reader param_name: Symbol

data/sig/rigor/reflection.rbs

@@ -3,16 +3,19 @@ module Rigor
     def self?.class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
     def self?.rbs_class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
     def self?.project_declared_class?: (String | Symbol class_name, ?scope: Scope?, ?environment: Environment?) -> bool
-    def self?.class_ordering: (String | Symbol lhs, String | Symbol rhs, ?scope: Scope) -> Symbol
+    def self?.class_ordering: (String | Symbol lhs, String | Symbol rhs, ?scope: Scope) -> (:disjoint | :equal | :subclass | :superclass | :unknown)
     def self?.nominal_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Nominal?
     def self?.singleton_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Singleton?
     def self?.constant_type_for: (String | Symbol constant_name, ?scope: Scope) -> Type::t?
-    def self?.resolve_constant_type: (String | Symbol name, ?scope: Scope, ?rooted: bool) -> Type::t?
+    def self?.resolve_constant_type: (String | Symbol name, ?scope: Scope, ?rooted: bool, ?caller_derived: bool) -> Type::t?
+    # sig-gen gap: #1157 — sig-gen skips the method (untyped return: the `&known` block-taking resolver
+    # declines through `nil` paths), so the resolved-name-or-decline is hand-written.
+    def self?.resolve_constant_path_name: (String | Symbol name, Scope scope) { (String candidate) -> boolish } -> String?
     def self?.lexical_nesting_chain: (Scope scope) -> Array[String]
-    def self?.instance_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped
-    def self?.singleton_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped
-    def self?.instance_definition: (String | Symbol class_name, ?scope: Scope) -> untyped
-    def self?.singleton_definition: (String | Symbol class_name, ?scope: Scope) -> untyped
+    def self?.instance_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> ::RBS::Definition::Method?
+    def self?.singleton_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> ::RBS::Definition::Method?
+    def self?.instance_definition: (String | Symbol class_name, ?scope: Scope) -> ::RBS::Definition?
+    def self?.singleton_definition: (String | Symbol class_name, ?scope: Scope) -> ::RBS::Definition?
     def self?.class_type_param_names: (String | Symbol class_name, ?scope: Scope) -> Array[Symbol]
     def self?.discovered_class?: (String | Symbol class_name, ?scope: Scope) -> bool
     def self?.discovered_method?: (String | Symbol class_name, String | Symbol method_name, ?kind: Symbol, ?scope: Scope) -> bool

data/sig/rigor/scope.rbs

@@ -14,14 +14,29 @@ module Rigor
     attr_reader void_origins: Hash[untyped, Inference::VoidOrigin]
     attr_reader plugin_typed_calls: Hash[untyped, bool]
     attr_reader optimistic_origins: Hash[untyped, Symbol]
-    attr_reader optimistic_locals: Hash[Symbol, Symbol]
-    attr_reader optimistic_ivars: Hash[Symbol, Symbol]
+    # A marked binding whose miss answer is known stores an `Inference::OptimisticOrigin::BoundMark` (a `Data`)
+    # in place of its bare cause (issue #1302).
+    attr_reader optimistic_locals: Hash[Symbol, Symbol | Data]
+    attr_reader optimistic_ivars: Hash[Symbol, Symbol | Data]
+    # sig-gen gap: #1154 — an `attr_reader` over an ivar assigned in `initialize` from a parameter reaches `untyped`.
+    attr_reader repeated_or_writes: Hash[untyped, bool]
+    # sig-gen gap: #1154 — the same reader shape; `Inference::MatchRebinding::Frame` carries no signature.
+    attr_reader match_frame: untyped
     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]
     attr_reader opaque_block_self: bool
+    # sig-gen gap: #1154 — sig-gen skips the reader (sig.skipped.untyped-return): an `attr_reader`
+    # over an ivar assigned in `initialize` from a parameter, so inference reaches `untyped`.
+    attr_reader singleton_class_body: bool
     attr_reader lexical_nesting: Array[String]?
+    # Issue #1429 — a guard's narrowing of a constant reference, keyed by its spelling.
+    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
+    attr_reader constant_narrowings: Hash[String, Type::t]
+    # Issue #1429 — the pre-guard type of each global or constant a guard narrowed.
+    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
+    attr_reader guard_records: Hash[[Symbol, Symbol | String], Type::t]
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # DiscoveryIndex; Scope keeps per-table readers as delegates.
@@ -37,14 +52,38 @@ module Rigor
     def discovered_def_sources: () -> Hash[String, Hash[Symbol, String]]
     def discovered_singleton_def_sources: () -> Hash[String, Hash[Symbol, String]]
     def discovered_method_visibilities: () -> Hash[String, Hash[Symbol, Symbol]]
+    # sig-gen gap: #1148 — sig-gen skips an endless-def reader (untyped return); the row is hand-written.
+    def discovered_parameter_envelopes: () -> Hash[String, Hash[untyped, untyped]]
+    # sig-gen gap: #1149 — sig-gen skips the `||` fallback reader (untyped return); the row is hand-written.
+    def parameter_envelopes_of: (String class_name) -> Hash[untyped, untyped]
     def discovered_superclasses: () -> Hash[String, String]
+    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the per-file
+    # deferred-range table's row shape is hand-written.
+    def discovered_deferred_ranges: () -> Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]]
+    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the refinement table's
+    # shape is hand-written.
+    def discovered_refinements: () -> Hash[String, Hash[Symbol, Array[String]]]
+    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the census shape is
+    # hand-written.
+    def discovered_global_write_census: () -> Set[Array[untyped]]
     def discovered_includes: () -> Hash[String, Array[String]]
+    # Issue #1123 — the instance-ancestor-ORDER table beside the include one.
+    def discovered_prepends: () -> Hash[String, Array[String]]
+    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (untyped return), so the table shape is hand-written.
+    def discovered_extends: () -> Hash[String, Array[String]]
     def discovered_class_sources: () -> Hash[String, Set[String]]
     def constant_sources: () -> Hash[String, Set[String]]
     def published_constant_names: () -> Set[String]
     def local_constant_names: () -> Set[String]
+    # sig-gen gap: #1150 — the `Data.define` table it reads carries no type, so sig-gen skips the return; the shape is hand-written.
+    def bound_constant_names: (String name) -> Array[String]
+    # sig-gen gap: #1150 — the `Data.define` table it reads carries no type, so sig-gen skips the return; the shape is hand-written.
+    def shadowing_constant_names: (String name) -> Array[String]
+    # sig-gen gap: #1149 — sig-gen types the `||` fallback `untyped`, so the element type is hand-written.
+    def published_constant_ivars_for: (String class_name) -> Set[Symbol]
     def published_constant?: (String name) -> bool
     def record_constant_dependency: (String name) -> void
+    def record_class_existence: (String class_name) -> void
     def data_member_layouts: () -> Hash[String, Array[Symbol]]
     def struct_member_layouts: () -> Hash[String, { members: Array[Symbol], keyword_init: bool }]
     def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
@@ -57,11 +96,17 @@ module Rigor
     def record_plugin_typed_call: (untyped node) -> Scope
     def plugin_typed_call?: (untyped node) -> bool
 
+    def with_repeated_or_writes: (untyped nodes) -> Rigor::Scope
+    # sig-gen gap: #1154 — `Hash#key?` over that reader reaches `untyped`, so the `bool` is hand-written.
+    def repeated_or_write?: (untyped node) -> bool
+
     class DiscoveryIndex
       attr_reader declared_types: Hash[untyped, Type::t]
       attr_reader class_ivars: Hash[String, Hash[Symbol, Type::t]]
       attr_reader class_cvars: Hash[String, Hash[Symbol, Type::t]]
       attr_reader program_globals: Hash[Symbol, Type::t]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader program_global_seeds: Hash[Symbol, Type::t]
       attr_reader discovered_classes: Hash[String, Type::Singleton]
       attr_reader in_source_constants: Hash[String, Type::t]
       attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
@@ -71,20 +116,48 @@ module Rigor
       attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
       attr_reader discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]]
       attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]]
       attr_reader discovered_superclasses: Hash[String, String]
       attr_reader discovered_includes: Hash[String, Array[String]]
+      attr_reader discovered_prepends: Hash[String, Array[String]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader discovered_extends: Hash[String, Array[String]]
       attr_reader discovered_class_sources: Hash[String, Set[String]]
       attr_reader constant_sources: Hash[String, Set[String]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader constant_writers: Hash[String, Array[String]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader constant_shadowers: Hash[String, Array[String]]
       attr_reader published_constant_names: Set[String]
       attr_reader local_constant_names: Set[String]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, so every row in this class is authored.
+      attr_reader published_constant_alias_names: Set[String]
+      # sig-gen gap: #1150 — as above.
+      attr_reader published_constant_ivars: Hash[String, Set[Symbol]]
       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]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader discovered_refinements: Hash[String, Hash[Symbol, Array[String]]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader discovered_global_write_census: Set[Array[untyped]]
       attr_reader run_generation: Object?
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader patched_line_readers: Set[Symbol]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader clears_last_status: bool
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader defines_case_equality: bool
+      # `untyped`: the value is an `Inference::LastLine::SelfEvidence` (or nil), and that class carries no signature,
+      # as `Inference::MatchRebinding::Frame` carries none for `match_frame`.
+      attr_reader implicit_self_evidence: untyped
 
       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_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?run_generation: Object?) -> DiscoveryIndex
+      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], ?program_global_seeds: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_prepends: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?constant_writers: Hash[String, Array[String]], ?constant_shadowers: Hash[String, Array[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?published_constant_alias_names: Set[String], ?published_constant_ivars: Hash[String, Set[Symbol]], ?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]], ?discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?discovered_refinements: Hash[String, Hash[Symbol, Array[String]]], ?discovered_global_write_census: Set[Array[untyped]], ?run_generation: Object?, ?patched_line_readers: Set[Symbol], ?clears_last_status: bool, ?defines_case_equality: bool, ?implicit_self_evidence: untyped) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -108,6 +181,9 @@ module Rigor
     def struct_fold_safe?: (String | Symbol name) -> bool
     def entering_opaque_block: () -> Scope
     def opaque_block_self?: () -> bool
+    def with_singleton_class_body: (bool) -> Scope
+    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (sig.skipped.untyped-return); the row is hand-written.
+    def singleton_class_body?: () -> bool
     def with_discovery: (DiscoveryIndex index) -> Scope
     def local: (String | Symbol name) -> Type::t?
     def ivar: (String | Symbol name) -> Type::t?
@@ -117,46 +193,106 @@ module Rigor
     def ivar_origin: (String | Symbol name) -> Symbol?
     def optimistic_local: (String | Symbol name) -> Symbol?
     def optimistic_ivar: (String | Symbol name) -> Symbol?
+    def optimistic_local_miss: (String | Symbol name) -> Object?
+    def optimistic_ivar_miss: (String | Symbol name) -> Object?
     def with_local: (String | Symbol name, Type::t type) -> Scope
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
     def with_local_origin: (String | Symbol name, Symbol? cause) -> Scope
-    def with_optimistic_local: (String | Symbol name, Symbol? cause) -> Scope
-    def with_optimistic_ivar: (String | Symbol name, Symbol? cause) -> Scope
+    def with_optimistic_local: (String | Symbol name, Symbol? cause, ?miss: Object?) -> Scope
+    def with_optimistic_ivar: (String | Symbol name, Symbol? cause, ?miss: Object?) -> Scope
     def with_ivar_origin: (String | Symbol name, Symbol? cause) -> 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]]
+    # Issue #1429 — `rigor sig-gen` output; the parameters are not inferred here, as for `with_mutated_local`.
+    def with_guarded_global: (untyped name, untyped type, untyped pre_guard, ?record: untyped) -> Scope
+    def with_constant_narrowing: (untyped key, untyped type, untyped pre_guard) -> Scope
+    def without_constant_narrowing: (untyped key) -> Scope
+    def guard_narrowed?: () -> bool
+    def forget_guard_narrowings: () -> Scope
+    def forget_guard_narrowing_of: (untyped kind, untyped name) -> Scope
+    def without_constant_narrowings_named: (untyped name) -> Scope
+    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
+    def constant_narrowing: (String key) -> Type::t?
+    # sig-gen gap: #1151 — an `attr_reader` over a frozen Set literal types `untyped`, as the sibling
+    # `declaration_sourced` row does.
+    def published_constant_sourced: () -> Set[[Symbol, Symbol]]
+    # sig-gen gap: #1152 — `Set#include?` over a tuple key types `untyped`, so the `bool` is hand-written.
+    def published_constant_sourced?: (Symbol kind, String | Symbol name) -> bool
+    def with_published_constant_mark: (Symbol kind, String | Symbol name) -> Scope
+    # Issue #1362 — a `[:global_copy, local, global]` record rides beside the `(kind, name)` refs.
+    def declaration_sourced: () -> Set[[Symbol, Symbol] | [Symbol, Symbol, Symbol]]
     def seed_declaration_sourced_ivar: (String | Symbol name, Type::t type) -> Scope
+    def seed_declaration_sourced_global: (String | Symbol name, Type::t type) -> Scope
+    def with_global_copy_marks: (String | Symbol name, Array[String | Symbol] globals) -> Scope
+    def without_local_declaration_marks: (String | Symbol name) -> Scope
+    # sig-gen gap: #1154 — the records come out of `@declaration_sourced`, an ivar assigned in `initialize` from a
+    # parameter, which reaches `untyped`.
+    def declaration_sourced_global_copies: (String | Symbol name) -> Array[Symbol]
     def with_declaration_sourced_local: (String | Symbol name, Type::t type) -> Scope
     def with_local_declaration_mark: (String | Symbol name) -> Scope
+    # `rigor sig-gen --params=observed` output; the siblings' hand-written `String | Symbol` / `Type::t`
+    # parameters are not inferred here either.
+    def with_mutated_local: (untyped name, untyped type) -> Scope
     def declaration_sourced?: (Symbol kind, String | Symbol name) -> bool
     def with_inferred_param_mark: (String | Symbol name) -> Scope
     def without_inferred_param_mark: (String | Symbol name) -> Scope
     def inferred_param?: (String | Symbol name) -> bool
     def forget_match_globals: () -> Scope
+    def untyped_match_globals: () -> Scope
+    def match_globals_bound?: () -> bool
+    def with_match_frame: (untyped body, ?untyped parameters) -> Scope
+    # sig-gen gap: #1154 — the frame reader over an ivar assigned in `initialize` from a parameter reaches
+    # `untyped`, so the `bool` is hand-written.
+    def match_rebinding_closure?: () -> bool
+    def forget_last_line: () -> Scope
+    def untyped_last_line: () -> Scope
+    # sig-gen gap: #1154 — the reader over the `@globals` ivar `initialize` assigns from a parameter reaches
+    # `untyped`, so the `bool` is hand-written.
+    def last_line_bound?: () -> bool
+    # sig-gen gap: #1154 — the frame reader over the `@match_frame` ivar `initialize` assigns from a parameter
+    # reaches `untyped`, so the `bool` is hand-written.
+    def last_line_closure?: () -> bool
+    def forget_error_info: () -> Scope
+    def untyped_error_info: () -> Scope
+    def forget_last_status: () -> Scope
+    def untyped_last_status: () -> 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 user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> [untyped?, String?]
+    def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
+    def user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
     def discovered_method_through_ancestors?: (String | Symbol? class_name, String | Symbol method_name, Symbol kind, ?name_memo: Hash[untyped, untyped]) -> bool
+    def external_ancestor_name_candidates: (String | Symbol class_name, ?name_memo: Hash[untyped, untyped]) -> Array[Array[String]]
     def enqueue_ancestors: (String current, Array[String] queue, Hash[untyped, untyped] name_memo, ?mixins: bool) -> void
     def ancestor_name_candidates: (String | Symbol subclass_qualified, String | Symbol raw_ancestor) -> Array[String]
 
+    # sig-gen gap: #1148 — sig-gen skips the method (sig.skipped.untyped-return: every decline returns the
+    # frozen EMPTY_HEADER_NESTING constant); the row is hand-written.
+    def ambiguous_ancestor_resolutions: (String | Symbol subclass_qualified, String | Symbol raw_ancestor) -> Array[String]
+
     # Issue #530 — public so the external-gem ancestry probe asks the same question the walk does.
     def known_user_class?: (String | Symbol name) -> bool
-    def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
-    def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> [untyped?, String?]
+    def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
+    def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def user_singleton_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
-    def top_level_def_for: (String | Symbol method_name) -> untyped?
-    def bindable_top_level_def_for: (String | Symbol method_name) -> untyped?
+    # sig-gen gap: #1167 — the predicate forwards its untyped `Prism::CallNode` into the range scan,
+    # which reads `call_node.location` off it: a `Dynamic` receiver answers `Dynamic`, not `bool`, so
+    # sig-gen skips the method (and `def_shadows_call?` above it) as an untyped return.
+    def singleton_def_shadows_call?: (String | Symbol class_name, String | Symbol method_name, untyped call_node) -> bool
+    # sig-gen gap: #1167 — the instance-side twin: the same untyped `call_node`, the same untyped-return skip.
+    def instance_def_shadows_call?: (String | Symbol class_name, String | Symbol method_name, untyped call_node) -> bool
+    def top_level_def_for: (String | Symbol method_name) -> ::Prism::DefNode?
+    def bindable_top_level_def_for: (String | Symbol method_name) -> ::Prism::DefNode?
     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]
+    # sig-gen gap: #1153 — sig-gen proposes `Array[untyped] | []` off the empty-table early return, so the
+    # element type is hand-written, matching {#includes_of}.
+    def singleton_extends_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
     def without_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Scope

data/sig/rigor/sig_gen/skip_reason_catalog.rbs

@@ -0,0 +1,21 @@
+# `Rigor::SigGen` itself has no other declaration under `sig/`; without this shell `rbs validate`
+# rejects the two declarations below with `Could not find ::Rigor::SigGen`.
+module Rigor::SigGen
+end
+
+# Every entry is built from string literals in `SkipReasonCatalog::ENTRIES`, so the four readers
+# answer `String`.
+class Rigor::SigGen::SkipReasonCatalog::Entry < ::Data
+  def id: () -> String
+  def summary: () -> String
+  def explanation: () -> String
+  def next_step: () -> String
+  def self.new: (id: String, summary: String, explanation: String, next_step: String) -> instance | (String id, String summary, String explanation, String next_step) -> instance
+  def self.[]: (id: String, summary: String, explanation: String, next_step: String) -> instance | (String id, String summary, String explanation, String next_step) -> instance
+  def to_h: () -> Hash[String, String]
+end
+
+module Rigor::SigGen::SkipReasonCatalog
+  def self?.resolve: (untyped) -> Rigor::SigGen::SkipReasonCatalog::Entry?
+  def self?.all: () -> Array[Rigor::SigGen::SkipReasonCatalog::Entry]
+end