rigortype 0.4.5 → 0.4.7

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/effects.rb

@@ -28,8 +28,8 @@ module Rigor
       #
       # An `ActiveRecord::Base` row reaches `User.find` through the project's own
       # `User < ApplicationRecord < ActiveRecord::Base` lines, so one row covers every model in the app.
-      # That is the whole economy of the framework layer: thirty-odd rows here colour the several thousand
-      # database touches a Rails app performs, and none of them needed a line of application code.
+      # That is the whole economy of the framework layer: a fixed set of rows here colours the several
+      # thousand database touches a Rails app performs, and none of them needed a line of application code.
       module Effects
         BASE = "ActiveRecord::Base"
         RELATION = "ActiveRecord::Relation"

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb

@@ -186,27 +186,20 @@ module Rigor
           merge_redeclarations(rows)
         end
 
-        # Collapses the rows that declare the SAME constant into one, so {ModelIndex.build} — which keys
-        # its entries by `class_name` — receives at most one row per model.
+        # Collapses the rows that declare the SAME constant into one, so {ModelIndex.build} (keyed by
+        # `class_name`) receives at most one row per model.
         #
-        # A model is routinely declared more than once: `app/models/user.rb` holds `class User <
-        # ApplicationRecord` and a second file reopens it (`class ::User`, `class User`, or a full
-        # `class User < ApplicationRecord` redeclaration) to add a method. Ruby's own semantics are
-        # ADDITIVE — a reopen contributes what it spells and leaves the rest of the class alone — so the
-        # rows are UNIONed here. Taking the last row instead dropped the real declaration's associations,
-        # scopes, enums, validations, callbacks and `alias_attribute`s whenever the reopen sorted later in
-        # the glob, and `where(<a declared alias>: …)` then surfaced a false `unknown-column` on correct
-        # code; taking the first dropped whatever the reopen added. Neither order loses anything now.
+        # A model is routinely declared more than once (`app/models/user.rb` plus a reopening file). Ruby's
+        # semantics are ADDITIVE, so the rows are UNIONed. Taking the last row dropped the real declaration's
+        # associations, scopes, enums, validations, callbacks and `alias_attribute`s whenever the reopen sorted
+        # later, producing false `unknown-column`s; taking the first dropped what the reopen added.
         #
-        # Merge is by field: the first non-nil `superclass_name` wins (a second declaration is the same
-        # thing, or invalid Ruby); `self.table_name =` is an ASSIGNMENT, so the LATER declaration's
-        # `table_name_override` wins as it does at load time, and when the two declarations disagree the
-        # resolved name is marked computed so no value is pinned — the glob order is not the load order for
-        # two full declarations, and a pinned wrong literal folds `Model.table_name == "…"` on correct code;
-        # `table_name_computed` is otherwise an OR (any computed name in the class makes the resolved one
-        # inexact); name-keyed rows (associations, enums, aliases) let the LAST declaration override an
-        # earlier same-name row exactly as {ModelIndex.merge_named_rows} does across an STI chain, and the
-        # plain lists union.
+        # Merge is by field: the first non-nil `superclass_name` wins. `self.table_name =` is an ASSIGNMENT, so
+        # the later `table_name_override` wins, but when two declarations disagree the name is marked computed
+        # so no value is pinned: glob order is not load order, and a pinned wrong literal would fold
+        # `Model.table_name == "…"` on correct code. `table_name_computed` is otherwise an OR. Name-keyed rows
+        # let the LAST declaration override an earlier same-name row, as {ModelIndex.merge_named_rows} does
+        # across an STI chain; plain lists union.
         def merge_redeclarations(rows)
           return rows if rows.length < 2
 
@@ -459,7 +452,6 @@ module Rigor
             macro_methods: lookup_macro_methods(node.body)
           })
 
-          # Recurse into the body in case nested classes exist.
           walk_for_classes(node.body, [full_name], &) if node.body
         end
 
@@ -869,8 +861,8 @@ module Rigor
 
         # Walks the namespace body's TOP-LEVEL statements only — a decorator declared inside a nested
         # `module`/`class` belongs to THAT namespace, not this one, and must not be attributed here.
-        # Returns `Hash<:prefix|:suffix => { literal: } | { computed: true }>`, only for the names this body
-        # actually mentions. A later statement overrides an earlier one within the SAME body — real Ruby
+        # Returns the decorators keyed by `:prefix` / `:suffix`, only for the names this body actually mentions.
+        # A later statement overrides an earlier one within the SAME body — real Ruby
         # assignment order, not a guess: `mattr_accessor :table_name_prefix` (no `default:`, so `computed:
         # true`) followed two lines down by a real `self.table_name_prefix = "blog_"` folds to the literal.
         #
@@ -1234,8 +1226,8 @@ module Rigor
         end
 
         # Recognised single-instance and collection association DSL methods. The kind drives the eventual
-        # return-type contribution: singular associations narrow to `Nominal[Target] | nil`, plural ones
-        # narrow to `ActiveRecord::Relation[Target]`.
+        # return-type contribution: singular associations narrow to the target or nil, plural ones to a
+        # relation of the target.
         #
         # `composed_of` value-object aggregations and `delegated_type` roles are folded in here too — both
         # accept the association name as a `where` / `find_by` query key, so omitting them turns every
@@ -1336,7 +1328,7 @@ module Rigor
                         association_option(args, "polymorphic") == true
 
           # A polymorphic association has no single static target class — `target` is nil and the flow
-          # contribution declines to narrow rather than inventing a wrong `Nominal[<classified-name>]`.
+          # contribution declines to narrow rather than inventing a wrong class-name target.
           if polymorphic
             target = nil
           else
@@ -1460,8 +1452,7 @@ module Rigor
         end
 
         # `enum status: { active: 0, archived: 1 }` (Rails ≤6) and `enum :status, [:active, :archived]`
-        # (Rails 7+). Returns `Hash<column_name => Array<Symbol>>`. Non-literal forms decline rather than
-        # guess.
+        # (Rails 7+). Non-literal forms decline rather than guess.
         def lookup_enums(body)
           return {} if body.nil?
 
@@ -1516,7 +1507,7 @@ module Rigor
         end
 
         # `scope :active, -> { ... }`. Records the scope name only (the body is intentionally NOT
-        # introspected — the caller contributes `ActiveRecord::Relation[Model]` based on the name alone
+        # introspected — the caller contributes a relation of the model based on the name alone
         # via `class_scope_return_type`).
         def lookup_scopes(body)
           return [] if body.nil?
@@ -1585,8 +1576,7 @@ module Rigor
 
         # `alias_attribute :new_name, :old_name`. Records the mapping so the analyzer accepts the alias
         # as a query key — without it every `where(<alias>: ...)` / `find_by(<alias>: ...)` call surfaces
-        # as a false `unknown-column`. Returns `Hash<alias => target>`; non-Symbol-literal forms decline
-        # rather than guess.
+        # as a false `unknown-column`. Non-Symbol-literal forms decline rather than guess.
         def lookup_aliases(body)
           return {} if body.nil?
 
@@ -1626,7 +1616,7 @@ module Rigor
         # macro and `images`, `images=`, `images_attachments`, `images_blobs` for the collection one — the
         # `has_one_attached` / `has_many_attached` generated-methods surface, none of it column-backed.
         # This is name MEMBERSHIP only, and does not overlap `rigor-activestorage`, which contributes the
-        # accessor's TYPE (`ActiveStorage::Attached::One`) and publishes no fact: a consumer that reads
+        # accessor's type and publishes no fact: a consumer that reads
         # `:model_index` to ask "does this model answer `avatar`?" gets nothing from that plugin, and gets
         # nothing at all when the project does not load it.
         ATTACHMENT_MACROS = {

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_index.rb

@@ -29,14 +29,12 @@ module Rigor
       # {Entry} resolves its table from the root model and inherits the chain's declared associations /
       # enums / aliases / scopes / validations / callbacks / macro methods.
       class ModelIndex
-        # `associations` is a frozen `Array<Hash>` where each row carries `{ name:, kind:, target:,
-        # nullable: }`:
+        # `associations` is a frozen list of rows `{ name:, kind:, target:, nullable: }`:
         #
-        # - `name`   — String, the association method name as the user invokes it (`"posts"`).
+        # - `name`   — the association method name as the user invokes it (`"posts"`).
         # - `kind`   — `:singular` (`belongs_to` / `has_one`) or `:collection` (`has_many`).
-        # - `target` — String, the target class name resolved either from an explicit `class_name:`
-        #              option or via {Inflector.classify}.
-        # - `nullable` — Boolean; whether a `:singular` accessor can return `nil`. `has_one` → `true`;
+        # - `target` — the target class name, from an explicit `class_name:` option or via {Inflector.classify}.
+        # - `nullable` — whether a `:singular` accessor can return `nil`. `has_one` → `true`;
         #              `belongs_to` → `false` (required by default since Rails 5) unless `optional: true`
         #              / `required: false`. Meaningless for `:collection` rows.
         #
@@ -71,27 +69,23 @@ module Rigor
 
           def association_names = associations.map { |a| a[:name] }
 
-          # `enums` is `Hash<column_name => Array<value_name>>`.
+          # `enums` maps a column name to its value names.
           def enum?(name) = enums.key?(name.to_s)
           def enum_values(name) = enums.fetch(name.to_s, [])
 
-          # `scopes` is `Array<scope_name>`.
           def scope?(name) = scopes.include?(name.to_s)
 
-          # `validations` is `Array<attribute_name>` covering both `validates :name, ...` and the
-          # `validates_*_of :name, ...` shorthand families.
+          # `validations` covers both `validates :name, ...` and the `validates_*_of :name, ...` shorthand families.
           def validation?(name) = validations.include?(name.to_s)
           def validated_attributes = validations
 
-          # `callbacks` is `Array<{ name:, callback: }>`.
           def callback_targets = callbacks.map { |c| c[:name] }
 
-          # `aliases` is `Hash<alias_name => target_attribute>` populated from `alias_attribute`
-          # declarations.
+          # `aliases` maps an alias name to its target attribute, from `alias_attribute` declarations.
           def alias?(name) = aliases.key?(name.to_s)
           def resolve_alias(name) = aliases[name.to_s]
 
-          # `macro_methods` is `Array<method_name>` — the instance methods a declaration macro installs that
+          # `macro_methods` lists the instance methods a declaration macro installs that
           # none of the sets above already carries (#1049): `delegate`'s names, the Paperclip / Active
           # Storage attachment readers, and an `enum`'s per-value predicates. Names only, with no type: a
           # consumer asks "does this model answer `followers_count`?", which is what a fail-closed check
@@ -312,7 +306,7 @@ module Rigor
           seen.values.map(&:freeze).freeze
         end
 
-        # `Hash<column => Array<value>>` merged across the STI chain; a child redeclaration of the same
+        # Enum value lists merged across the STI chain; a child redeclaration of the same
         # enum column overrides the ancestor's value list.
         def self.merge_enums(chain)
           chain.each_with_object({}) do |row, acc|
@@ -320,7 +314,7 @@ module Rigor
           end.freeze
         end
 
-        # `Hash<alias => target>` merged across the STI chain.
+        # Alias map merged across the STI chain.
         def self.merge_aliases(chain)
           chain.each_with_object({}) do |row, acc|
             (row[:aliases] || {}).each { |name, target| acc[name.to_s] = target.to_s }

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/schema_parser.rb

@@ -108,9 +108,8 @@ module Rigor
           false
         end
 
-        # Walks the block body collecting `t.<method>(...)` calls. Skips nested blocks (e.g. inside
-        # `if`-conditioned columns) only at the top level — for richer schema constructs the parser falls
-        # back silently.
+        # Walks the block body collecting `t.<method>(...)` calls. It descends through nested constructs
+        # (e.g. `if` branches) but does not recurse into a matched call.
         def collect_column_calls(node, &)
           return if node.nil?
 

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/schema_table.rb

@@ -21,7 +21,6 @@ module Rigor
           end
         end
 
-        # Map ActiveRecord column types → Ruby class names.
         RUBY_TYPE_MAPPING = {
           string: "String",
           text: "String",

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

@@ -59,8 +59,8 @@ module Rigor
     # capital R) is intentional — keeps the constant lookup distinct from `::ActiveRecord` even though the
     # gem name is hyphenated.
     #
-    # Note: this plugin is the seventh worked example. It does NOT require `active_record` at runtime — it
-    # only reads project source, the same way the other examples do. Rigor stays decoupled from Rails.
+    # Note: this plugin does NOT require `active_record` at runtime — it only reads project source, the
+    # same way the other examples do. Rigor stays decoupled from Rails.
     class Activerecord < Rigor::Plugin::Base
       manifest(
         id: "activerecord",
@@ -553,8 +553,9 @@ module Rigor
       end
 
       # Class-side finders + the class-side relation entry points. `find` returns the model, or an Array of
-      # them for two or more ids, or with a block the model or `nil`; `find_by!` returns the model; `find_by` adds the `nil` arm; `where` /
-      # `all` / `order` / `limit` / `none` open a relation. The relation then carries its element type
+      # them for two or more ids, or with a block the model or `nil`; `find_by!` returns the model;
+      # `find_by` adds the `nil` arm; `where` / `all` / `order` / `limit` / `none` open a relation. The
+      # relation then carries its element type
       # through any further chained query method via the bundled `ActiveRecord::Relation` RBS.
       def finder_return_type(call_node, entry, scope)
         case call_node.name

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_discoverer.rb

@@ -105,10 +105,9 @@ module Rigor
           walk(node.body, inner_path, &) if node.body
         end
 
-        # The full constant name a `class` / `module` declaration defines, given the rendered local name
-        # and the enclosing lexical path. A ROOTED local name (`class ::User`) names the top-level constant
-        # whatever the nesting, so the lexical path is dropped and the `::` with it; otherwise the name is
-        # appended to the path (`class User` inside `module Admin` → `Admin::User`).
+        # The full constant name a `class` / `module` declaration defines. A ROOTED local name (`class ::User`)
+        # names the top-level constant whatever the nesting, so the lexical path is dropped; otherwise the
+        # name is appended to it (`class User` inside `module Admin` → `Admin::User`).
         def declared_constant_name(local_name, lexical_path)
           return local_name.delete_prefix("::") if local_name.start_with?("::")
 

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_index.rb

@@ -8,7 +8,7 @@ module Rigor
       #
       # Each row is `{ name:, kind: }`:
       #
-      # - `name` — String, the attachment method name as the user invokes it (`"avatar"`).
+      # - `name` — the attachment method name as the user invokes it (`"avatar"`).
       # - `kind` — `:singular` (`has_one_attached`) or `:collection` (`has_many_attached`).
       class AttachmentIndex
         attr_reader :entries

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

@@ -137,19 +137,14 @@ module Rigor
         nil
       end
 
-      # Issue #1056 — "the attachment index did not load" is a fact about the run's INPUTS, not about the
-      # file being analysed, so both outcomes are registered rather than returned: see
-      # {Plugin::Base#disclose_once} for the channel and the position. Returned from the per-file hook they
-      # carried no once-guard at all — the `.uniq` collapsed repeats within one instance's list, but the
-      # whole list was re-emitted on every analysed file.
+      # Issue #1056 — "the attachment index did not load" is a fact about the run's INPUTS, not the file
+      # being analysed, so it is registered via {Plugin::Base#disclose_once} rather than returned from the
+      # per-file hook (which had no once-guard and re-emitted the list on every file).
       #
-      # The `key`s carry an ordinal prefix because the engine emits a plugin's disclosures in KEY order
-      # (#1051), and a refused read must still precede a discovery failure the way `@load_errors` records
-      # them — `@load_errors` is now keyed by that same string, which also caps it: `#attachment_index`
-      # re-attempts the load per call site, and the old Array appended a fresh interpolated string every
-      # time (the unbounded-growth shape #569 measured at 4.2 M retained strings on Redmine). The key, not
-      # the message, is the identity: a second refusal naming a different path collapses into the first row
-      # rather than adding one — the notice is "the index did not load", said once.
+      # The `key`s carry an ordinal prefix because the engine emits disclosures in KEY order (#1051), and
+      # a refused read must precede a discovery failure. `@load_errors` is keyed by the same string, which
+      # caps it: `#attachment_index` re-attempts the load per call site (#569). The key, not the message,
+      # is the identity, so a second refusal collapses into the first row.
       def disclose_load_errors
         @load_errors.each do |key, message|
           disclose_once(key, message: message, severity: :warning, rule: "load-error")

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

@@ -3,4 +3,4 @@
 # Entry point matching the `rigor-<id>` gem-name convention. The Plugin::Loader's `require_gem!` step
 # calls `require "rigor-activestorage"`, and this file loads the plugin's actual implementation under
 # the `rigor/plugin/` namespace so the require / register pair fires.
-require "rigor/plugin/activestorage"
+require_relative "rigor/plugin/activestorage"

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext/effects.rb

@@ -12,7 +12,7 @@ module Rigor
       # the core_ext predicate surface — the single cheapest purity win in a Rails app, per WD10 — is issue
       # #388 and lands in this plugin's shipped RBS, not here (`try` was audited and skipped: it dispatches
       # to whatever method the caller names, so its purity is a fact about the call site, not about `try`).
-      # One row below (`in_time_zone_row`) is #388's own addition: `DateTime#in_time_zone` reads `Time.zone`
+      # The `in_time_zone_rows` group is #388's own addition: `DateTime#in_time_zone` reads `Time.zone`
       # through a default argument, a gap the RBS sweep found but can only fix here.
       #
       # ## The clock

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext/symbolize_keys.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "rigor/type"
+
+module Rigor
+  module Plugin
+    class ActivesupportCoreExt < Rigor::Plugin::Base
+      # #2433 — the result type of `Hash#symbolize_keys` / `#to_options`.
+      #
+      # ActiveSupport implements them as `transform_keys { |key| key.to_sym rescue key }`, so a String or
+      # Symbol key becomes a Symbol and a key without `to_sym` (an Integer, a Float) survives unchanged. One
+      # RBS return type cannot say that: `Hash[Symbol, V]` reads an Integer key as a Symbol, and
+      # `Hash[Symbol | K, V]` makes a String-keyed hash fail a declared `Hash[Symbol, untyped]` parameter.
+      # So the RBS rows answer `Hash[untyped, V]` and this module maps each key member where it can.
+      #
+      # A key that is not a String or Symbol (an Integer, a project class) reads `Dynamic[top]`: no Rigor fact proves
+      # a class has no `to_sym` (a mixin, a `pre_eval` file or a reopening can add one), so a kept key could claim
+      # a type the program does not have. It declines (`nil`, the RBS row answers) when a receiver member is
+      # neither a `Hash[K, V]` nor `nil`. A `nil` member is dropped: `nil.symbolize_keys` raises, and the engine
+      # adds `nil` back for `&.`.
+      module SymbolizeKeys
+        HASH = "Hash"
+        SYMBOLIZED_CLASSES = %w[String Symbol].freeze
+
+        module_function
+
+        # Answers `Hash[K', V]` (the union of such over the receiver's Hash members), or nil to decline.
+        def result(receiver_type, scope)
+          members = receiver_type.is_a?(Rigor::Type::Union) ? receiver_type.members : [receiver_type]
+          answers = members.reject { |member| nil_member?(member) }.map { |member| member_answer(member, scope) }
+          return nil if answers.empty? || answers.any?(:decline)
+
+          hashes = answers.reject { |answer| answer == :empty }
+          hashes.empty? ? nil : Rigor::Type::Combinator.union(*hashes)
+        end
+
+        # An empty closed shape is `{}`: it adds no key, so it drops out of the union rather than declining it.
+        def member_answer(member, scope)
+          return :empty if member.is_a?(Rigor::Type::HashShape) && member.closed? && member.pairs.empty?
+
+          key_type, value_type = hash_arguments(member)
+          return :decline if key_type.nil?
+
+          Rigor::Type::Combinator.nominal_of(HASH, type_args: [map_key(key_type, scope), value_type])
+        end
+
+        def nil_member?(type)
+          (type.is_a?(Rigor::Type::Constant) && type.value.nil?) ||
+            (type.is_a?(Rigor::Type::Nominal) && type.class_name == "NilClass")
+        end
+
+        def hash_arguments(type)
+          case type
+          when Rigor::Type::Nominal
+            type.class_name == HASH && type.type_args.size == 2 ? type.type_args : nil
+          when Rigor::Type::Difference
+            hash_arguments(type.base)
+          when Rigor::Type::HashShape
+            shape_arguments(type)
+          end
+        end
+
+        # A closed, non-empty shape reads as `Hash[<its keys>, <union of its values>]`.
+        def shape_arguments(shape)
+          return nil if shape.open? || shape.pairs.empty?
+
+          keys = shape.pairs.keys.map { |key| Rigor::Type::Combinator.constant_of(key) }
+          [Rigor::Type::Combinator.union(*keys), Rigor::Type::Combinator.union(*shape.pairs.values)]
+        end
+
+        def map_key(type, scope)
+          members = type.is_a?(Rigor::Type::Union) ? type.members : [type]
+          Rigor::Type::Combinator.union(*members.map { |member| map_member(member, scope) })
+        end
+
+        def map_member(member, scope)
+          case member
+          when Rigor::Type::Constant
+            member.value.is_a?(String) || member.value.is_a?(Symbol) ? symbol : Rigor::Type::Combinator.untyped
+          when Rigor::Type::Nominal
+            symbolized_class?(member.class_name, scope) ? symbol : Rigor::Type::Combinator.untyped
+          else Rigor::Type::Combinator.untyped
+          end
+        end
+
+        def symbol
+          Rigor::Type::Combinator.nominal_of("Symbol")
+        end
+
+        # String, Symbol and their subclasses go through `to_sym`.
+        def symbolized_class?(name, scope)
+          SYMBOLIZED_CLASSES.include?(name) ||
+            SYMBOLIZED_CLASSES.any? { |base| %i[equal subclass].include?(ordering(name, base, scope)) }
+        end
+
+        def ordering(name, base, scope)
+          Rigor::Reflection.class_ordering(name, base, scope: scope)
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext.rb

@@ -3,6 +3,7 @@
 require "rigor/plugin"
 
 require_relative "activesupport_core_ext/effects"
+require_relative "activesupport_core_ext/symbolize_keys"
 
 module Rigor
   module Plugin
@@ -43,12 +44,15 @@ module Rigor
       manifest(
         id: "activesupport-core-ext",
         target_gems: ["activesupport"],
+        # Bumped 2026-10-27 (#2433) — `Hash#symbolize_keys` / `#to_options` map each key member through a
+        # `dynamic_return` hook instead of claiming `Hash[Symbol, V]`.
+        #
         # Bumped 2026-09-10 (#534 item 7) — `ActiveSupport::Concern` is declared, so `extend
         # ActiveSupport::Concern` resolves instead of reading as an unresolved constant.
         #
         # Bumped 2026-09-02 (#632) — `ActiveSupport::Duration`'s reader surface (`ago`/`to_i`/`iso8601`/…)
         # is now declared, open_receivers-protected; see the class comment above.
-        version: "0.5.0",
+        version: "0.6.0",
         description: "RBS bundle for the most-frequently-flagged ActiveSupport core_ext extensions, " \
                      "plus the `ActiveSupport::Duration` type of the numeric time multipliers and its " \
                      "reader surface.",
@@ -190,11 +194,9 @@ module Rigor
         argument = duration_arithmetic_argument(call_node)
         next nil if argument.nil?
 
-        # The ARGUMENT is checked before the receiver: it is the cheaper of the two on the overwhelmingly
-        # common shapes (`i + 1`, `n * 2`), and a call with no Duration operand must cost as little as
-        # possible — this rule is consulted on every `+` / `-` / `*` in the project. The early exit is
-        # what makes the ordering worth anything: an argument that is no Duration operand at all
-        # (`"a" + b`, `list + other`) declines here and never types its receiver on this rule's behalf.
+        # The ARGUMENT is checked before the receiver: it is the cheaper test on the common shapes (`i + 1`,
+        # `n * 2`), and this rule is consulted on every `+` / `-` / `*`. An argument that is no Duration
+        # operand (`"a" + b`, `list + other`) declines here and never types its receiver on this rule's behalf.
         argument_kind = duration_operand_kind(scope&.type_of(argument))
         next nil if argument_kind.nil?
 
@@ -204,6 +206,17 @@ module Rigor
         duration_arithmetic_result(call_node.name, receiver_kind, argument_kind)
       end
 
+      # #2433 — `symbolize_keys` / `to_options` keep a key without `to_sym`, so the key type is mapped per
+      # member; see {SymbolizeKeys}. The RBS rows answer `Hash[untyped, V]` wherever this declines.
+      dynamic_return methods: %i[symbolize_keys to_options] do |call_node, scope|
+        next nil unless call_node.is_a?(Prism::CallNode)
+        next nil unless call_node.receiver
+        next nil unless call_node.arguments.nil?
+
+        # A block is ignored by `symbolize_keys`, so it does not decline.
+        SymbolizeKeys.result(scope&.type_of(call_node.receiver), scope)
+      end
+
       # ADR-88 WD1 — both tables are static and the RBS bundle ships with the gem; nothing here reads a
       # project file, so a project enabling this plugin stays incremental-capable.
       def incremental_state_fingerprint

data/plugins/rigor-activesupport-core-ext/sig/active_support/core_ext.rbs

@@ -1565,28 +1565,35 @@ class Hash[unchecked out K, unchecked out V]
   # non-bang half is `%a{pure}`. `assert_valid_keys` raises rather than
   # mutating (raising is not an effect label).
   %a{pure}
-  def symbolize_keys: () -> Hash[Symbol, V]
+  # `key.to_sym rescue key` keeps a key without `to_sym`, so no one key type is right: `Hash[untyped, V]` here,
+  # and the plugin's `dynamic_return` hook (#2433) maps each key member where it can.
+  def symbolize_keys: () -> Hash[untyped, V]
+  # `symbolize_keys!` keeps `-> self`: `key.to_sym rescue key` leaves a key without `to_sym` as it is, so
+  # `Hash[Symbol, V]` is wrong for an Integer-keyed receiver (#2424 review). The other bang forms below
+  # answer the re-keyed or re-valued hash.
   def symbolize_keys!: () -> self
   %a{pure}
   def deep_symbolize_keys: () -> Hash[untyped, untyped]
-  def deep_symbolize_keys!: () -> self
+  def deep_symbolize_keys!: () -> Hash[untyped, untyped]
   %a{pure}
   def stringify_keys: () -> Hash[String, V]
-  def stringify_keys!: () -> self
+  def stringify_keys!: () -> Hash[String, V]
   %a{pure}
   def deep_stringify_keys: () -> Hash[untyped, untyped]
-  def deep_stringify_keys!: () -> self
+  def deep_stringify_keys!: () -> Hash[untyped, untyped]
   %a{pure}
   def assert_valid_keys: (*K | Array[K]) -> self
+  # The block's result is the new key at every level, so the keys are its type, not `K`: `{ a: 1 }
+  # .deep_transform_keys(&:to_s)` has String keys. Nested values are re-keyed too, so they read `untyped`.
   %a{pure}
-  def deep_transform_keys: () { (K) -> K } -> Hash[K, untyped]
-  def deep_transform_keys!: () { (K) -> K } -> self
+  def deep_transform_keys: [X] () { (K) -> X } -> Hash[X, untyped]
+  def deep_transform_keys!: [X] () { (K) -> X } -> Hash[X, untyped]
   %a{pure}
   def deep_transform_values: () { (V) -> untyped } -> Hash[K, untyped]
-  def deep_transform_values!: () { (V) -> untyped } -> self
+  def deep_transform_values!: () { (V) -> untyped } -> Hash[K, untyped]
   # `alias_method`s of `symbolize_keys` / `symbolize_keys!`.
   %a{pure}
-  def to_options: () -> Hash[Symbol, V]
+  def to_options: () -> Hash[untyped, V]
   def to_options!: () -> self
 
   # `core_ext/hash/deep_dup` — allocates a deep copy, never touches the
@@ -1600,11 +1607,17 @@ class Hash[unchecked out K, unchecked out V]
   # `core_ext/hash/deep_merge` — the block receives `(key, this_val,
   # other_val)` and returns the merged value; neither `deep_merge` nor its
   # block mutates either hash (containment covers the block itself).
-  %a{pure}
-  def deep_merge: (Hash[K, V]) -> Hash[K, V]
-                | (Hash[K, V]) { (K, V, V) -> V } -> Hash[K, V]
-  def deep_merge!: (Hash[K, V]) -> self
-                 | (Hash[K, V]) { (K, V, V) -> V } -> self
+  # The result carries the argument's keys and values as well as the
+  # receiver's, and a key both hold a Hash under merges into a third Hash
+  # that is neither side's value type (`{ n: { x: 1 } }.deep_merge(n: { y:
+  # "s" })[:n]` is `{ x: 1, y: "s" }`), so the values read `untyped`.
+  # `(Hash[K, V]) -> Hash[K, V]` typed `h.deep_merge(b: "x")[:b]` as the
+  # receiver's value type (#2424 review). The bang form answers the receiver.
+  %a{pure}
+  def deep_merge: [A, B] (Hash[A, B] other_hash) -> Hash[K | A, untyped]
+                | [A, B] (Hash[A, B] other_hash) { (K | A, untyped, untyped) -> untyped } -> Hash[K | A, untyped]
+  def deep_merge!: [A, B] (Hash[A, B] other_hash) -> Hash[K | A, untyped]
+                 | [A, B] (Hash[A, B] other_hash) { (K | A, untyped, untyped) -> untyped } -> Hash[K | A, untyped]
   # `other.is_a?(Hash)` — the hook `ActiveSupport::DeepMergeable` asks before
   # recursing into a value. `:nodoc:`, but public.
   %a{pure}

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_index.rb

@@ -37,9 +37,9 @@ module Rigor
           @classes.empty?
         end
 
-        # The classes alba infers for the associations that name no resource, limited to
-        #   those that exist in the project. The block receives each association name and returns alba's
-        #   `classify` of it (the caller owns the inflector; ADR-39).
+        # The classes alba infers for the associations that name no resource, limited to those that exist in
+        # the project. The block receives each association name and returns alba's `classify` of it (the
+        # caller owns the inflector; ADR-39).
         def inferred_roots(&classify)
           roots = @associations.filter_map do |association|
             next unless resource?(association.owner)

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

@@ -33,9 +33,11 @@ module Rigor
     # - `:authenticatable` — always-included base module
     #
     # The substrate's pre-pass scanner consults each module's RBS via `Environment::RbsLoader#instance_definition`
-    # to enumerate method names. A user project providing real Devise via Bundler will see methods like
-    # `valid_password?`, `send_reset_password_instructions`, etc. resolve through the synthetic-method
-    # tier without `call.undefined-method`.
+    # to enumerate method names, so it names only what the project's RBS declares. The `devise` gem ships no
+    # RBS and Rigor bundles none for `Devise::Models::*`: a project supplies those signatures (`signature_paths:`
+    # or an `rbs collection`), and only then do `valid_password?`, `send_reset_password_instructions`, etc.
+    # resolve through the synthetic-method tier. A name the model defines itself, or a project module it
+    # includes or prepends defines, is left to the project's definition.
     #
     # ## Precision tier
     #

data/plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema/schema_scanner.rb

@@ -212,9 +212,7 @@ module Rigor
         # ... end` row's own recursive call (see {#each_block_type_info}). It caps the recursion at ONE
         # level deep: with `nested: true`, {#walk_predicate_chain} declines a FURTHER `each do ... end`
         # rather than recursing again (issue #137 deliberately does not model doubly-nested arrays of
-        # arrays). This also keeps `collect_schema_shape` from calling itself — {#each_block_type_info}
-        # is the only caller that ever passes `nested: true}` — so the call graph has no cycle for the
-        # engine's return-type inference to approximate through.
+        # arrays). The recursion through {#each_block_type_info} is therefore bounded and terminates.
         def collect_schema_shape(block_node, type_aliases, nested:)
           required = {}
           optional = {}

data/plugins/rigor-dry-struct/lib/rigor/plugin/dry_struct.rb

@@ -34,9 +34,9 @@ module Rigor
     #
     # The synthetic reader's return type is resolved via ADR-18's `returns_from_arg:` fact lookup: the
     # call-site's second argument (`Types::String` etc.) is looked up through the `:dry_type_aliases`
-    # fact published by `rigor-dry-types`, yielding `Nominal[String]` for common cases. When the lookup
-    # misses (e.g. inline method-chain argument whose chain-head isn't currently extracted), the row
-    # falls back to `Dynamic[Top]` silently.
+    # fact published by `rigor-dry-types`, yielding the aliased class (`String`) for common cases. When the
+    # lookup misses (e.g. inline method-chain argument whose chain-head isn't currently extracted), the row
+    # falls back to the untyped floor silently.
     #
     # ## Scope (slice 2c minimum)
     #
@@ -58,8 +58,8 @@ module Rigor
                      "by consuming `rigor-dry-types`'s `:dry_type_aliases` fact.",
         # ADR-9 consumption — the precision-promotion path below uses `:dry_type_aliases` published by
         # `rigor-dry-types`. The fact is optional: when the `rigor-dry-types` plugin isn't loaded, the
-        # `returns_from_arg:` lookup misses and the synthetic readers fall back to `Dynamic[Top]` (the
-        # pre-ADR-18 floor).
+        # `returns_from_arg:` lookup misses and the synthetic readers fall back to the untyped floor (the
+        # pre-ADR-18 behaviour).
         consumes: [{ plugin_id: "dry-types", name: :dry_type_aliases, optional: true }],
         heredoc_templates: [
           Rigor::Plugin::Macro::HeredocTemplate.new(
@@ -69,7 +69,7 @@ module Rigor
             # ADR-18 — the synthetic reader's return type comes from the call site's second argument
             # (`Types::String` etc.), resolved through the `:dry_type_aliases` fact. When the lookup
             # misses (e.g. inline `attribute :tag, Types::String.constrained(...)`, whose receiver chain
-            # head isn't currently extracted), the row falls back to Dynamic[Top].
+            # head isn't currently extracted), the row falls back to the untyped floor.
             emit: [{
               name: "\#{name}",
               returns_from_arg: {