rigortype 0.4.0 → 0.4.2

data/plugins/rigor-typelizer/lib/rigor/plugin/typelizer/serializer_index.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Typelizer < Rigor::Plugin::Base
+      # The project's classes (every file of the project's `paths:` and the typelizer `dirs`), as the {SerializerCollector} found them. A frozen value
+      # object the `:serializer_index` producer caches.
+      #
+      # {#roots} answers the one question, conservatively — a wrong "no" costs a missing root, a wrong "yes"
+      # hides a dead class.
+      class SerializerIndex
+        # A class the project declares. `superclass` is the constant as written (`nil` when absent) and
+        # `nesting` the `Module.nesting` chain (innermost first) its header was written under, which is where
+        # Ruby resolves that constant. `dsl` is true when its body includes or extends `Typelizer::DSL`; `in_dirs` when a file under the
+        # typelizer `dirs` declares it (only such a class is published as a root).
+        ClassEntry = Data.define(:name, :superclass, :nesting, :dsl, :in_dirs)
+
+        def initialize(classes:)
+          @classes = classes.to_h { |entry| [entry.name, entry] }.freeze
+          freeze
+        end
+
+        def empty?
+          @classes.empty?
+        end
+
+        # Every class typelizer generates an interface for: a class that registered itself through the DSL, and
+        # each subclass of one (`Typelizer.target_serializers` takes `descendants`).
+        def roots
+          @classes.keys.select { |name| @classes[name].in_dirs && typelized?(name, {}) }.sort
+        end
+
+        private
+
+        def typelized?(name, seen)
+          entry = @classes[name]
+          return false if entry.nil? || seen[name]
+
+          seen[name] = true
+          return true if entry.dsl
+
+          parent = superclass_of(entry)
+          !parent.nil? && typelized?(parent, seen)
+        end
+
+        # Resolves the superclass as written the way Ruby does: against the `Module.nesting` chain of the header,
+        # innermost first, then the top level. A compact header (`class Admin::UserSerializer < Base`) does not
+        # put `Admin` on the chain, so `Base` is not looked up under it. The first match wins, so a class that
+        # shadows the DSL base (`Admin::Base` with no DSL) ends the walk there.
+        #
+        # Ruby also searches the ancestors of the innermost cref before the top level. That is not modelled, so a
+        # name that is not found on the lexical chain is declined (nil: not typelized) when the innermost scope
+        # is a class with a superclass, since the constant might live on that superclass.
+        def superclass_of(entry)
+          written = entry.superclass
+          return nil if written.nil?
+
+          if written.start_with?("::")
+            rooted = written.delete_prefix("::")
+            return @classes.key?(rooted) ? rooted : nil
+          end
+
+          lexical = entry.nesting.map { |scope| "#{scope}::#{written}" }.find { |name| @classes.key?(name) }
+          return lexical if lexical
+          return nil if cref_has_ancestors?(entry.nesting.first)
+
+          @classes.key?(written) ? written : nil
+        end
+
+        def cref_has_ancestors?(scope)
+          !scope.nil? && !@classes[scope]&.superclass.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "typelizer/serializer_index"
+require_relative "typelizer/serializer_collector"
+require_relative "typelizer/serializer_discoverer"
+
+module Rigor
+  module Plugin
+    # rigor-typelizer — roots the serializer classes the typelizer gem
+    # (https://github.com/skryukov/typelizer) generates TypeScript interfaces from, so `rigor unused` does not
+    # list them as removal candidates.
+    #
+    # typelizer's `Typelizer.target_serializers` is `base_classes + base_classes.flat_map(&:descendants)`, where
+    # `base_classes` holds every named class that ran `include Typelizer::DSL` or `extend Typelizer::DSL`. Such
+    # a class may never be referenced from Ruby and still be consumed by the frontend through the generated
+    # type, so the plugin publishes it — and every project subclass of it — as a `:reachability_roots` fact.
+    #
+    # The plugin adds no diagnostic and no return type. It models nothing at runtime: `reject_class` (a lambda
+    # in typelizer's configuration that can drop a class from the output) is not evaluated, so a rejected class
+    # is still rooted. That costs a hidden candidate, never a false report.
+    class Typelizer < Rigor::Plugin::Base
+      manifest(
+        id: "typelizer",
+        target_gems: ["typelizer"],
+        version: "0.1.0",
+        description: "Roots the serializer classes typelizer generates TypeScript interfaces from, " \
+                     "for `rigor unused`.",
+        config_schema: {
+          # Typelizer::Railtie sets exactly these two when `Typelizer.dirs` is empty.
+          "dirs" => { kind: :array, default: %w[app/resources app/serializers] }
+        },
+        produces: [:reachability_roots]
+      )
+
+      producer :serializer_index, watch: -> { watch_globs } do |_params|
+        SerializerDiscoverer.new(io_boundary: io_boundary, dirs: @dirs, project_paths: @project_paths).discover
+      end
+
+      def init(services)
+        @dirs = Array(config.fetch("dirs")).map(&:to_s)
+        @project_paths = Array(services.configuration.paths).map(&:to_s)
+      end
+
+      def prepare(services)
+        index = producer_value(:serializer_index)
+        return if index.nil?
+
+        roots = index.roots
+        return if roots.empty?
+
+        services.fact_store.publish(plugin_id: manifest.id, name: :reachability_roots, value: roots)
+      end
+
+      private
+
+      # Superclass resolution reads every file of the project's `paths:` (a shadowing `Admin::Base` may live
+      # outside `dirs`), so all of them are watched, not only `dirs`.
+      def watch_globs
+        (@dirs + @project_paths).filter_map do |entry|
+          if io_boundary.directory?(File.expand_path(entry))
+            [entry, "**/*.rb"]
+          elsif entry.end_with?(".rb") && io_boundary.file?(File.expand_path(entry))
+            [File.dirname(entry), File.basename(entry)]
+          end
+        end
+      end
+    end
+
+    Rigor::Plugin.register(Typelizer)
+  end
+end

data/plugins/rigor-typelizer/lib/rigor-typelizer.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/typelizer"

data/sig/rigor/analysis/dependency_source_inference/index.rbs

@@ -2,7 +2,7 @@ module Rigor
   module Analysis
     module DependencySourceInference
       class Index
-        def initialize: (?resolved_gems: untyped, ?unresolvable: untyped, ?method_catalog: untyped, ?budget_exceeded: untyped, ?class_to_gem: untyped, ?budget_overrun_strategy: untyped) -> void
+        def initialize: (?resolved_gems: untyped, ?unresolvable: untyped, ?method_catalog: untyped, ?budget_exceeded: untyped, ?class_to_gem: untyped, ?budget_overrun_strategy: untyped, ?gem_modes: untyped, ?refinements: untyped) -> void
       end
     end
   end

data/sig/rigor/environment.rbs

@@ -20,6 +20,8 @@ module Rigor
 
     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
+    # authored: the return is the `signature_paths:` argument's type (authored intent) or the default [Pathname]; sig-gen types the `||` fallback untyped.
+    def self.project_signature_roots: (Array[String | _ToPath]? signature_paths, ?root: String) -> Array[String | _ToPath]
 
     def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?source_rbs_synthesis_reporter: untyped?, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> void
     def rbs_extended_reporter: () -> untyped?

data/sig/rigor/plugin/io_boundary.rbs

@@ -4,10 +4,14 @@ class Rigor::Plugin::IoBoundary
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
   def list_directory: (untyped) -> Array[String]
+  # Records a `:names` glob row (membership only); a caller needing a match's content `read_file`s it. A `..`
+  # segment, a brace or a backslash in `pattern` raises `AccessDeniedError`.
+  def glob: (untyped root, untyped pattern) -> 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
+  def replay: (untyped descriptor) -> nil
 end

data/sig/rigor/scope.rbs

@@ -29,6 +29,10 @@ module Rigor
     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`.
+    # Issue #1759 — `:refinement` (REFINEMENT_BLOCK_SELF) directly in a `refine X do … end` block body.
+    attr_reader block_self_unknown: bool | :refinement
+    # 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.
@@ -37,6 +41,12 @@ module Rigor
     # 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]
+    # Issue #1446 — the classes a class guard narrowed a `bot` receiver to.
+    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
+    attr_reader bot_guard_classes: Hash[[Symbol, Symbol | String], Array[String]]
+    # Issue #1667 — the modules a plugin-declared refined block runs under, in declaration order.
+    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
+    attr_reader declared_refinements: Array[String]
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # DiscoveryIndex; Scope keeps per-table readers as delegates.
@@ -61,8 +71,11 @@ module Rigor
     # 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]]]
+    # shape is hand-written. A method key is a Symbol or the `"*"` wildcard (ADR-121 WD7).
+    def discovered_refinements: () -> Hash[String, Hash[Symbol | String, Array[String]]]
+    # authored: the list holds module names and the `InEffectRefinements::UNKNOWN` Symbol; sig-gen reads the delegated
+    # return through an unsigned class as untyped.
+    def in_effect_refinements: (untyped node, ?Array[String] declared) -> Array[String | Symbol]
     # 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]]
@@ -141,7 +154,7 @@ module Rigor
       # 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]]]
+      attr_reader discovered_refinements: Hash[String, Hash[Symbol | String, 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?
@@ -154,10 +167,41 @@ module Rigor
       # `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
+      # sig-gen gap: #1150 — `Data.define` members carry no type; the value is an `Inference::InEffectRefinements`
+      # (or nil), which carries no signature either.
+      attr_reader in_effect_refinements: untyped
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader possible_discovered_methods: 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 possible_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 contested_discovered_def_nodes: Set[Array[untyped]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader contested_discovered_singleton_def_nodes: Set[Array[untyped]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader contested_discovered_method_visibilities: Set[Array[untyped]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader contested_discovered_parameter_envelopes: Set[Array[untyped]]
 
       EMPTY: DiscoveryIndex
+      # authored: ADR-119 WD1 — hand-written beside the `Data.define` rows above (#1150).
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      SIBLINGS: Hash[Symbol, Symbol]
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      EMPTY_SIBLINGS: Hash[Symbol, untyped]
+
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.empty_value: (Symbol name) -> untyped
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.empty_siblings: () -> Hash[Symbol, untyped]
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.compact_pairs: (Hash[Symbol, untyped] tables) -> Hash[Symbol, untyped]
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.paired?: (Symbol name) -> bool
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def sibling_tables: () -> Hash[Symbol, untyped]
 
-      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
+      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 | String, 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, ?in_effect_refinements: untyped, ?possible_discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?possible_discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?contested_discovered_def_nodes: Set[Array[untyped]], ?contested_discovered_singleton_def_nodes: Set[Array[untyped]], ?contested_discovered_method_visibilities: Set[Array[untyped]], ?contested_discovered_parameter_envelopes: Set[Array[untyped]]) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -180,8 +224,15 @@ module Rigor
     def with_lexical_nesting: (Array[String]? chain) -> Scope
     def struct_fold_safe?: (String | Symbol name) -> bool
     def entering_opaque_block: () -> Scope
+    # sig-gen gap: #1148 — sig-gen skips the endless-def reader (sig.skipped.untyped-return); the row is hand-written.
+    def block_self_unknown?: () -> bool
+    REFINEMENT_BLOCK_SELF: :refinement
+    # sig-gen gap: #1148 — sig-gen skips the endless-def predicate (sig.skipped.untyped-return); the row is hand-written.
+    def refinement_block_self?: () -> bool
+    def with_block_self_unknown: (bool flag) -> Scope
     def opaque_block_self?: () -> bool
     def with_singleton_class_body: (bool) -> Scope
+    def with_declared_refinements: (Array[String] names) -> 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
@@ -206,6 +257,15 @@ module Rigor
     # 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
+    # Issue #1446 — `rigor sig-gen` output.
+    def with_guarded_ivar: (untyped name, untyped type, untyped pre_guard) -> Scope
+    def without_ivar_guard: (untyped name) -> Scope
+    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
+    def guard_narrowed_ivar?: (untyped name) -> bool
+    # Issue #1446 — `rigor sig-gen` output.
+    def with_bot_guard_classes: (untyped kind, untyped name, untyped class_names) -> Scope
+    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
+    def bot_guard_classes_for: (untyped kind, untyped name) -> Array[String]?
     def without_constant_narrowing: (untyped key) -> Scope
     def guard_narrowed?: () -> bool
     def forget_guard_narrowings: () -> Scope
@@ -259,6 +319,8 @@ module Rigor
     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
+    # authored: the slot is a Prism::DefNode or a DefHandle until ADR-119 C1d/C2 decide its type.
+    def def_node_slot: (untyped class_name, untyped method_name, ?Symbol kind) -> untyped
     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
@@ -295,6 +357,7 @@ module Rigor
     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 with_isolated_side_tables: () -> Scope
     def without_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Scope
     def without_indexed_narrowings_for: (Symbol receiver_kind, String | Symbol receiver_name) -> Scope
     def method_chain_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, String | Symbol method_name) -> Type::t?
@@ -303,6 +366,8 @@ module Rigor
     def without_method_chain_narrowings_for: (Symbol receiver_kind, String | Symbol receiver_name) -> Scope
     def with_fact: (Analysis::FactStore::Fact fact) -> Scope
     def with_self_type: (Type::t? type) -> Scope
+    def with_block_self_type: (Type::t? type, ?keeps_unknown: bool | :refinement) -> Scope
+    def block_self_narrowing_unknown?: (Prism::CallNode call_node) -> bool
     def facts_for: (?target: Analysis::FactStore::Target?, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
     def local_facts: (String | Symbol name, ?bucket: Symbol?) -> Array[Analysis::FactStore::Fact]
     def type_of: (untyped node, ?tracer: Inference::FallbackTracer?) -> Type::t

data/sig/rigor/source.rbs

@@ -21,6 +21,10 @@ module Rigor
       def self?.symbol_arg: (untyped? call_node, Integer index) -> Symbol?
     end
 
+    module SymbolName
+      def self?.of: (String? text) -> Symbol?
+    end
+
     module NodeWalker
       def self?.each: (untyped root) { (untyped) -> void } -> nil
                     | (untyped root) -> Enumerator[untyped, nil]

data/sig/rigor.rbs

@@ -14,7 +14,9 @@ module Rigor
     def self.load: (?String? path) -> Configuration
     def self.discover: () -> String?
     def self.load_with_includes: (String path, ?visited: Set[String]) -> Hash[String, untyped]
-    def initialize: (?Hash[String, untyped] data, ?bool effects_key_present) -> void
+    def initialize: (?Hash[String, untyped] data, ?bool effects_key_present, ?bool target_ruby_key_present) -> void
+    def target_ruby_explicit?: () -> bool
+    def stated_runtime_ruby: () -> String?
     def to_h: () -> Hash[String, untyped]
     # ADR-103 WD13 — the `effects:` block, nil when the key was absent. Presence is the opt-in.
     attr_reader effects: Hash[String, untyped]?

data/skills/rigor-project-init/SKILL.md

@@ -88,7 +88,7 @@ diagnostics.
 | Today's diagnostics | Snapshotted into `.rigor-baseline.yml`; suppressed as long as the count does not grow. | All surfaced; every one is fixed or consciously suppressed. |
 | Hard-to-fix diagnostics | Left in the baseline. The project **trusts its test / spec suite** to cover runtime correctness for those sites — the static `T | nil` reading is worst-case-sound, the suite proves the worst case is not hit. | Fixed, or annotated `# rigor:disable <rule>` with an author-intent reason at the specific line. No blanket suppression. |
 | `severity_profile` | `lenient` (or `balanced` for a small project). | `strict`. |
-| Best for | Mature codebases; incremental adoption; teams that want the regression guard without a big upfront fix. | New / small projects; libraries; teams that want the maximum guarantee and have the budget to reach zero. |
+| Best for | **Every project by default** — mature or brand-new, large or small. | Users fluent in both type theory and RBS who opt in and will resolve Rigor's inference gaps themselves. |
 | New diagnostics later | Surface immediately — anything beyond the baseline envelope is a regression. | Surface immediately — there is no envelope; every diagnostic is live. |
 
 Both modes give the same core guarantee: **a change that introduces
@@ -97,12 +97,35 @@ diagnostics that exist *today*. Acknowledge mode parenthesises them
 behind a baseline and leans on the test suite; strict mode refuses to
 parenthesise anything.
 
-If the project's first `rigor check` reports more than ~100 errors,
-recommend acknowledge mode as the default and let the user override.
-Below that, either mode is reasonable — ask.
-
-Note the ordering: the error count that feeds this recommendation (and
-the `severity_profile` choice in Phase 4) is only *measured* in
+**Recommend acknowledge mode for every project, including new and
+small ones.** Rigor's inference still has gaps, so even a fresh
+project meets diagnostics on correct code. Under strict mode each one
+needs a `sig/` fix, an RBS workaround, or a reasoned
+`# rigor:disable` — work that takes type theory and RBS. Without that
+knowledge, users rewrite correct code for the tool or scatter
+suppressions. Acknowledge mode keeps the same regression guard with an
+exit: a new diagnostic still fails the check, and once it is confirmed
+as an inference gap, the baseline can absorb it (report the false
+positive upstream). `rigor baseline regenerate` rewrites the baseline
+from every live diagnostic, so run it only when a whole-project
+`rigor check` (no path arguments) shows nothing but confirmed false
+positives; otherwise it silences a real
+bug alongside them.
+
+Present strict mode as an opt-in for users who know type theory and
+RBS, want the zero-diagnostic gate, and accept resolving inference
+gaps themselves — never as the recommendation, and never because the
+project is new, small, or a library. If the user picks it, tell them
+how to move to acknowledge mode later: optionally relax
+`severity_profile`, re-run triage, then run Phase 7 (generate a
+baseline and wire `baseline:`). The profile change comes first because
+it changes which rules fire.
+
+For a large first run (more than ~100 errors), acknowledge mode also
+suggests `severity_profile: lenient`; see Phase 4.
+
+Note the ordering: the error count that feeds the `severity_profile`
+choice in Phase 4 is only *measured* in
 Phase 6's triage run. Any profile written in Phase 4 is therefore
 **provisional** — Phase 6 revisits it against the measured count (see
 [`references/02-configure.md`](references/02-configure.md)
@@ -111,12 +134,15 @@ Phase 6's triage run. Any profile written in Phase 4 is therefore
 ## Non-interactive / agent-driven runs
 
 This skill has several ask-the-user points (the mode choice, the RBS
-collection install, the final gitignore-and-commit confirmation). When
-the user delegated the onboarding up front — including the adoption
-mode — those points resolve without blocking:
+collection install, the final gitignore-and-commit confirmation). A
+*delegation* is the user asking, before the run, for the onboarding to
+proceed without these questions ("set it up, don't ask me"). An
+ordinary request to set Rigor up is not one: ask as usual. Under a
+delegation those points resolve without blocking:
 
 - The **mode** the user pre-declared is settled; record it and skip the
-  Phase 2 presentation.
+  Phase 2 presentation. If the delegation names no mode, choose
+  acknowledge mode and say so in the report — never strict.
 - Low-risk, reversible, in-repo confirmations (`rbs collection
   install`, the `.gitignore` addition) are covered by the delegation —
   act, and note each self-answer in your report.

data/skills/rigor-project-init/references/02-configure.md

@@ -138,14 +138,19 @@ entirely — including a `sig/` that `rigor sig-gen --write` created.
 List only directories that contain `.rbs` files or subdirectories of
 them. Rigor walks each path recursively.
 
-A strict-mode plain-Ruby gem is shorter:
+A plain-Ruby gem is shorter. The `balanced` default needs no
+`severity_profile:` key:
 
 ```yaml
 paths:
   - lib
 test_paths:
   - test
-severity_profile: strict
+
+# Phase 7 (acknowledge mode) appends this line after generating the
+# baseline. Strict mode (opt-in) sets `severity_profile: strict` and
+# leaves it out.
+# baseline: .rigor-baseline.yml
 ```
 
 ### Test roots — write `test_paths:` explicitly