rigortype 0.3.9 → 0.4.0

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

@@ -7,14 +7,15 @@ module Rigor
     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?
-    # sig-gen gap: #656 — sig-gen skips the method (untyped return), so the resolved-name-or-decline is hand-written.
+    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,15 +52,34 @@ 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]]
-    # sig-gen gap: #898 — sig-gen skips the endless-def reader (untyped return), so the table shape is hand-written.
+    # 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: #667 — sig-gen types the `||` fallback `untyped`, so the element type is hand-written.
+    # 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
@@ -62,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]]
@@ -76,26 +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]]
-      # sig-gen gap: #898 — `Data.define` members carry no type, as for every other row in this class.
+      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: #667 — `Data.define` members carry no type, so every row in this class is authored.
+      # 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: #667 — as above.
+      # 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_extends: 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], ?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]], ?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
@@ -119,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?
@@ -128,54 +193,104 @@ 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
-    # sig-gen gap: #667 — an `attr_reader` over a frozen Set literal types `untyped`, as the sibling
+    # 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: #667 — `Set#include?` over a tuple key types `untyped`, so the `bool` is hand-written.
+    # 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
-    def declaration_sourced: () -> Set[[Symbol, Symbol]]
+    # 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] | [nil, nil])
+    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] | [nil, nil])
+    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: #898 — sig-gen proposes `Array[untyped] | []` off the empty-table early return, so the
+    # 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?

data/sig/rigor/sig_gen/skip_reason_catalog.rbs

@@ -1,11 +1,18 @@
+# `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: () -> untyped
-  def summary: () -> untyped
-  def explanation: () -> untyped
-  def next_step: () -> untyped
-  def self.new: (id: untyped, summary: untyped, explanation: untyped, next_step: untyped) -> instance | (untyped id, untyped summary, untyped explanation, untyped next_step) -> instance
-  def self.[]: (id: untyped, summary: untyped, explanation: untyped, next_step: untyped) -> instance | (untyped id, untyped summary, untyped explanation, untyped next_step) -> instance
-  def to_h: () -> Hash[String, untyped]
+  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

data/sig/rigor/source.rbs

@@ -4,11 +4,11 @@ module Rigor
       class OutOfRangeError < StandardError
       end
 
-      def self.at_position: (source: String, root: untyped, line: Integer, column: Integer) -> untyped?
-      def self.at_offset: (root: untyped, offset: Integer) -> untyped?
+      def self.at_position: (source: String, root: untyped, line: Integer, column: Integer) -> ::Prism::Node?
+      def self.at_offset: (root: untyped, offset: Integer) -> ::Prism::Node?
       def initialize: (source: String, root: untyped) -> void
-      def at_position: (line: Integer, column: Integer) -> untyped?
-      def at_offset: (Integer offset) -> untyped?
+      def at_position: (line: Integer, column: Integer) -> ::Prism::Node?
+      def at_offset: (Integer offset) -> ::Prism::Node?
     end
 
     module Literals

data/sig/rigor/testing.rbs

@@ -1,9 +1,15 @@
 module Rigor
   module Testing
-    def self?.dump_type: (untyped value) -> untyped
-    def self?.assert_type: (String expected, untyped value) -> untyped
+    # Both helpers return `value` unchanged (lib/rigor/testing.rb); the type variable carries the
+    # argument's type through so a probed expression stays typed downstream instead of widening to
+    # `Dynamic[top]`. `A` binds only on a dispatch that carries a scope — a `Rigor.` /
+    # `Rigor::Testing.` receiver, or an including class that is RBS-known. A bare `dump_type(x)` after
+    # `include Rigor::Testing` in a discovered-only class still reaches the ancestor fallback without a
+    # scope and answers `Dynamic[top]`, as it did under `-> untyped` (#303 follow-up).
+    def self?.dump_type: [A] (A value) -> A
+    def self?.assert_type: [A] (String expected, A value) -> A
   end
 
-  def self.dump_type: (untyped value) -> untyped
-  def self.assert_type: (String expected, untyped value) -> untyped
+  def self.dump_type: [A] (A value) -> A
+  def self.assert_type: [A] (String expected, A value) -> A
 end

data/sig/rigor/type.rbs

@@ -429,8 +429,14 @@ module Rigor
       attr_reader trinary: Trinary
       attr_reader mode: accepts_mode
       attr_reader reasons: Array[String]
+      # sig-gen gap: #1155 — the memoized `||=` return is an honest union with an
+      #   untyped arm (the slot read cannot prove the memoized value), so sig-gen
+      #   skips it (sig.skipped.untyped-return); the runtime result is always
+      #   AcceptsResult and the row is hand-written.
       def self.yes: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
+      # sig-gen gap: #1155 — same memoized `||=` untyped-return gap as `self.yes`.
       def self.no: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
+      # sig-gen gap: #1155 — same memoized `||=` untyped-return gap as `self.yes`.
       def self.maybe: (?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> AcceptsResult
       def initialize: (Trinary trinary, ?mode: accepts_mode, ?reasons: (Array[String] | String)?) -> void
       def yes?: () -> bool

data/sig/rigor.rbs

@@ -124,32 +124,50 @@ module Rigor
       attr_reader buffer: untyped
       attr_reader file_dependencies: Hash[String, untyped]
       attr_reader analyzed_files: Array[String]
-      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped, ?workers: Integer, ?collect_stats: bool, ?buffer: untyped, ?prebuilt: untyped, ?environment: untyped, ?record_dependencies: bool, ?analyze_only: untyped) -> void
+      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped, ?workers: Integer, ?collect_stats: bool, ?buffer: untyped, ?prebuilt: Analysis::ProjectScan?, ?environment: untyped, ?record_dependencies: bool, ?analyze_only: untyped) -> void
       def run: (?Array[String] paths) -> Result
       def run_source: (source: String, ?path: String) -> Result
       def analysis_file_set: (?Array[String] paths) -> Array[String]
       def file_dependents: () -> Hash[String, untyped]
-      def prepare_project_scan: (?paths: Array[String]) -> untyped
+      def prepare_project_scan: (?paths: Array[String]) -> Analysis::ProjectScan
       # ADR-103 — the propagated effect graph and the merged per-file collections behind it. A report
-      # surface: never a diagnostic, empty when the configuration carries no `effects:` block. Typed
-      # `untyped` for the same reason `cache_store` is — `Rigor::Effects` is not sig-covered yet
-      # (`spec/rigor/public_api_drift_spec.rb`), and a named reference would raise `RBS::UnknownTypeName`.
-      def effect_table: () -> untyped
-      def effect_collection: () -> untyped
-      # #381 — `{ "Class#m" => [path] }`, which the snapshot's `reach:` globs match against. Same
-      # `untyped` reasoning as its two siblings above.
-      def effect_sources: () -> untyped
-      # #387 — the loaded plugins' compiled effect contributions, read by `rigor effects` so the snapshot's
-      # vocabulary is the one the collection window scanned under. Same `untyped` reasoning again.
-      def effect_plugin_facts: () -> untyped
+      # surface: never a diagnostic, empty when the configuration carries no `effects:` block.
+      def effect_table: () -> Effects::EffectTable
+      def effect_collection: () -> Effects::FileCollection
+      # ADR-103 WD9 (#391): the resolved envelope index `rigor sig-gen`'s annotation emission
+      # consults, built on demand so a warm-cache run still serves the same strata.
+      def effect_envelopes: () -> Effects::EnvelopeIndex
+      # #381 — `{ "Class#m" => [path] }`, which the snapshot's `reach:` globs match against.
+      def effect_sources: () -> Hash[String, Array[String]]
+      # #387 — the loaded plugins' compiled effect contributions, read by `rigor effects` so the
+      # snapshot's vocabulary is the one the collection window scanned under.
+      def effect_plugin_facts: () -> Effects::PluginFacts
+      # The run's as-written superclass table — what `effect.liskov-widened` reads.
+      def effect_ancestry: () -> Hash[String, String]
+      # `{ "lib/a.rb" => FileCollection, … }` — the per-file collections the caches persist (#382).
+      def effect_collections_by_path: () -> Hash[String, Effects::FileCollection]
+      # Issue #382 — adopt persisted collections as this run's own (the warm-hit half of the
+      # whole-run effects slot).
+      def adopt_effect_collections: (Hash[String, Effects::FileCollection] collections,
+                                     ?table: Effects::EffectTable?) -> void
+      # #482 — adopt the served run's small summary entry, collections left behind a loader.
+      def adopt_effect_summary: (table: Effects::EffectTable, sources: Hash[String, Array[String]],
+                                 ancestry: Hash[String, String], collections_loader: untyped) -> void
+      # Whether this run's effect collections came from the whole-run effects slot (#382).
+      def effects_served_from_cache?: () -> bool
       # The incremental session's read surface (ADR-46 / ADR-67 / ADR-103) — `IncrementalSession`
-      # drives a live Runner through these between rechecks. Typed `untyped` like the cache / effects
-      # readers above until their namespaces are sig-covered.
-      def return_summaries: () -> untyped
-      def param_inferred_types: () -> untyped
-      def effect_collections_by_path: () -> untyped
-      def collect_param_inference_table: (untyped files) -> untyped
-      def evaluate_return_types: (untyped paths, untyped specs) -> untyped
+      # drives a live Runner through these between rechecks.
+      # sig-gen gap: #1008 — `result` is populated by `collect_return_summaries` mutating it by
+      # reference from a sibling method; sig-gen folds only the `{}` seed and the empty-memo early
+      # return, so it proposes the seed shape instead of the honest, usually-non-empty contract.
+      # Keys are `[path, "Class#method"]` pairs; values are `{ keys:, returns:, effects: }` bundles.
+      def return_summaries: () -> Hash[[String, String], Hash[Symbol, untyped]]
+      # ADR-67 — `[class_name, method_name, kind] => { param_name => Type }`.
+      def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
+      def collect_param_inference_table: (untyped files) -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
+      # `{ class_name:, method_name:, singleton: }` spec triple => the per-key return descriptors
+      # (`describe(:short)` strings; nil for a missing/bodyless def).
+      def evaluate_return_types: (untyped paths, untyped specs) -> Hash[[String, Symbol, bool], Array[String?]]
     end
   end
 

data/skills/rigor-ask/SKILL.md

@@ -1,7 +1,9 @@
 ---
 name: rigor-ask
-description: |
-  Answer any question about Rigor by investigating, not from memory — Rigor is niche and version-specific, so run its tools and read its bundled docs, then answer from what you saw. Use `rigor docs` (handbook + manual, offline and version-matched) and `rigor explain <rule>`; for the user's own code, `rigor check` / `annotate` / `type-of`. Covers: why a line is flagged or whether it's a false positive; the type model (narrowing, refinements, `Dynamic`, RBS); config keys, flags, baselines; comparisons to Sorbet, Steep, mypy, PHPStan; whether Rigor handles Rails, RSpec, or a given gem; how to type a method; "what is Rigor / why use it / is it right for us?". Trigger on any Rigor question seeking understanding — even casual, comparative, or grumbling. Skip only when it's purely "set it up / fix / reduce it for me" (use rigor-next-steps).
+description: >-
+  Answer a question about Rigor from version-matched bundled docs and tool output. Use when the user
+  asks why a diagnostic fired, how a type/config/flag works, or how Rigor compares with another tool; not
+  when they ask you to set up, fix, or reduce something.
 license: MPL-2.0
 metadata:
   version: 0.2.0
@@ -51,8 +53,9 @@ rigor --help                   # the live command + flag list
 rigor skill --full rigor-ask   # the current version of this skill itself
 ```
 
-Never cite a page, flag, or rule id you have not just seen in one of these
-— that is this skill's whole discipline. If `rigor` is not installed, you
+Cite a page, flag, or rule id only after you have seen it in this
+install — `rigor docs`, `rigor --help`, `rigor explain`, or the gem's own
+files (see "If the docs don't cover it"). If `rigor` is not installed, you
 can still answer high-level "what is Rigor?" questions from the web
 <https://rigor.typedduck.fail/llms.txt>, but for anything version-specific
 install it first (see `rigor-next-steps`).
@@ -80,7 +83,7 @@ Everything here is read-only and needs no network.
 | `rigor triage` | Cluster the project's diagnostics by rule / receiver / method — for "what's the shape of my errors?". |
 | `rigor coverage [--protection]` | Type / type-protection coverage — for "how well-typed is this?" and "where are the holes?". |
 | `rigor plugins` | Which plugins are installed and enabled *here* — the honest answer to "does Rigor support <gem/framework>?". |
-| `rigor sig-gen <path>` | Generate RBS for code — for "how do I type this?". Offer it and show the result; this project prefers sig-gen over hand-written RBS. |
+| `rigor sig-gen <path>` | Generate RBS for code — for "how do I type this?". Offer it and show the result — generated RBS is derived; hand-written RBS is a guess until `rigor check` agrees (see `rigor-type-oracle`). |
 
 ## Where the answer lives
 

data/skills/rigor-baseline-reduce/SKILL.md

@@ -1,7 +1,9 @@
 ---
 name: rigor-baseline-reduce
-description: |
-  Work a Rigor project's `.rigor-baseline.yml` down rule by rule: prioritise with `rigor triage`, sample call sites, classify each as real bug / stylistic-safe / false positive, then fix, `# rigor:disable`, or open a Rigor issue — and regenerate the baseline. Triggers: "reduce the rigor baseline", "fix some baseline diagnostics", "what rigor issue should I fix next?". NOT for first-time setup (use rigor-project-init) or authoring a plugin (use rigor-plugin-author).
+description: >-
+  Reduce an existing `.rigor-baseline.yml` rule by rule by triaging sites, fixing or intentionally
+  suppressing them, and regenerating the baseline. Use for baseline diagnostics already acknowledged by a
+  project; not for first-time setup or plugin authoring.
 license: MPL-2.0
 metadata:
   version: 0.1.0
@@ -37,10 +39,6 @@ header names). If `rigor` is not on `PATH`, this task needs it: run
 
 ## Phase 0 — When to use this skill
 
-Trigger when the user says "reduce the rigor baseline", "fix some
-baseline diagnostics", "what should I fix next in rigor?", or asks to
-work down the diagnostics a previous onboarding parenthesised.
-
 **Precondition: the project is in acknowledge mode.** This skill
 operates on a `.rigor-baseline.yml` that `.rigor.yml` /
 `.rigor.dist.yml` declares via `baseline:`. A strict-mode project