rigortype 0.4.3 → 0.4.5

data/lib/rigor/type/constant.rb

@@ -78,7 +78,8 @@ module Rigor
       # `RbsTypeTranslator#translate_literal` already maps the parsed RBS Literal back to `Constant`.
       # Scalar carriers without RBS Literal support (Float, Range, Rational, Complex, Regexp, Pathname)
       # keep their pre-existing widen-to-class-name behaviour because RBS rejects their literal spellings
-      # as syntax errors.
+      # as syntax errors. `Range` is generic (`Range[out E]`), and a bare `Range` fails `rbs validate`, so
+      # it carries the class of its endpoints, or `untyped` when both are nil (#1891).
       def erase_to_rbs
         case value
         when true then "true"
@@ -86,6 +87,7 @@ module Rigor
         when nil then "nil"
         when Integer then value.to_s
         when Symbol, String then value.inspect
+        when Range then "Range[#{range_element_rbs}]"
         else value.class.name
         end
       end
@@ -106,6 +108,13 @@ module Rigor
       def inspect
         "#<Rigor::Type::Constant #{describe(:short)}>"
       end
+
+      private
+
+      def range_element_rbs
+        classes = [value.begin, value.end].compact.map { |endpoint| endpoint.class.name }.uniq.sort
+        classes.empty? ? "untyped" : classes.join(" | ")
+      end
     end
   end
 end

data/lib/rigor/version.rb

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

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

@@ -99,7 +99,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -90,7 +90,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -58,7 +58,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -159,13 +159,18 @@ module Rigor
 
           # Project-relative paths, the spelling `#template_units_for_file` is handed and the spelling the
           # compiled cache is keyed by.
+          #
+          # #1803 — listed through the boundary's `#glob`, which records each root's membership: a helper
+          # added under `app/helpers`, or a template under a `view_search_paths:` root the template globs do
+          # not claim, is analysed by nobody, and without the row the run-result caches kept serving the
+          # index built before it appeared.
           def self.source_files(io_boundary, roots, pattern)
             root_prefix = "#{Dir.pwd}#{File::SEPARATOR}"
             roots.flat_map do |root|
               absolute = File.expand_path(root)
               next [] unless io_boundary.directory?(absolute)
 
-              Dir.glob(File.join(absolute, "**", pattern)).map { |path| path.delete_prefix(root_prefix) }
+              io_boundary.glob(absolute, "**/#{pattern}").map { |path| path.delete_prefix(root_prefix) }
             end
           end
 

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

@@ -116,7 +116,7 @@ module Rigor
               absolute = File.expand_path(root)
               next [] unless @io_boundary.directory?(absolute)
 
-              Dir.glob(File.join(absolute, "**", "*.rb"))
+              @io_boundary.glob(absolute, "**/*.rb")
             end
           end
 

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers/serializer_discoverer.rb

@@ -127,7 +127,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -146,11 +146,12 @@ module Rigor
 
         # ADR-45 WD1b (#613) — `config/application.rb` is probed at a fixed path, so its ABSENCE is what
         # shapes "no adapter" on a project that has none yet; the probe goes through the boundary to record
-        # that. The globbed `config/environments/*.rb` entries exist by enumeration and only pick up the
-        # (immediately superseded) presence row.
+        # that. The `config/environments/*.rb` listing goes through `#glob` (#1803), whose row records the
+        # directory's membership; each listed entry only picks up the (immediately superseded) presence row.
         def config_files(io_boundary, root)
           application = File.join(root, CONFIG_PATHS.first)
-          environments = Dir.glob(File.join(root, CONFIG_PATHS.last, "*.rb"))
+          environments_dir = File.join(root, CONFIG_PATHS.last)
+          environments = io_boundary.glob(environments_dir, "*.rb")
           ([application] + environments).select { |path| io_boundary.file?(path) }
         rescue StandardError
           []

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

@@ -92,7 +92,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -375,7 +375,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -69,7 +69,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

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

@@ -65,7 +65,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
       end

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

@@ -168,10 +168,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -109,7 +109,7 @@ module Rigor
       def scannable_paths
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            Dir.glob("**/*.rb", base: entry).map { |path| File.join(entry, path) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -142,10 +142,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -54,7 +54,7 @@ module Rigor
             if @io_boundary.file?(absolute)
               [absolute]
             elsif @io_boundary.directory?(absolute)
-              Dir.glob(File.join(absolute, "**", "*.rb"))
+              Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
             else
               []
             end

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/discoverer.rb

@@ -5,13 +5,22 @@ require "prism"
 module Rigor
   module Plugin
     class FFI < Base
+      # Issue #1803 — the walk lists and reads through the plugin's {Rigor::Plugin::IoBoundary} (`io:`), so every
+      # `.rb` the catalog was built from is a dependency row of the `:ffi_catalog` producer's cache entry and of
+      # every run-result cache built on the run. The producer declares no `watch:`, so before this its entry
+      # carried no row at all and was served after any edit, an analysed file's included, until `--no-cache`.
       class Discoverer
-        def self.discover(root:)
-          new(root: root).discover
+        RUBY_GLOB = "**/*.rb"
+        RUBY_FILE = "*.rb"
+        SKIPPED_DIRECTORIES = %w[vendor .git].freeze
+
+        def self.discover(root:, io:)
+          new(root: root, io: io).discover
         end
 
-        def initialize(root:)
+        def initialize(root:, io:)
           @root = root
+          @io = io
         end
 
         def discover
@@ -24,7 +33,7 @@ module Rigor
           callbacks = {}
 
           ruby_files.each do |file_path|
-            parse_result = Prism.parse_file(file_path)
+            parse_result = parse(file_path)
             next unless parse_result.value
 
             walk_tree(parse_result.value, nil) do |node, mod_name|
@@ -60,10 +69,52 @@ module Rigor
 
         private
 
+        # #1959 — one `:kinds` listing row over the root's top-level entries, then one `:names` `**/*.rb` row per
+        # real directory among them other than `vendor/`. A single `**/*.rb` row over the root re-walked an in-tree
+        # `vendor/bundle` on every warm validation and read stale on every `bundle install`. The listing carries
+        # each entry's kind and not just its name: the walk descends a directory but not a symlinked one (`**` never
+        # followed it), so a file `gen` that becomes a directory `gen/`, or a symlink that becomes a real
+        # directory, changes what it reads while every name stays put.
+        #
+        # The answer is `Dir.glob("**/*.rb")` minus the skipped paths and minus every match that is not a regular
+        # file (#2113), in its order: entry by entry, a top-level name matching `*.rb`, then that directory's
+        # matches. A directory so named is walked, never read. The boundary answers absolute paths; they are spelled
+        # back under `@root` as `Dir.glob` spells them.
         def ruby_files
-          return [] unless @root && File.directory?(@root)
+          return [] unless @root && @io.directory?(@root.to_s)
+
+          root = @root.to_s
+          prefix = "#{File.absolute_path(root)}/"
+          @io.list_directory_kinds(root).flat_map do |path, kind|
+            name = path.delete_prefix(prefix)
+            own = File.fnmatch?(RUBY_FILE, name) && readable_file?(path, kind) ? [File.join(root, name)] : []
+            next own unless kind == :directory && !SKIPPED_DIRECTORIES.include?(name)
+
+            own + @io.glob(path, RUBY_GLOB).filter_map do |nested|
+              relative = nested.delete_prefix(prefix)
+              File.join(root, relative) if !skipped?(relative) && @io.file?(nested)
+            end
+          end
+        end
+
+        # #2113 — `*.rb` names a directory too, and a fifo, socket or device can carry the name. Only a regular file
+        # is read: `read_file` on a directory raises `EISDIR` and aborts the whole walk, and on a fifo it blocks
+        # until a writer appears. A top-level entry is judged by its `lstat` kind, and a symlink by what it
+        # resolves to; a nested match is judged by `file?` (which follows a symlink as `File.file?` does).
+        def readable_file?(path, kind)
+          kind == :file || (kind == :symlink && @io.file?(path))
+        end
+
+        # #1956 — the skip reads the path relative to the root, a `vendor` or `.git` directory segment at any
+        # depth under it. Matching `/vendor/` in the whole path also dropped every file of a project that itself
+        # lives under some `…/vendor/…` directory, and the catalog came out empty.
+        def skipped?(relative)
+          relative.split("/")[0...-1].intersect?(SKIPPED_DIRECTORIES)
+        end
 
-          Dir.glob(File.join(@root, "**", "*.rb")).reject { |p| p.include?("/vendor/") || p.include?("/.git/") }
+        # The glob's rows record which files match; this read's row carries an edit.
+        def parse(file_path)
+          Prism.parse(@io.read_file(file_path))
         end
 
         def walk_tree(node, current_module, &)

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/target_detector.rb

@@ -26,7 +26,7 @@ module Rigor
         def extconf_uses_ffx?(root, io = nil)
           return false if root.nil?
 
-          extconfs = io ? io.glob(root.to_s, EXTCONF_GLOB) : Dir.glob(File.join(root.to_s, EXTCONF_GLOB))
+          extconfs = io ? io.glob(root.to_s, EXTCONF_GLOB) : Dir.glob(EXTCONF_GLOB, base: root.to_s).map { |path| File.join(root.to_s, path) }
           extconfs.any? do |extconf|
             read_text(extconf, io).include?("FFX.create_makefile")
           rescue SystemCallError

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

@@ -32,7 +32,7 @@ module Rigor
 
       producer :ffi_catalog do
         root = config["root"] || Dir.pwd
-        Discoverer.discover(root: root)
+        Discoverer.discover(root: root, io: io_boundary)
       end
 
       # Dynamic return rule for attached FFI functions

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

@@ -151,10 +151,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/authorization_scan.rb

@@ -72,7 +72,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_discoverer.rb

@@ -60,7 +60,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_index.rb

@@ -34,12 +34,17 @@ module Rigor
           end
         end
 
-        attr_reader :entries, :locales
+        attr_reader :entries, :locales, :load_errors
 
         # @param locales — all locale names that contributed at least one key.
-        def initialize(entries, locales:)
+        # @param load_errors — the {LocaleLoader::LoadError}s of the files that did not parse (#1954). They
+        #   ride in the index, not beside it, because the index is the cached producer value: a warm run
+        #   serves it without re-reading a single locale file, so an error kept anywhere else is lost exactly
+        #   when the cache hits.
+        def initialize(entries, locales:, load_errors: [])
           @entries = entries.freeze
           @locales = locales.dup.freeze
+          @load_errors = load_errors.map(&:freeze).freeze
           @by_key = entries.to_h { |e| [e.dotted_key, e] }.freeze
           freeze
         end

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_loader.rb

@@ -15,9 +15,9 @@ module Rigor
       # flattened into dotted keys (`users.welcome`, `errors.messages.blank`, …). For each leaf string,
       # `%{var}` placeholders are extracted via a simple regex.
       #
-      # Files that fail to parse are skipped with a load-error diagnostic surfaced through the plugin's
-      # error channel. Non-Hash YAML roots (e.g. a top-level sequence) are also skipped — the format is
-      # locale-keyed by convention.
+      # Files that fail to parse are skipped and recorded in the returned index's `load_errors`, which the
+      # plugin discloses as a run-scoped load-error row. Non-Hash YAML roots (e.g. a top-level sequence) are
+      # also skipped — the format is locale-keyed by convention.
       class LocaleLoader
         PLACEHOLDER_RE = /%\{(?<name>[^}]+)\}/
 
@@ -66,7 +66,7 @@ module Rigor
               value_kinds: per_key_kinds[dotted_key].freeze
             )
           end
-          LocaleIndex.new(entries, locales: locales.to_a.sort)
+          LocaleIndex.new(entries, locales: locales.to_a.sort, load_errors: @load_errors)
         end
 
         private
@@ -90,7 +90,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.{yml,yaml}"))
+            Dir.glob("**/*.{yml,yaml}", base: absolute).map { |path| File.join(absolute, path) }
           end.sort
         end
 

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -57,7 +57,11 @@ module Rigor
         target_gems: ["i18n"],
         # Bumped 2026-06-23 — view template lazy-key scanning (`t('.key')` inside ERB / Haml / Slim under
         # `view_search_paths`).
-        version: "0.3.0",
+        # Bumped 2026-10-17 (#1954) — the cached `:locale_index` value now carries the YAML load errors. A
+        # belt-and-braces key change: a released build already drops pre-change entries with the cache ABI
+        # (`Rigor::VERSION`) and a checkout with its engine-source identity, and the read below tolerates
+        # an index without errors either way.
+        version: "0.3.1",
         description: "Validates I18n `t(key)` calls against `config/locales/*.yml`.",
         config_schema: {
           "locale_search_paths" => { kind: :array, default: ["config/locales"] },
@@ -72,17 +76,12 @@ module Rigor
       )
 
       # `watch:` covers every `.yml` / `.yaml` file under the locale search paths so the cache invalidates
-      # when locale files are added, removed, or edited (ADR-60 WD3). `@load_errors` is a producer-side
-      # capture: it is populated only when the block runs (a cache miss / a watched file changed), which is
-      # exactly when a malformed YAML must re-surface.
+      # when locale files are added, removed, or edited (ADR-60 WD3). The YAML load errors travel inside the
+      # returned index (`LocaleIndex#load_errors`), not in an instance variable the block sets (#1954): a
+      # warm producer-cache hit skips the block, so a block-side capture lost the load-error row on every
+      # run whose result was not itself served from the run-result cache.
       producer :locale_index, watch: -> { [[@locale_search_paths, "**/*.yml", "**/*.yaml"]] } do |_params|
-        loader = LocaleLoader.new(
-          io_boundary: io_boundary,
-          search_paths: @locale_search_paths
-        )
-        index = loader.load
-        @load_errors = loader.load_errors
-        index
+        LocaleLoader.new(io_boundary: io_boundary, search_paths: @locale_search_paths).load
       end
 
       # Scans view templates under `view_search_paths` for lazy `t('.key')` / `I18n.translate('.key')`
@@ -102,7 +101,6 @@ module Rigor
         @locale_search_paths = Array(config.fetch("locale_search_paths")).map(&:to_s)
         @view_search_paths = Array(config.fetch("view_search_paths")).map(&:to_s)
         @configured_locales = Array(config.fetch("configured_locales")).map(&:to_s)
-        @load_errors = []
       end
 
       # Returns no rows of its own: every file-level outcome here is run-scoped. The YAML load errors and the
@@ -114,8 +112,11 @@ module Rigor
       # are lazily loaded + memoised by `producer_value`, so the repeat registrations are no-ops.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:locale_index)
-        disclose_load_errors unless @load_errors.empty?
-        disclose_locale_runtime_error if index.nil? && producer_error(:locale_index)
+        if index
+          disclose_load_errors(Array(index.load_errors))
+        elsif producer_error(:locale_index)
+          disclose_locale_runtime_error
+        end
         view_diags = producer_value(:view_diagnostics) || []
         if (view_err = producer_error(:view_diagnostics))
           disclose_view_runtime_error(view_err)
@@ -175,7 +176,7 @@ module Rigor
           # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
           next [] unless io_boundary.directory?(absolute)
 
-          Dir.glob(File.join(absolute, "**", "*.{erb,haml,slim}"))
+          Dir.glob("**/*.{erb,haml,slim}", base: absolute).map { |path| File.join(absolute, path) }
         end.sort
       end
 
@@ -209,8 +210,8 @@ module Rigor
       # be pinned to the first analysed Ruby file — once per plugin INSTANCE, so once per fork-pool worker
       # (#1051). They go through the run-scoped channel instead: keyed by the locale path that failed, so a
       # project with two broken YAML files still discloses both, each exactly once, at `.rigor.yml:1:1`.
-      def disclose_load_errors
-        @load_errors.each do |err|
+      def disclose_load_errors(load_errors)
+        load_errors.each do |err|
           disclose_once(
             "locale-parse:#{err.path}",
             message: "rigor-rails-i18n: failed to parse `#{err.path}`: #{err.message}",

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -168,7 +168,7 @@ module Rigor
           # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
           next unless io_boundary.directory?(absolute)
 
-          Dir.glob(File.join(absolute, "**", "*.rb")).each(&)
+          Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }.each(&)
         end
       end