rigortype 0.3.8 → 0.3.9

data/lib/rigor/type_node.rb

@@ -11,6 +11,7 @@ end
 
 require_relative "type_node/identifier"
 require_relative "type_node/integer_literal"
+require_relative "type_node/range_literal"
 require_relative "type_node/symbol_literal"
 require_relative "type_node/string_literal"
 require_relative "type_node/generic"

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.3.8"
+  VERSION = "0.3.9"
 end

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

@@ -34,10 +34,6 @@ module Rigor
         # The broadcast violations for a single call node, or `[]` when the node is not a
         # `broadcast_to` / `ActionCable.server.broadcast` call this plugin recognises. ADR-37: the
         # engine owns the walk.
-        #
-        # @param call_node [Prism::Node]
-        # @param channel_index [ChannelIndex]
-        # @return [Array<Violation>]
         def violations_for(call_node:, channel_index:)
           return [] unless call_node.is_a?(Prism::CallNode)
 

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_discoverer.rb

@@ -43,7 +43,6 @@ module Rigor
           @base_classes = base_classes.to_set { |name| strip_root(name.to_s) }
         end
 
-        # @return [ChannelIndex]
         def discover
           entries = []
           ruby_files_under(@search_paths).each do |path|

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_index.rb

@@ -39,8 +39,6 @@ module Rigor
         # `"::ChatChannel"`; see {ChannelDiscoverer}), while a QUERY may legitimately arrive rooted:
         # `::ChatChannel.broadcast_to(...)` renders its receiver as `"::ChatChannel"`. The root marker is
         # dropped here, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
-        #
-        # @return [Entry, nil]
         def find(class_name)
           @by_name[strip_leading_namespace(class_name.to_s)]
         end

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

@@ -65,6 +65,7 @@ module Rigor
     class Actioncable < Rigor::Plugin::Base
       manifest(
         id: "actioncable",
+        target_gems: ["actioncable"],
         # Bumped 2026-09-02 (#621) — channel keys and base-class names are de-rooted at the producer and a
         # reopened class's actions and streams are UNIONed rather than clobbered, so a cached 0.1.0 index
         # can be missing a whole channel (`< ::ApplicationCable::Channel`) or half its stream names.

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

@@ -42,10 +42,6 @@ module Rigor
 
         # The mailer-call violations for a single call node (0..2), or `[]` when it is not a
         # `<Mailer>.action(...)` call on a known mailer. ADR-37: the engine owns the walk.
-        #
-        # @param call_node [Prism::Node]
-        # @param mailer_index [MailerIndex]
-        # @return [Array<Violation>]
         def violations_for(call_node:, mailer_index:)
           return [] unless call_node.is_a?(Prism::CallNode) && action_call_candidate?(call_node)
 

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb

@@ -38,10 +38,9 @@ module Rigor
         VIEW_FORMATS = %w[html text].freeze
         VIEW_EXTENSIONS = %w[erb haml slim].freeze
 
-        # @param io_boundary [Rigor::Plugin::IoBoundary]
-        # @param search_paths [Array<String>] absolute or project-relative paths to scan for mailers.
-        # @param base_classes [Array<String>] direct superclasses that mark a class as a mailer.
-        # @param views_root [String] absolute or project-relative path to the views directory (typically
+        # @param search_paths — absolute or project-relative paths to scan for mailers.
+        # @param base_classes — direct superclasses that mark a class as a mailer.
+        # @param views_root — absolute or project-relative path to the views directory (typically
         #   `app/views`).
         def initialize(io_boundary:, search_paths:, base_classes:, views_root: DEFAULT_VIEWS_ROOT)
           @io_boundary = io_boundary
@@ -53,7 +52,6 @@ module Rigor
           @views_root = views_root
         end
 
-        # @return [MailerIndex]
         def discover
           # Two-pass: first collect every module's defs (for the include-following step), then build
           # per-class entries that pull in actions from include'd modules. GitLab's `Notify` mailer

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_index.rb

@@ -58,8 +58,6 @@ module Rigor
         # `"::UserMailer"`; see {MailerDiscoverer}), while a QUERY may legitimately arrive rooted:
         # `::UserMailer.welcome(u)` renders its receiver as `"::UserMailer"`. The root marker is dropped
         # here, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
-        #
-        # @return [ClassEntry, nil]
         def find(class_name)
           @by_name[strip_leading_namespace(class_name.to_s)]
         end
@@ -68,9 +66,8 @@ module Rigor
           @by_name.key?(strip_leading_namespace(class_name.to_s))
         end
 
-        # @param file_path [String] absolute path of a mailer file (canonicalised — see plugin entry's
+        # @param file_path — absolute path of a mailer file (canonicalised — see plugin entry's
         #   `harvest`)
-        # @return [ClassEntry, nil]
         def find_by_file(file_path)
           @entries.find { |entry| entry.file_path == file_path }
         end

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

@@ -43,6 +43,7 @@ module Rigor
     class Actionmailer < Rigor::Plugin::Base
       manifest(
         id: "actionmailer",
+        target_gems: ["actionmailer"],
         # Bumped 2026-05-28 — extended RESERVED_CLASS_METHODS to include `respond_to?` / `public_send` /
         # `send` / `__send__` / `method` and friends so dynamic-dispatch idioms
         # (`Mailer.respond_to?(action)` / `Mailer.public_send(action)`) stop firing `unknown-action`

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

@@ -81,10 +81,8 @@ module Rigor
         # duplicates on Mastodon and ~119 on Redmine, exactly stacked with the rails-routes diagnostics.
         # Returns `[]` for unknown / arity-mismatch shapes.
         #
-        # @param call_node [Prism::Node]
-        # @param helper_table [Hash{String => Hash}] each entry carries `name`, `arity`,
+        # @param helper_table — each entry carries `name`, `arity`,
         #   `acceptable_arities`, `path`, `http_method`, `action`.
-        # @return [Array<Violation>]
         def helper_violations_for(call_node:, helper_table:)
           return [] unless implicit_helper_call?(call_node)
 
@@ -108,10 +106,7 @@ module Rigor
         # each filter name reference is validated against it. Calls outside a known controller
         # contribute nothing.
         #
-        # @param call_node [Prism::Node]
-        # @param ancestors [Array<Prism::Node>] the lexical ancestor chain
-        # @param controller_index [ControllerIndex]
-        # @return [Array<Violation>]
+        # @param ancestors — the lexical ancestor chain
         def filter_violations_for(call_node:, ancestors:, controller_index:)
           return [] unless filter_call?(call_node)
 
@@ -144,10 +139,6 @@ module Rigor
         # AR model's column list (looked up via the model_index fact published by `rigor-activerecord`).
         # Calls whose `:require` argument is a non-literal Symbol are passed through; namespaced models
         # (`params.require(:admin_user)` → `Admin::User`) are deferred.
-        #
-        # @param call_node [Prism::Node]
-        # @param model_index [Hash{String => Hash}]
-        # @return [Array<Violation>]
         def permit_violations_for(call_node:, model_index:)
           return [] unless permit_chain?(call_node)
 
@@ -179,13 +170,13 @@ module Rigor
         # method that doesn't call `render`) is also skipped — Phase 3 validates explicit renders only,
         # since the implicit path would false-positive on `redirect_to` / `head` / early returns.
         #
-        # @param call_node [Prism::Node]
-        # @param ancestors [Array<Prism::Node>] the lexical ancestor chain
-        # @param path [String] file being analysed
-        # @param view_search_roots [Array<String>]
-        # @param controller_index [ControllerIndex, nil]
-        # @return [Array<Violation>]
-        def render_violations_for(call_node:, ancestors:, path:, view_search_roots:, controller_index: nil)
+        # @param ancestors — the lexical ancestor chain
+        # @param path — file being analysed
+        # @param io_boundary — the plugin's {Rigor::Plugin::IoBoundary}; #629 — every filesystem
+        #   question this phase asks goes through it, so "no such template" is a recorded dependency and
+        #   the run-result cache invalidates once the template appears
+        def render_violations_for(call_node:, ancestors:, path:, view_search_roots:, io_boundary:,
+                                  controller_index: nil)
           return [] unless render_call?(call_node)
 
           class_name = enclosing_controller_name(ancestors)
@@ -217,12 +208,12 @@ module Rigor
           # `app/views/admin/settings/` holds about/, appearance/, … but no top-level templates). Skip
           # render checks for these — the diagnostic would be a false positive against intentional Rails
           # abstract-base layouts.
-          return [] if abstract_base_controller?(class_name, controller_path, view_search_roots)
+          return [] if abstract_base_controller?(class_name, controller_path, view_search_roots, io_boundary)
 
           target = render_target_for(call_node, controller_path)
           return [] if target.nil?
 
-          violation = render_violation(call_node, target, view_search_roots)
+          violation = render_violation(call_node, target, view_search_roots, io_boundary)
           violation ? [violation] : []
         end
 
@@ -406,15 +397,16 @@ module Rigor
         #       controllers.
         # Deliberately NOT triggered by "no view directory at all" because that fires the diagnostic we
         # DO want for genuinely-missing views (the typo / forgot-to-create case).
-        def abstract_base_controller?(class_name, controller_path, view_search_roots)
+        def abstract_base_controller?(class_name, controller_path, view_search_roots, io_boundary)
           return true if class_name.end_with?("BaseController")
 
           view_search_roots.any? do |root|
             dir = File.join(root, controller_path)
-            next false unless File.directory?(dir)
-
-            entries = Dir.children(dir)
-            entries.any? && entries.all? { |e| File.directory?(File.join(dir, e)) }
+            # #629 — the listing row this records is the same one {#locate_template} needs, and the
+            # boundary deduplicates it per directory, so the whole render phase costs one glob
+            # validation per consulted view directory on a warm run.
+            entries = io_boundary.list_directory(dir)
+            entries.any? && entries.all? { |e| File.directory?(e) }
           end
         end
 
@@ -473,9 +465,9 @@ module Rigor
           Rigor::Plugin::Inflector.underscore(stripped)
         end
 
-        def render_violation(call_node, target, view_search_roots)
+        def render_violation(call_node, target, view_search_roots, io_boundary)
           kind, relative = target
-          existing = locate_template(relative, view_search_roots)
+          existing = locate_template(relative, view_search_roots, io_boundary)
           if existing
             render_target_violation(call_node, kind, relative, existing)
           else
@@ -483,11 +475,22 @@ module Rigor
           end
         end
 
-        def locate_template(relative, view_search_roots)
+        # #629 — resolved from the DIRECTORY LISTING, not from a probe per candidate path. The old shape
+        # asked `File.file?` up to `extensions × roots` times per `render` call and recorded nothing, so a
+        # cached run kept reporting `plugin.actionpack.missing-template` after the template was written.
+        # One {Rigor::Plugin::IoBoundary#list_directory} row per `app/views/<controller>` directory carries
+        # the dependency instead: any file added or removed there invalidates the run, and the warm-run
+        # validation count is the number of view directories the run consulted rather than the number of
+        # candidate paths it tried.
+        def locate_template(relative, view_search_roots, io_boundary)
+          basename = File.basename(relative)
           view_search_roots.each do |root|
+            # Names, not paths: the boundary answers in absolute paths while `root` may be the relative
+            # `app/views` the user configured, and the reported candidate keeps the configured spelling.
+            listing = io_boundary.list_directory(File.join(root, File.dirname(relative)))
+            names = listing.map { |entry| File.basename(entry) }
             RENDER_TEMPLATE_EXTENSIONS.each do |ext|
-              candidate = File.join(root, "#{relative}#{ext}")
-              return candidate if File.file?(candidate)
+              return File.join(root, "#{relative}#{ext}") if names.include?("#{basename}#{ext}")
             end
           end
           nil

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_discoverer.rb

@@ -42,7 +42,6 @@ module Rigor
           @search_paths = search_paths
         end
 
-        # @return [ControllerIndex]
         def discover
           entries = {}
           ruby_files_under(@search_paths).each do |path|

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_index.rb

@@ -42,8 +42,6 @@ module Rigor
         # `"Admin::AccountsController"` — never `"::AccountsController"`; see {ControllerDiscoverer}),
         # while a QUERY may legitimately arrive rooted. The root marker is dropped at every lookup entry
         # point, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
-        #
-        # @return [Entry, nil]
         def find(class_name)
           @entries[strip_leading_namespace(class_name)]
         end
@@ -84,7 +82,7 @@ module Rigor
           methods.uniq.freeze
         end
 
-        # @return [Boolean] true when the class has at least one include OR parent class we couldn't
+        # @return true when the class has at least one include OR parent class we couldn't
         #   resolve in the index (typically a gem-shipped concern such as Devise's
         #   `Devise::Controllers::Helpers`, or a gem-shipped parent controller such as
         #   `Devise::ConfirmationsController` or `Doorkeeper::AuthorizedApplicationsController`). Phase

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

@@ -55,6 +55,7 @@ module Rigor
     class Actionpack < Rigor::Plugin::Base
       manifest(
         id: "actionpack",
+        target_gems: ["actionpack"],
         # ADR-37: the four phases (helper / filter / render / strong-params) run per-call over the
         # engine-owned walk; the enclosing controller is read from the node-rule `NodeContext`
         # ancestors. Nested-module qualification is preserved — `module Admin; class
@@ -68,7 +69,11 @@ module Rigor
         # Bumped 2026-09-02 (#621) — a reopened controller's `def`s are UNIONed rather than clobbered by
         # the later file in the glob, so a cached 1.0.0 index can be missing the filter targets the merge
         # restores.
-        version: "1.1.0",
+        # Bumped 2026-09-10 (#534 item 7) — the plugin gained a bundled `sig/` (ADR-25) naming the
+        # `ActionController` namespace and the errors controllers rescue, so the constants stop resolving
+        # to `untyped`. `ActionController::Parameters` and the `ActionDispatch` readers stay undeclared;
+        # `sig/action_controller.rbs` documents why that absence is load-bearing.
+        version: "1.2.0",
         description: "Validates Action Pack route-helper calls and filter chains inside controllers, and types the request-context readers (`params` / `session` / `request` / `flash`) and their chains.",
         config_schema: {
           "controller_search_paths" => { kind: :array, default: ["app/controllers"] },
@@ -78,6 +83,26 @@ module Rigor
           { plugin_id: "rails-routes", name: :helper_table, optional: true },
           { plugin_id: "activerecord", name: :model_index, optional: true }
         ],
+        # ADR-25 (#534 item 7) — the framework-namespace signatures. See `sig/action_controller.rbs` for
+        # the admission rule and, more importantly, for what it refuses to declare.
+        signature_paths: ["sig"],
+        # ADR-26 — every class the bundled signature names is declared so the CONSTANT resolves; none of
+        # them enumerates a method surface, so `ParameterMissing#param` and its siblings must stay
+        # lenient rather than becoming `call.undefined-method` on a rescue body.
+        open_receivers: [
+          "ActionController::ActionControllerError",
+          "ActionController::BadRequest",
+          "ActionController::RoutingError",
+          "ActionController::UrlGenerationError",
+          "ActionController::MethodNotAllowed",
+          "ActionController::NotImplemented",
+          "ActionController::UnknownFormat",
+          "ActionController::InvalidAuthenticityToken",
+          "ActionController::InvalidCrossOriginRequest",
+          "ActionController::MissingExactTemplate",
+          "ActionController::ParameterMissing",
+          "ActionController::UnpermittedParameters"
+        ],
         # ADR-103 WD10 / WD14 (#387) — see {Effects} for what each row is and why.
         effect_root: "rails",
         effect_labels: %w[
@@ -144,7 +169,8 @@ module Rigor
         diagnostics_for(
           Analyzer.render_violations_for(
             call_node: node, ancestors: context.ancestors, path: path,
-            view_search_roots: @view_search_paths, controller_index: producer_value(:controller_index)
+            view_search_roots: @view_search_paths, io_boundary: io_boundary,
+            controller_index: producer_value(:controller_index)
           ),
           path: path, node: node
         )

data/plugins/rigor-actionpack/sig/action_controller.rbs

@@ -0,0 +1,71 @@
+# Action Pack's framework namespaces — issue #534 item 7.
+#
+# The 2026-09-01 corpus sweep counted `ActionController` 37 times on mastodon as an unresolved
+# constant. This file names the namespace and the errors controllers rescue, and nothing else.
+#
+# ## What must NOT be declared here, and why the list is so short
+#
+# `ActionController::Parameters` is absent on purpose, and it is the most important absence in this
+# plugin. `Rigor::Plugin::Actionpack::REQUEST_CONTEXT_READER_TYPES` types `params` as a *lenient*
+# nominal — a real class name Rigor ships no RBS for — precisely so that `params.require(...)`,
+# `params.to_unsafe_h` and every other member of a surface no signature can complete resolve
+# lenient-to-`Dynamic` instead of drawing `call.undefined-method`. Declaring the class here, even
+# empty, would make it RBS-known and undo that. The same argument covers `ActionDispatch::Request`,
+# `Request::Session`, `Flash::FlashHash`, `Flash::FlashNow` and `Cookies::CookieJar`.
+#
+# `ActionController::Base` and `ActionController::API` are absent for the stronger reason: every
+# controller in a Rails app inherits from one of them, so declaring either empty would close the
+# whole project's controller hierarchy and turn `render`, `before_action`, `head` and the rest into
+# `call.undefined-method` on working code.
+#
+# What is left is exactly the shape that is safe: bare namespace modules nobody dispatches on, and
+# exception classes whose inherited surface is a core Ruby one Rigor already carries. Each error
+# class is listed in the manifest's `open_receivers:` (ADR-26), so the framework-specific readers
+# this file does not enumerate (`ParameterMissing#param`, `UrlGenerationError#routes`, …) stay
+# lenient too.
+#
+# Superclasses transcribed from Rails v8.0.2 (`actionpack/lib/action_controller/metal/exceptions.rb`
+# and `strong_parameters.rb`); `ParameterMissing < KeyError` and `UnpermittedParameters < IndexError`
+# are the two that are NOT under `ActionControllerError`, and getting that wrong would be a wrong
+# `rescue` reachability answer, so both are stated from the source rather than from the pattern.
+
+module ActionController
+  class ActionControllerError < StandardError
+  end
+
+  class BadRequest < ActionControllerError
+  end
+
+  class RoutingError < ActionControllerError
+  end
+
+  class UrlGenerationError < ActionControllerError
+  end
+
+  class MethodNotAllowed < ActionControllerError
+  end
+
+  class NotImplemented < MethodNotAllowed
+  end
+
+  class UnknownFormat < ActionControllerError
+  end
+
+  class InvalidAuthenticityToken < ActionControllerError
+  end
+
+  class InvalidCrossOriginRequest < ActionControllerError
+  end
+
+  class MissingExactTemplate < UnknownFormat
+  end
+
+  # `::KeyError` is generic in core RBS (`KeyError[K, R]`, the receiver and key of the failed lookup),
+  # so the supertype has to be applied. `untyped` on both: Rails raises it from a Parameters lookup and
+  # this signature has no business claiming what `#receiver` / `#key` answer.
+  class ParameterMissing < ::KeyError[untyped, untyped]
+  end
+
+  class UnpermittedParameters < ::IndexError
+  end
+end

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

@@ -25,10 +25,6 @@ module Rigor
 
         # The job-call violations for a single call node (0..2), or `[]` when the node is not a
         # `<Job>.perform_*` entry call on a known job. ADR-37: the engine owns the walk.
-        #
-        # @param call_node [Prism::Node]
-        # @param job_index [JobIndex]
-        # @return [Array<Violation>]
         def violations_for(call_node:, job_index:)
           return [] unless call_node.is_a?(Prism::CallNode) && entry_call?(call_node)
 

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

@@ -61,7 +61,7 @@ module Rigor
 
         module_function
 
-        # @param adapter [String, nil] the adapter the project declares, or nil when it declares none
+        # @param adapter — the adapter the project declares, or nil when it declares none
         #   (or more than one, across environments)
         def attributions(adapter)
           labels = (TRANSPORTS[adapter] || ["io"]) + MEANING

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_discoverer.rb

@@ -32,7 +32,6 @@ module Rigor
           @base_classes = base_classes.to_set { |name| strip_root(name.to_s) }
         end
 
-        # @return [JobIndex]
         def discover
           candidates = []
           ruby_files_under(@search_paths).each do |path|

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_index.rb

@@ -42,8 +42,6 @@ module Rigor
         # `"::WelcomeJob"`; see {JobDiscoverer}), while a QUERY may legitimately arrive rooted:
         # `::WelcomeJob.perform_later(1)` renders its receiver as `"::WelcomeJob"`. The root marker is
         # dropped here, once, so no caller needs a `find(name) || find("::#{name}")` retry (#621).
-        #
-        # @return [Entry, nil]
         def find(class_name)
           @by_name[strip_leading_namespace(class_name.to_s)]
         end

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/recurring_scan.rb

@@ -51,7 +51,7 @@ module Rigor
           @recurring_paths = recurring_paths
         end
 
-        # @return [Array<String>] the class names named by a `class:` key in a recurring-task entry, sorted
+        # @return the class names named by a `class:` key in a recurring-task entry, sorted
         #   and unique. NOT yet intersected with the discovered jobs — the caller does that.
         def job_names
           names = Set.new

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

@@ -37,6 +37,7 @@ module Rigor
     class Activejob < Rigor::Plugin::Base
       manifest(
         id: "activejob",
+        target_gems: ["activejob"],
         # Bumped — publishes `:reachability_roots` for `rigor unused` (ADR-102 WD3): the jobs Solid Queue's
         # recurring schedule runs by name, which no `perform_later` call site writes down.
         #

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

@@ -77,9 +77,8 @@ module Rigor
       #   `ApplicationRecord`) setting `self.table_name_prefix` for every model under it — both already
       #   guess wrong identically on unpatched code.
       class ModelDiscoverer
-        # @param io_boundary [Rigor::Plugin::IoBoundary]
-        # @param search_paths [Array<String>] absolute or project-relative paths.
-        # @param base_classes [Array<String>] superclass names that identify a class as an AR model.
+        # @param search_paths — absolute or project-relative paths.
+        # @param base_classes — superclass names that identify a class as an AR model.
         # Declaration macros whose column's runtime value is a rich object, not the SQL scalar. Their column
         # must NOT be narrowed to the schema type (see {ModelIndex.build}'s type-override remap).
         TYPE_OVERRIDE_METHODS = %i[serialize mount_uploader mount_uploaders].freeze
@@ -113,7 +112,7 @@ module Rigor
 
         attr_reader :type_override_columns
 
-        # @return [Array<Hash>] rows of { class_name:, table_name_override:, sti_parent:, ... }
+        # @return rows of { class_name:, table_name_override:, sti_parent:, ... }
         def discover
           candidates = []
           ruby_files_under(@search_paths).each do |path|

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

@@ -45,8 +45,7 @@ module Rigor
           unique_constraint foreign_key primary_keys
         ].freeze
 
-        # @param source [String] contents of `db/schema.rb`
-        # @return [SchemaTable]
+        # @param source — contents of `db/schema.rb`
         def self.parse(source)
           tree = Prism.parse(source).value
           new.parse(tree)

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

@@ -54,8 +54,7 @@ module Rigor
         # Uppercase leading keywords that mark a table-level constraint line rather than a column.
         CONSTRAINT_KEYWORDS = %w[CONSTRAINT PRIMARY UNIQUE CHECK FOREIGN EXCLUDE LIKE PARTITION].freeze
 
-        # @param source [String] contents of `db/structure.sql`
-        # @return [SchemaTable]
+        # @param source — contents of `db/structure.sql`
         def self.parse(source)
           new.parse(source)
         end

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

@@ -63,6 +63,12 @@ module Rigor
     class Activerecord < Rigor::Plugin::Base
       manifest(
         id: "activerecord",
+        target_gems: ["activerecord"],
+        # 0.9.0, 2026-09-10 (#534 item 7) — the bundled signatures gained `sig/active_record/framework.rbs`:
+        # the Active Record exception hierarchy, the `ActiveModel` namespace and `Arel`. No producer payload
+        # changed shape, but the version is the cache key a project sees, and the RBS half of a plugin's
+        # contribution rides the same bundle.
+        #
         # 0.8.0, 2026-09-02 — a model declared `class ::User` is keyed by its de-rooted name (`"User"`) in
         # the {ModelIndex} and the published `:model_index` fact (#583). The version is part of the
         # producer cache KEY: a cached 0.7.0 index still keys such a model `"::User"`, and `ModelIndex#find`
@@ -87,7 +93,7 @@ module Rigor
         # a scope lambda body / class-method body now contributes `Relation[Model]` via `scope.self_type`
         # instead of falling through to `Kernel#select` (the IO multiplexer, `Array[String]` return). Plus
         # `:select` added to the relation-entry-point list.
-        version: "0.8.0",
+        version: "0.9.0",
         description: "Types ActiveRecord finders against the project's db/schema.rb and AR models.",
         config_schema: {
           "schema_file" => { kind: :string, default: "db/schema.rb" },
@@ -104,7 +110,28 @@ module Rigor
         # ADR-26 — `ActiveRecord::Relation` is an "open" receiver: it delegates an unbounded set of
         # user-defined scopes / class methods to its model, so `call.undefined-method` must not fire for
         # it. `CheckRules` reads this manifest field and skips the rule for the class.
-        open_receivers: ["ActiveRecord::Relation"],
+        #
+        # The `sig/active_record/framework.rbs` names (#534 item 7) are open for the narrower reason that
+        # file documents: each is declared so the CONSTANT resolves, and none of them enumerates a method
+        # surface. `RecordInvalid#record`, `StatementInvalid#sql`, `Arel.star` and every other member left
+        # out must stay lenient, so the declaration buys constant resolution and asserts nothing else.
+        open_receivers: [
+          "ActiveRecord::Relation",
+          "ActiveRecord::ActiveRecordError",
+          "ActiveRecord::RecordNotFound",
+          "ActiveRecord::RecordInvalid",
+          "ActiveRecord::RecordNotSaved",
+          "ActiveRecord::RecordNotDestroyed",
+          "ActiveRecord::ReadOnlyRecord",
+          "ActiveRecord::Rollback",
+          "ActiveRecord::StaleObjectError",
+          "ActiveRecord::ConnectionNotEstablished",
+          "ActiveRecord::StatementInvalid",
+          "ActiveRecord::WrappedDatabaseException",
+          "ActiveRecord::RecordNotUnique",
+          "ActiveModel::ValidationError",
+          "Arel"
+        ],
         # ADR-103 WD2 / WD10 (#387) — the effect layer. rigor-activerecord models ActiveRecord, which is
         # part of Rails, so it opens the framework's own `rails.*` root rather than one named after the
         # plugin; `effect_root:` is granted only because the engine bundles this plugin
@@ -512,15 +539,23 @@ module Rigor
         return bool_type if predicate
 
         inner = ruby_type_to_type(column.ruby_type)
-        return nil if inner.nil?
+        return Rigor::Type::Combinator.untyped if inner.nil?
 
         column.array? ? Rigor::Type::Combinator.nominal_of("Array", type_args: [inner]) : inner
       end
 
-      # Maps a `SchemaTable::Column#ruby_type` string to a Rigor type. `"Object"` (json / jsonb /
-      # unrecognised column types) declines — `Nominal[Object]` would be NARROWER than the RBS-erased
-      # envelope and could surface false `call.undefined-method` on a value whose real shape the plugin
-      # cannot model.
+      # Maps a `SchemaTable::Column#ruby_type` string to a Rigor type. `"Object"` (json / jsonb / a
+      # `serialize`d or `mount_uploader`ed column / an unrecognised SQL type) declines — `Nominal[Object]`
+      # would be NARROWER than the RBS-erased envelope and could surface false `call.undefined-method` on a
+      # value whose real shape the plugin cannot model.
+      #
+      # ADR-82 WD4 — the caller turns that decline into an explicit `Dynamic[top]` rather than passing the
+      # call on. The two are the same type at the site (dispatch widens an unresolved reader to Dynamic
+      # anyway), but only the plugin ANSWERING makes the engine record `framework_dsl_boundary`: this is a
+      # macro-generated attribute whose value crosses a DSL boundary and stays dynamic, which is exactly the
+      # cause WD4 defined and left unattributed. Answering here is honest in the way WD4 requires — the
+      # plugin knows the reader exists (the schema declares the column) and knows it cannot type it — where
+      # guessing "framework boundary" for any unresolved receiver would not be.
       def ruby_type_to_type(ruby_type)
         case ruby_type
         when "bool" then bool_type