rigortype 0.2.7 → 0.2.8

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

@@ -5,17 +5,13 @@ require "prism"
 module Rigor
   module Plugin
     class Activestorage < Rigor::Plugin::Base
-      # Per-file walker. Emits one `:info` `attachment-call`
-      # diagnostic per recognised attachment access on a
-      # known AR class. The diagnostic surfaces what the
-      # plugin recognised so users can verify the model →
-      # attachment mapping the plugin sees.
+      # Per-file walker. Emits one `:info` `attachment-call` diagnostic per recognised attachment access
+      # on a known AR class. The diagnostic surfaces what the plugin recognised so users can verify the
+      # model → attachment mapping the plugin sees.
       #
-      # No `:error` diagnostics here — the `dynamic_return`
-      # return-type narrowing carries the type-checking value.
-      # An `unknown-attachment` rule (similar to
-      # `rigor-activerecord`'s `unknown-column`) is deferred:
-      # it requires a coupled receiver-class narrowing pass.
+      # No `:error` diagnostics here — the `dynamic_return` return-type narrowing carries the
+      # type-checking value. An `unknown-attachment` rule (similar to `rigor-activerecord`'s
+      # `unknown-column`) is deferred: it requires a coupled receiver-class narrowing pass.
       class Analyzer
         attr_reader :diagnostics
 
@@ -47,10 +43,8 @@ module Rigor
                         @attachment_index.attachments_for("::#{owner}")
           return if attachments.nil?
 
-          # Only flag when the method matches a known
-          # attachment name (the `dynamic_return` rule
-          # provides the narrowing; the diagnostic just
-          # confirms the recognition).
+          # Only flag when the method matches a known attachment name (the `dynamic_return` rule provides
+          # the narrowing; the diagnostic just confirms the recognition).
           attachment = attachments.find { |a| a[:name] == node.name.to_s }
           return if attachment.nil?
 

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

@@ -6,10 +6,8 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class Activestorage < Rigor::Plugin::Base
-      # Walks the configured model search paths via the plugin's
-      # `IoBoundary`, parses each `.rb` file with Prism, and
-      # collects `has_one_attached` / `has_many_attached`
-      # declarations.
+      # Walks the configured model search paths via the plugin's `IoBoundary`, parses each `.rb` file
+      # with Prism, and collects `has_one_attached` / `has_many_attached` declarations.
       #
       # Returns rows the {AttachmentIndex} consumes:
       #
@@ -19,17 +17,13 @@ module Rigor
       #
       # Limitations (intentional for v0.1.0 of the plugin):
       #
-      # - The walker matches any class declaration that
-      #   contains a `has_*_attached` call. Whether the class
-      #   IS an ActiveRecord model is not verified here —
-      #   `rigor-activerecord` provides that check via its
-      #   own model index. The analyser is intentionally
-      #   lenient so the plugin runs standalone in projects
-      #   that haven't loaded `rigor-activerecord` yet.
-      # - Only Symbol-literal attachment names are recognised.
-      #   `has_one_attached(args)` or computed names decline.
-      # - Modules (`class Admin::User`) are recognised; the
-      #   resulting class name is the lexical path
+      # - The walker matches any class declaration that contains a `has_*_attached` call. Whether the
+      #   class IS an ActiveRecord model is not verified here — `rigor-activerecord` provides that check
+      #   via its own model index. The analyser is intentionally lenient so the plugin runs standalone in
+      #   projects that haven't loaded `rigor-activerecord` yet.
+      # - Only Symbol-literal attachment names are recognised. `has_one_attached(args)` or computed names
+      #   decline.
+      # - Modules (`class Admin::User`) are recognised; the resulting class name is the lexical path
       #   (`Admin::User`).
       class AttachmentDiscoverer
         ATTACHMENT_METHODS = {

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

@@ -3,16 +3,13 @@
 module Rigor
   module Plugin
     class Activestorage < Rigor::Plugin::Base
-      # Maps a discovered class name to the list of attachment
-      # rows declared on it. Marshal-clean so the cache producer
-      # round-trips it through the standard pair.
+      # Maps a discovered class name to the list of attachment rows declared on it. Marshal-clean so the
+      # cache producer round-trips it through the standard pair.
       #
       # Each row is `{ name:, kind: }`:
       #
-      # - `name` — String, the attachment method name as the
-      #            user invokes it (`"avatar"`).
-      # - `kind` — `:singular` (`has_one_attached`) or
-      #            `:collection` (`has_many_attached`).
+      # - `name` — String, 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

@@ -8,26 +8,18 @@ require_relative "activestorage/analyzer"
 
 module Rigor
   module Plugin
-    # rigor-activestorage — recognises `has_one_attached` /
-    # `has_many_attached` macros on ActiveRecord models and
-    # contributes attachment accessor return types so chained
-    # calls (`user.avatar.attached?`) route through Rigor's
-    # normal dispatch.
+    # rigor-activestorage — recognises `has_one_attached` / `has_many_attached` macros on ActiveRecord
+    # models and contributes attachment accessor return types so chained calls (`user.avatar.attached?`)
+    # route through Rigor's normal dispatch.
     #
     # ## Architecture
     #
-    # One discovery pass per run reads the configured AR model
-    # paths (default `app/models/`) via the plugin's
-    # `IoBoundary`, walks each `.rb` file with Prism, and
-    # collects `has_one_attached :avatar` /
-    # `has_many_attached :photos` macros into an
-    # {AttachmentIndex} keyed by class name. The walker is
-    # stand-alone (mirrors `rigor-activerecord`'s
-    # `ModelDiscoverer`) so the plugin works even when
-    # `rigor-activerecord` is not loaded; when it IS loaded,
-    # the published `:model_index` fact (ADR-9 cross-plugin
-    # API) drives the same class set so the two plugins agree
-    # on what counts as a model.
+    # One discovery pass per run reads the configured AR model paths (default `app/models/`) via the
+    # plugin's `IoBoundary`, walks each `.rb` file with Prism, and collects `has_one_attached :avatar` /
+    # `has_many_attached :photos` macros into an {AttachmentIndex} keyed by class name. The walker is
+    # stand-alone (mirrors `rigor-activerecord`'s `ModelDiscoverer`) so the plugin works even when
+    # `rigor-activerecord` is not loaded; when it IS loaded, the published `:model_index` fact (ADR-9
+    # cross-plugin API) drives the same class set so the two plugins agree on what counts as a model.
     #
     # ## Configuration
     #
@@ -39,9 +31,8 @@ module Rigor
     #
     # `model_search_paths` defaults to `["app/models"]`.
     #
-    # The class name `Rigor::Plugin::Activestorage` (single
-    # capital A) matches the constant-distinguishing convention
-    # used by `rigor-activerecord`.
+    # The class name `Rigor::Plugin::Activestorage` (single capital A) matches the constant-distinguishing
+    # convention used by `rigor-activerecord`.
     class Activestorage < Rigor::Plugin::Base
       manifest(
         id: "activestorage",
@@ -53,11 +44,9 @@ module Rigor
         consumes: [{ plugin_id: "activerecord", name: :model_index, optional: true }]
       )
 
-      # Cached: attachment index. Walks every `.rb` file under
-      # `model_search_paths` for `has_*_attached` macros. `watch:`
-      # (ADR-60 WD3) covers model-file additions; the discoverer's
-      # in-block reads are captured into the record-and-validate
-      # dependency descriptor after the block runs.
+      # Cached: attachment index. Walks every `.rb` file under `model_search_paths` for `has_*_attached`
+      # macros. `watch:` (ADR-60 WD3) covers model-file additions; the discoverer's in-block reads are
+      # captured into the record-and-validate dependency descriptor after the block runs.
       producer :attachment_index, watch: -> { [[@model_search_paths, "**/*.rb"]] } do |_params|
         rows = AttachmentDiscoverer.new(
           io_boundary: io_boundary,
@@ -80,18 +69,12 @@ module Rigor
         Analyzer.new(path: path, attachment_index: index).analyze(root).diagnostics
       end
 
-      # Return-type contribution: when the receiver is
-      # `Nominal[Model]` and the method matches a discovered
-      # attachment, narrows to
-      # `Nominal[ActiveStorage::Attached::One]` (singular) or
-      # `Nominal[ActiveStorage::Attached::Many]` (collection)
-      # via a `dynamic_return` rule keyed on the live set of
-      # model class names from the attachment index.
-      # The chained call (`.attached?`, `.purge`, `.url`)
-      # then resolves through ActiveStorage's RBS surface.
-      # Attachment setters (`user.avatar=`) decline — they
-      # take side-effecting argument types that the RBS
-      # surface already covers.
+      # Return-type contribution: when the receiver is `Nominal[Model]` and the method matches a
+      # discovered attachment, narrows to `Nominal[ActiveStorage::Attached::One]` (singular) or
+      # `Nominal[ActiveStorage::Attached::Many]` (collection) via a `dynamic_return` rule keyed on the
+      # live set of model class names from the attachment index. The chained call (`.attached?`, `.purge`,
+      # `.url`) then resolves through ActiveStorage's RBS surface. Attachment setters (`user.avatar=`)
+      # decline — they take side-effecting argument types that the RBS surface already covers.
       dynamic_return receivers: -> { attachment_index&.class_names || [] } do |call_node, scope|
         next nil unless call_node.is_a?(Prism::CallNode)
         next nil if call_node.receiver.nil?
@@ -129,10 +112,9 @@ module Rigor
       def attachment_index
         return @attachment_index if @attachment_index
 
-        # ADR-60 WD3 record-and-validate: the producer's in-block
-        # `AttachmentDiscoverer` reads are captured into the
-        # dependency descriptor after the block runs, and the
-        # producer's `watch:` covers model-file additions.
+        # ADR-60 WD3 record-and-validate: the producer's in-block `AttachmentDiscoverer` reads are
+        # captured into the dependency descriptor after the block runs, and the producer's `watch:`
+        # covers model-file additions.
         @attachment_index = cache_for(:attachment_index, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_errors << "rigor-activestorage: #{e.message}"

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# 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.
+# 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"

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

@@ -4,14 +4,11 @@ require "rigor/plugin"
 
 module Rigor
   module Plugin
-    # ADR-25 — a pure RBS-bundle plugin. It ships NO analyzer code:
-    # no `diagnostics_for_file`, no `dynamic_return`. Its
-    # whole contribution is the manifest's `signature_paths: ["sig"]`,
-    # which declares the bundled ActiveSupport `core_ext` RBS
-    # directory. `Plugin::Loader` resolves that directory against
-    # this gem's root and `Environment.for_project` merges it into
-    # the RBS environment, so the ActiveSupport core-extension
-    # selectors (`3.days`, `"x".squish`, `Time.current`, …) resolve.
+    # ADR-25 — a pure RBS-bundle plugin. It ships NO analyzer code: no `diagnostics_for_file`, no
+    # `dynamic_return`. Its whole contribution is the manifest's `signature_paths: ["sig"]`, which
+    # declares the bundled ActiveSupport `core_ext` RBS directory. `Plugin::Loader` resolves that
+    # directory against this gem's root and `Environment.for_project` merges it into the RBS environment,
+    # so the ActiveSupport core-extension selectors (`3.days`, `"x".squish`, `Time.current`, …) resolve.
     #
     # Activate it like any plugin — no path, no vendoring:
     #
@@ -23,8 +20,7 @@ module Rigor
     class ActivesupportCoreExt < Rigor::Plugin::Base
       manifest(
         id: "activesupport-core-ext",
-        # Bumped 2026-05-28 — added Date#midnight /
-        # at_midnight / beginning_of_day / end_of_day (Rails
+        # Bumped 2026-05-28 — added Date#midnight / at_midnight / beginning_of_day / end_of_day (Rails
         # aliases that return Time, not Date).
         version: "0.2.0",
         description: "RBS bundle for the most-frequently-flagged ActiveSupport core_ext extensions.",

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

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
 
-# rigor-activesupport-core-ext — a community-maintained RBS bundle
-# for the most-frequently-flagged ActiveSupport core extensions.
+# rigor-activesupport-core-ext — a community-maintained RBS bundle for the most-frequently-flagged
+# ActiveSupport core extensions.
 #
-# Per ADR-25 this gem is a pure RBS-bundle *plugin*: it ships a
-# `sig/` directory and a trivial `Rigor::Plugin::Base` subclass
-# whose manifest declares `signature_paths: ["sig"]`. Activate it
-# by listing the gem under `.rigor.yml`'s `plugins:` — Rigor
-# resolves and loads the bundled `sig/` automatically, with no
-# hand-written path:
+# Per ADR-25 this gem is a pure RBS-bundle *plugin*: it ships a `sig/` directory and a trivial
+# `Rigor::Plugin::Base` subclass whose manifest declares `signature_paths: ["sig"]`. Activate it by
+# listing the gem under `.rigor.yml`'s `plugins:` — Rigor resolves and loads the bundled `sig/`
+# automatically, with no hand-written path:
 #
 #     # .rigor.yml
 #     plugins:
 #       - rigor-activesupport-core-ext
 #
-# Coverage scope and rationale: see `README.md` in this directory
-# and `docs/notes/20260515-real-world-rails-survey.md` for the
-# survey that established the selector ranking.
+# Coverage scope and rationale: see `README.md` in this directory and
+# `docs/notes/20260515-real-world-rails-survey.md` for the survey that established the selector ranking.
 require_relative "rigor/plugin/activesupport_core_ext"

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

@@ -4,26 +4,21 @@ require "rigor/plugin"
 
 module Rigor
   module Plugin
-    # ADR-16 Tier B worked plugin: recognises Devise's model-side
-    # `devise :strategy_a, :strategy_b` DSL on `ActiveRecord::Base`
-    # subclasses and explodes each strategy's module RBS into the
-    # calling class.
+    # ADR-16 Tier B worked plugin: recognises Devise's model-side `devise :strategy_a, :strategy_b` DSL on
+    # `ActiveRecord::Base` subclasses and explodes each strategy's module RBS into the calling class.
     #
-    # Per the per-library survey (§ Devise), Devise's `devise(*modules)`
-    # at `lib/devise/models.rb:79-112` is a **table-driven include
-    # sequence**: each Symbol argument resolves through
-    # `Devise::Models.const_get(m.to_s.classify)` to a concrete
-    # `Devise::Models::*` module, which is then mixed into the
-    # calling class. The substrate replays the same shape
-    # statically — the manifest's `modules_by_symbol:` mirrors
-    # Devise's `lib/devise/modules.rb` and the pre-pass scanner
-    # synthesises one SyntheticMethod per (calling class, included
-    # module instance method) pair into the SyntheticMethodIndex.
+    # Per the per-library survey (§ Devise), Devise's `devise(*modules)` at `lib/devise/models.rb:79-112`
+    # is a **table-driven include sequence**: each Symbol argument resolves through
+    # `Devise::Models.const_get(m.to_s.classify)` to a concrete `Devise::Models::*` module, which is then
+    # mixed into the calling class. The substrate replays the same shape statically — the manifest's
+    # `modules_by_symbol:` mirrors Devise's `lib/devise/modules.rb` and the pre-pass scanner synthesises
+    # one SyntheticMethod per (calling class, included module instance method) pair into the
+    # SyntheticMethodIndex.
     #
     # ## Reach
     #
-    # The full set of strategies Devise registers via
-    # `Devise.add_module` at gem load (per `lib/devise/modules.rb`):
+    # The full set of strategies Devise registers via `Devise.add_module` at gem load (per
+    # `lib/devise/modules.rb`):
     #
     # - `:database_authenticatable` — password + email auth core
     # - `:recoverable` — password-reset flow
@@ -37,41 +32,31 @@ module Rigor
     # - `:omniauthable` — OmniAuth providers
     # - `: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`.
+    # 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`.
     #
     # ## Precision tier
     #
-    # The scanner records `origin_module:` in each synthetic
-    # method's provenance. The dispatcher's slice-6a TierB path
-    # (`promote_via_origin_module`) redispatches on
-    # `Nominal[origin_module]` via `RbsDispatch`, so Devise's
-    # authored RBS return types win: `valid_password?` returns
-    # `bool`, not `Dynamic[T]`. Unknown return types degrade
-    # gracefully to `Dynamic[T]`.
+    # The scanner records `origin_module:` in each synthetic method's provenance. The dispatcher's
+    # slice-6a TierB path (`promote_via_origin_module`) redispatches on `Nominal[origin_module]` via
+    # `RbsDispatch`, so Devise's authored RBS return types win: `valid_password?` returns `bool`, not
+    # `Dynamic[T]`. Unknown return types degrade gracefully to `Dynamic[T]`.
     #
     # ## Scope
     #
-    # - Recognises model-side `devise :a, :b` on any AR::Base
-    #   subclass; trait symbol set mirrors `lib/devise/modules.rb`.
-    # - `Devise::Models::Authenticatable` is always_included
-    #   (matches Devise's `with_options model: true`).
-    # - Unknown trait symbols silently skipped (per slice-3
-    #   design judgment (2)). User initializers that call
-    #   `Devise.add_module :my_strategy, ...` are NOT seen — that
-    #   path requires a separate scanner for `config/initializers/`
-    #   and is deferred.
-    # - Controller-side helpers (`current_user`, `authenticate_user!`,
-    #   etc.) are Tier C work, NOT Tier B; deferred to a future
-    #   slice that consumes ADR-9 fact-store entries from a
-    #   `rigor-rails-routes`-style walker.
-    # - Per-strategy `ClassMethods` extend (Devise's `extend
-    #   Mod::ClassMethods` pattern) is NOT yet wired — slice 3
-    #   covers instance methods only per WD13 floor.
+    # - Recognises model-side `devise :a, :b` on any AR::Base subclass; trait symbol set mirrors
+    #   `lib/devise/modules.rb`.
+    # - `Devise::Models::Authenticatable` is always_included (matches Devise's `with_options model: true`).
+    # - Unknown trait symbols silently skipped (per slice-3 design judgment (2)). User initializers that
+    #   call `Devise.add_module :my_strategy, ...` are NOT seen — that path requires a separate scanner
+    #   for `config/initializers/` and is deferred.
+    # - Controller-side helpers (`current_user`, `authenticate_user!`, etc.) are Tier C work, NOT Tier B;
+    #   deferred to a future slice that consumes ADR-9 fact-store entries from a `rigor-rails-routes`-style
+    #   walker.
+    # - Per-strategy `ClassMethods` extend (Devise's `extend Mod::ClassMethods` pattern) is NOT yet wired
+    #   — slice 3 covers instance methods only per WD13 floor.
     class Devise < Rigor::Plugin::Base
       manifest(
         id: "devise",

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# Gem entry point. Required by Rigor's plugin loader when
-# `.rigor.yml` lists `rigor-devise` under `plugins:`. The loader
-# expects this `require` to side-effect a call to
-# `Rigor::Plugin.register`, which the body of
-# `lib/rigor/plugin/devise.rb` performs at load time.
+# Gem entry point. Required by Rigor's plugin loader when `.rigor.yml` lists `rigor-devise` under
+# `plugins:`. The loader expects this `require` to side-effect a call to `Rigor::Plugin.register`,
+# which the body of `lib/rigor/plugin/devise.rb` performs at load time.
 require_relative "rigor/plugin/devise"

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

@@ -6,16 +6,13 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class DrySchema < Rigor::Plugin::Base
-      # Walks project source for `Foo = Dry::Schema.{Params,JSON,define}
-      # { ... }` shapes and emits a
-      # `{schema_const_fqn => {required: {key => underlying_class}, optional: {…}}}`
-      # table covering each schema's typed-key surface.
+      # Walks project source for `Foo = Dry::Schema.{Params,JSON,define} { ... }` shapes and emits a
+      # `{schema_const_fqn => {required: {key => underlying_class}, optional: {…}}}` table covering each
+      # schema's typed-key surface.
       module SchemaScanner
-        # The dry-schema canonical-type symbols accepted as
-        # predicate arguments. Maps each to the underlying Ruby
-        # class name (the same vocabulary `rigor-dry-types`
-        # uses for `CANONICAL_ALIASES`, intersected with what
-        # dry-schema's predicate engine accepts).
+        # The dry-schema canonical-type symbols accepted as predicate arguments. Maps each to the
+        # underlying Ruby class name (the same vocabulary `rigor-dry-types` uses for `CANONICAL_ALIASES`,
+        # intersected with what dry-schema's predicate engine accepts).
         CANONICAL_TYPES = {
           string: "String",
           integer: "Integer",
@@ -30,12 +27,10 @@ module Rigor
           array: "Array"
         }.tap { |h| h[:nil] = "NilClass" }.freeze
 
-        # The dry-schema predicate verbs that accept a type
-        # argument. Each verb has a slightly different runtime
-        # semantic (`filled` = present + non-empty; `value` =
-        # present; `maybe` = present-or-nil; `each` = collection
-        # element type) but for Rigor's purposes they all
-        # contribute the same underlying class for the key.
+        # The dry-schema predicate verbs that accept a type argument. Each verb has a slightly different
+        # runtime semantic (`filled` = present + non-empty; `value` = present; `maybe` = present-or-nil;
+        # `each` = collection element type) but for Rigor's purposes they all contribute the same
+        # underlying class for the key.
         TYPE_BEARING_PREDICATES = %i[filled value maybe each].to_set.freeze
         private_constant :TYPE_BEARING_PREDICATES
 
@@ -45,17 +40,12 @@ module Rigor
 
         module_function
 
-        # @param paths [Array<String>] absolute paths to `.rb`
-        #   files the project's `paths:` resolves to.
-        # @param type_aliases [Hash{String => String}] the
-        #   ADR-9 `:dry_type_aliases` fact published by
-        #   `rigor-dry-types` when loaded. Used to resolve
-        #   `value(Types::Email)` references to their
-        #   underlying class. Empty when the plugin isn't
-        #   loaded.
-        # @return [Hash{String => Hash{Symbol => Hash{Symbol => String}}}]
-        #   frozen per-schema typed-key table. Empty when no
-        #   recognisable schema declaration is found.
+        # @param paths [Array<String>] absolute paths to `.rb` files the project's `paths:` resolves to.
+        # @param type_aliases [Hash{String => String}] the ADR-9 `:dry_type_aliases` fact published by
+        #   `rigor-dry-types` when loaded. Used to resolve `value(Types::Email)` references to their
+        #   underlying class. Empty when the plugin isn't loaded.
+        # @return [Hash{String => Hash{Symbol => Hash{Symbol => String}}}] frozen per-schema typed-key
+        #   table. Empty when no recognisable schema declaration is found.
         def scan(paths:, type_aliases: {})
           table = {}
           paths.each do |path|
@@ -77,11 +67,9 @@ module Rigor
         end
         private_class_method :scan_file
 
-        # Walks the AST collecting `<Const> = Dry::Schema.X { ... }`
-        # assignments at any nesting level. Tracks the enclosing
-        # constant chain so a class-level `class Foo; SCHEMA =
-        # Dry::Schema.Params { ... }; end` registers as
-        # `"Foo::SCHEMA"`.
+        # Walks the AST collecting `<Const> = Dry::Schema.X { ... }` assignments at any nesting level.
+        # Tracks the enclosing constant chain so a class-level `class Foo; SCHEMA = Dry::Schema.Params
+        # { ... }; end` registers as `"Foo::SCHEMA"`.
         def collect_schemas(node, qualified_prefix, type_aliases)
           return {} if node.nil?
 
@@ -119,8 +107,7 @@ module Rigor
         end
         private_class_method :collect_schema_assignment
 
-        # Matches `Dry::Schema.Params { ... }` /
-        # `Dry::Schema.JSON { ... }` / `Dry::Schema.define { ... }`.
+        # Matches `Dry::Schema.Params { ... }` / `Dry::Schema.JSON { ... }` / `Dry::Schema.define { ... }`.
         def schema_entry_call?(node)
           return false unless node.is_a?(Prism::CallNode)
           return false unless SCHEMA_ENTRY_NAMES.include?(node.name)
@@ -147,10 +134,9 @@ module Rigor
         end
         private_class_method :collect_schema_shape
 
-        # Walks every top-level `required(:key).<predicate>(...)` /
-        # `optional(:key).<predicate>(...)` chain in the block
-        # body. The block's body is either a `Prism::StatementsNode`
-        # (multi-statement) or a single expression node.
+        # Walks every top-level `required(:key).<predicate>(...)` / `optional(:key).<predicate>(...)`
+        # chain in the block body. The block's body is either a `Prism::StatementsNode` (multi-statement)
+        # or a single expression node.
         def walk_block_body(block_node, &)
           body = block_node.body
           return if body.nil?
@@ -160,13 +146,10 @@ module Rigor
         end
         private_class_method :walk_block_body
 
-        # `required(:key).filled(:string)` parses as a CallNode
-        # whose receiver is the `required(:key)` call. Walk the
-        # chain inward looking for the type-bearing predicate at
-        # the head; the key sits on the chain's tail. The
-        # `each(<Type>)` predicate yields a list-of-element
-        # type info (`{type: <T>, list: true}`); other type-bearing
-        # predicates (`filled`/`value`/`maybe`) yield scalar info
+        # `required(:key).filled(:string)` parses as a CallNode whose receiver is the `required(:key)`
+        # call. Walk the chain inward looking for the type-bearing predicate at the head; the key sits on
+        # the chain's tail. The `each(<Type>)` predicate yields a list-of-element type info (`{type: <T>,
+        # list: true}`); other type-bearing predicates (`filled`/`value`/`maybe`) yield scalar info
         # (`{type: <T>, list: false}`).
         def visit_chain(node, &block)
           return unless node.is_a?(Prism::CallNode)
@@ -179,11 +162,9 @@ module Rigor
         end
         private_class_method :visit_chain
 
-        # `required(:key).filled(:string).value(...)...` — the
-        # OUTERMOST call's receiver chain ends in the
-        # `required(:key)` / `optional(:key)` call. Recurse on
-        # `node.receiver` until we hit the `required` /
-        # `optional` call, recording the key + kind.
+        # `required(:key).filled(:string).value(...)...` — the OUTERMOST call's receiver chain ends in
+        # the `required(:key)` / `optional(:key)` call. Recurse on `node.receiver` until we hit the
+        # `required` / `optional` call, recording the key + kind.
         def extract_key_and_kind(node)
           current = node
           while current.is_a?(Prism::CallNode)
@@ -199,11 +180,9 @@ module Rigor
         end
         private_class_method :extract_key_and_kind
 
-        # Walks the call chain finding the first type-bearing
-        # predicate (`filled` / `value` / `maybe` / `each`) and
-        # extracts its argument type. Returns a `{type:, list:}`
-        # tuple (`each` is the only verb that produces a list)
-        # or nil when no recognisable type sits on the chain.
+        # Walks the call chain finding the first type-bearing predicate (`filled` / `value` / `maybe` /
+        # `each`) and extracts its argument type. Returns a `{type:, list:}` tuple (`each` is the only
+        # verb that produces a list) or nil when no recognisable type sits on the chain.
         def walk_predicate_chain(node)
           current = node
           while current.is_a?(Prism::CallNode)
@@ -217,12 +196,10 @@ module Rigor
         end
         private_class_method :walk_predicate_chain
 
-        # Reads the first positional argument of a `filled(:string)`
-        # / `value(:integer)` / `maybe(Types::Email)` call. Returns
-        # either the canonical-type-symbol's underlying class
-        # ("String" / "Integer" / …), or the constant's qualified
-        # name for downstream type-alias resolution. Returns nil
-        # for anything else.
+        # Reads the first positional argument of a `filled(:string)` / `value(:integer)` /
+        # `maybe(Types::Email)` call. Returns either the canonical-type-symbol's underlying class
+        # ("String" / "Integer" / …), or the constant's qualified name for downstream type-alias
+        # resolution. Returns nil for anything else.
         def extract_type_from_predicate(call_node)
           arg = call_node.arguments&.arguments&.first
           case arg
@@ -236,12 +213,10 @@ module Rigor
         end
         private_class_method :extract_type_from_predicate
 
-        # In-place: any value's `type:` slot in `bucket` that
-        # doesn't already match a canonical class (e.g.
-        # `"Types::Email"`) gets resolved through the
-        # type_aliases fact. Unresolvable values drop from the
-        # bucket (no fact contribution rather than misleading
-        # data). The `list:` slot rides along unchanged.
+        # In-place: any value's `type:` slot in `bucket` that doesn't already match a canonical class
+        # (e.g. `"Types::Email"`) gets resolved through the type_aliases fact. Unresolvable values drop
+        # from the bucket (no fact contribution rather than misleading data). The `list:` slot rides along
+        # unchanged.
         def remap_aliases!(bucket, type_aliases)
           canonical_set = CANONICAL_TYPES.values.to_set
           bucket.each_pair.to_a.each do |key, info|
@@ -258,9 +233,8 @@ module Rigor
         end
         private_class_method :remap_aliases!
 
-        # Constant-path serialiser: `Dry::Schema` -> "Dry::Schema",
-        # bare `Foo` -> "Foo". Returns nil for shapes Prism
-        # doesn't expose as ConstantRead/PathNode.
+        # Constant-path serialiser: `Dry::Schema` -> "Dry::Schema", bare `Foo` -> "Foo". Returns nil for
+        # shapes Prism doesn't expose as ConstantRead/PathNode.
         def constant_name_for(node)
           return nil if node.nil?