rigortype 0.2.9 → 0.3.0

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

@@ -63,12 +63,28 @@ module Rigor
         produces: [:dry_type_aliases]
       )
 
-      # Walks every project file once during `prepare(services)` to build the alias table, then publishes
-      # via the ADR-9 fact store. The walk is bounded by the configured `paths:` surface; each file's
-      # parse error degrades to "no contribution" without polluting the user-visible diagnostic stream.
+      # Cached alias-table producer (ADR-60 WD3 record-and-validate). The scan Prism-parses every `.rb` file
+      # under the project's `paths:` tree to find `include Dry.Types()` declarations — an expensive pass that
+      # ran on EVERY invocation (cold and warm) because `#prepare` called {AliasScanner.scan} directly, with
+      # no cache. It now rides `cache_for`: a warm run re-globs + re-digests the watched tree (cheap SHA over
+      # file bytes, no AST build) and reuses the cached table instead of re-parsing. This is the dominant win
+      # even for a project that ships no dry-types module — the parse still has to run to prove that, and now
+      # the empty result is cached too.
+      #
+      # `watch:` covers exactly the files the scan reads: one glob per project `paths:` entry, co-extensive
+      # with {#scannable_paths}. A {Cache::Descriptor::GlobEntry} digests every file matching its glob, so a
+      # content edit, a file addition, and a file removal anywhere under those paths all move the digest and
+      # invalidate the entry. The scan reads no file individually through the `IoBoundary`, so the evaluated
+      # `watch:` globs are the entire dependency descriptor — and they fully cover the scan's input.
+      producer :dry_type_aliases, watch: -> { alias_watch_globs } do |_params|
+        AliasScanner.scan(paths: scannable_paths)
+      end
+
+      # Builds the (cached) alias table and publishes it via the ADR-9 fact store. `producer_value` runs the
+      # producer through `cache_for` and memoises the result — including a rescued nil — for the run.
       def prepare(services)
-        aliases = AliasScanner.scan(paths: scannable_paths(services))
-        return if aliases.empty?
+        aliases = producer_value(:dry_type_aliases)
+        return if aliases.nil? || aliases.empty?
 
         services.fact_store.publish(
           plugin_id: manifest.id,
@@ -86,7 +102,7 @@ module Rigor
       # Resolves the project's `paths:` to a flat list of `.rb` files the scanner walks. Mirrors
       # `Analysis::Runner`'s `expand_paths` floor; we don't need the runner's full exclude/sort surface
       # because the alias table is a union — any duplicate scan is a no-op.
-      def scannable_paths(services)
+      def scannable_paths
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if File.directory?(entry)
             Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
@@ -97,6 +113,22 @@ module Rigor
           end
         end.uniq.freeze
       end
+
+      # The `watch:` glob tuples covering the scan's entire input — one `[root, pattern]` per project `paths:`
+      # entry. A directory entry watches its whole `**/*.rb` subtree; a single-file `.rb` entry watches
+      # exactly that file (`[dir, basename]`). Roots are expanded to absolute paths by
+      # `Plugin::Base#watch_glob_entries`, so a relative CLI path (`app/models`) re-validates against the same
+      # tree from the project root on the next run. Co-extensive with {#scannable_paths}: every `.rb` the scan
+      # would read is watched, so any edit / addition / removal under those paths invalidates the cache.
+      def alias_watch_globs
+        services.configuration.paths.filter_map do |entry|
+          if File.directory?(entry)
+            [entry, "**/*.rb"]
+          elsif File.file?(entry) && entry.end_with?(".rb")
+            [File.dirname(entry), File.basename(entry)]
+          end
+        end
+      end
     end
 
     Rigor::Plugin.register(DryTypes)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -86,7 +88,7 @@ module Rigor
             visit_factory(node, &)
             return
           end
-          node.compact_child_nodes.each { |child| walk_for_factories(child, &) }
+          node.rigor_each_child { |child| walk_for_factories(child, &) }
         end
 
         def factory_call?(node)

data/plugins/rigor-hanami/lib/rigor/plugin/hanami/action_checker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -65,7 +67,7 @@ module Rigor
           case node
           when Prism::DefNode then defs << node
           when Prism::ClassNode, Prism::ModuleNode then nil # nested scopes own their own defs
-          else node.compact_child_nodes.each { |child| collect_direct_defs(child, defs) }
+          else node.rigor_each_child { |child| collect_direct_defs(child, defs) }
           end
         end
 

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

@@ -122,6 +122,16 @@ module Rigor
         carried_type(receiver_type, call_node.name)
       end
 
+      # ADR-88 WD1 — the `dynamic_return` contribution is a PURE STRUCTURAL projection of the receiver's own
+      # carrier type args (`Result[T, E]#unwrap → T`), computed per call from the receiver type the engine
+      # already resolved; it reads no cross-file catalog. (The `Enum` nested-class emission rides the ADR-16
+      # macro substrate / synthetic-method scanner, a separate pre-pass, not this `dynamic_return`.) A stable
+      # sentinel declares "no cross-file fact surface", keeping the plugin incremental-capable; the
+      # `--verify-incremental` gate backstops the claim.
+      def incremental_state_fingerprint
+        "structural-carriers"
+      end
+
       private
 
       # @return [Rigor::Type, nil] the receiver's inferred type, or nil when the engine raises on a synthetic

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

@@ -62,6 +62,17 @@ module Rigor
       narrowing_facts methods: AssertionAnalyzer::SUPPORTED_METHODS do |call_node, scope|
         AssertionAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end
+
+      # ADR-88 WD1 — the narrowing facts this plugin contributes are derived purely from each assertion call's
+      # own AST at its call site (`assert_kind_of(String, x)` ⇒ `x` is `String` on the continuation); there is
+      # no cross-file catalog a cached diagnostic could depend on. A change to a file's assertions changes that
+      # file's own content (re-analysed by the incremental graph already). A stable sentinel declares "no
+      # cross-file fact surface", keeping the plugin incremental-capable (a contributing plugin with NO
+      # fact / producer / hook makes the incremental snapshot un-reusable every run); `--verify-incremental`
+      # backstops the claim.
+      def incremental_state_fingerprint
+        "per-file-assertions"
+      end
     end
 
     Rigor::Plugin.register(Minitest)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 require_relative "policy_index"
@@ -69,7 +71,7 @@ module Rigor
           when Prism::ClassNode then visit_class(node, lexical_path, &)
           when Prism::ModuleNode then visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk_for_policies(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk_for_policies(child, lexical_path, &) }
           end
         end
 

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

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
-# Convenience entry point. `require "rigor-rails"` requires every Tier 1+2 Rails ecosystem plugin in one go,
-# so projects that prefer a single require statement (some `spec_helper` patterns, ad-hoc scripts) do not
-# have to list seven require lines.
+# The Tier 1+2 Rails set, as a single require. Requiring this file registers every member class with
+# `Rigor::Plugin`; the loader's lookup phase then finds them by id when `.rigor.yml` enumerates them.
 #
-# Note: requiring this entry point does NOT mark every plugin as active. The Rigor plugin loader walks
-# `.rigor.yml`'s `plugins:` list and instantiates only the plugins enumerated there. This is per ADR-12
-# WD1's "Gemfile-convenience meta-gem" pattern — users still control which plugins participate in analysis
-# via `.rigor.yml`.
+# UNWIRED — this entry point has no supported use today, and is kept deliberately (ADR-96 WD5) rather
+# than removed. It was ADR-12 WD1's "Gemfile-convenience meta-gem": each plugin was to be its own gem, and
+# `gem "rigor-rails"` was to pull the Rails set into a project's Gemfile in one line. Commit `9769f5fa`
+# dropped the per-plugin gemspecs and ADR-31 settled distribution on the single bundled `rigortype` gem, so
+# there is no `rigor-rails` gem to add to a Gemfile — and `plugins: [rigor-rails]` is rejected by the
+# loader, which requires the members to be enumerated (or one selected with an explicit `id:`).
 #
-# Sub-plugins ARE registered with `Rigor::Plugin` when this file loads (each gem's entry point side-effects
-# a `Plugin.register` call); the loader's lookup phase finds them by id when listed.
-#
-# Adding the gem to a project's Gemfile without listing any plugin in `.rigor.yml` is harmless: the requires
-# happen on `Bundler.require`, but no plugin's `init` / `prepare` / hooks run.
+# ADR-96 WD3 proposes the role this file would fill: `plugins: [rigor-rails]` activating those members
+# whose `target_gems:` are actually in the project's `Gemfile.lock`. If that is rejected, ADR-60 WD1's
+# never-wired-surface criterion applies and this directory goes.
 
 require "rigor-rails-routes"
 require "rigor-rails-i18n"

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -106,7 +108,7 @@ module Rigor
             end
           end
 
-          node.compact_child_nodes.each { |child| walk(child, prefix_path, declarations, superclasses) }
+          node.rigor_each_child { |child| walk(child, prefix_path, declarations, superclasses) }
         end
 
         def record_class(node, qualified, declarations, superclasses)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -87,7 +89,7 @@ module Rigor
           def visit_program_children(node)
             return unless node.respond_to?(:compact_child_nodes)
 
-            node.compact_child_nodes.each do |child|
+            node.rigor_each_child do |child|
               case child
               when Prism::ModuleNode, Prism::ClassNode
                 visit_module_or_class(child)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -371,7 +373,7 @@ module Rigor
           when Prism::CallNode
             interpret_call(node, context)
           else
-            node.compact_child_nodes.each { |child| interpret(child, context) }
+            node.rigor_each_child { |child| interpret(child, context) }
           end
         end
 
@@ -526,7 +528,7 @@ module Rigor
           return unless node.is_a?(Prism::Node)
 
           yield node
-          node.compact_child_nodes.each { |child| walk_for_alias_pattern(child, &) }
+          node.rigor_each_child { |child| walk_for_alias_pattern(child, &) }
         end
 
         def first_block_parameter_name(block_node)
@@ -545,7 +547,7 @@ module Rigor
           body = node.block&.body
           return if body.nil?
 
-          body.compact_child_nodes.each { |child| interpret(child, context) }
+          body.rigor_each_child { |child| interpret(child, context) }
         end
 
         def handle_namespace(node, context)
@@ -625,7 +627,7 @@ module Rigor
           return [] if body.nil?
 
           skips = []
-          body.compact_child_nodes.each do |child|
+          body.rigor_each_child do |child|
             next unless child.is_a?(Prism::CallNode) && child.name == :skip_controllers
             next if child.receiver
 
@@ -748,7 +750,7 @@ module Rigor
             body = context.concern_body(concern_name)
             next if body.nil?
 
-            body.compact_child_nodes.each { |child| interpret(child, context) }
+            body.rigor_each_child { |child| interpret(child, context) }
           end
         end
 

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -8,9 +8,10 @@ require "rigor/plugin"
 # name: T`, `# @rbs return: T`, attribute `#:`, …) and contributes the result to the analysis environment
 # through the `source_rbs_synthesizer:` manifest hook.
 #
-# By default (WD2) only files starting with the upstream `# rbs_inline: enabled` magic comment are
-# processed; a host context can flip this off by setting `require_magic_comment: false` in the plugin
-# config (WD10).
+# Since ADR-93 WD1 the default is `require_magic_comment: false`: a file is processed whenever it actually
+# carries an annotation (see {Synthesizer#annotated?}), with only the upstream `# rbs_inline: disabled`
+# directive opting a file out. Set `require_magic_comment: true` to restore the old ADR-32 WD2 gate that
+# processed only files opening with `# rbs_inline: enabled`.
 module Rigor
   module Plugin
     # The plugin gem requires `rbs/inline` at load time; without the upstream library the synthesizer can't
@@ -35,9 +36,24 @@ module Rigor
       # env-build time. Returns the synthesised RBS source as a String, or `nil` when the file contributes
       # nothing (no magic comment in the default mode, empty annotation set, parse error per WD6).
       class Synthesizer
-        # @param require_magic_comment [Boolean] when `true` (the default, WD2), only files with
-        #   `# rbs_inline: enabled` at the top are processed. When `false` (WD10 host-context override),
-        #   every file is treated as if it carried the magic comment.
+        # An RDoc directive comment: `#:` followed by a bare word (RDoc allows a hyphen, as in `:call-seq:`)
+        # and a closing colon. RDoc predates rbs-inline by about two decades and `#:<name>:` is
+        # indistinguishable from an rbs-inline `#: <type>` assertion to upstream's parser, which reads the
+        # directive name as a type alias — `def f #:nodoc:` becomes `def f: () -> nodoc`, a type nothing
+        # declares (upstream issue: https://github.com/soutaro/rbs-inline/issues/248).
+        #
+        # Matching on shape rather than a name list covers all 17 directives the Ruby docs list
+        # (https://docs.ruby-lang.org/ja/latest/library/rdoc.html) with nothing to maintain, and none of
+        # `#: () -> void`, `#: String`, `#:Integer`, `#: bool`, `#:my_alias`, `#: { name: String }`,
+        # `#: (name: String) -> void`, `#: Integer?`, `#[Integer]` or `# @rbs x: String` matches it: a valid
+        # RBS type never starts with a bare lowercase word that is immediately closed by a colon. Only the
+        # space-free spelling is affected; `# :nodoc:` never reaches upstream's annotation grammar.
+        RDOC_DIRECTIVE_COMMENT = /\A#:[a-z_][\w-]*:/
+
+        # @param require_magic_comment [Boolean] when `false` (the default since ADR-93 WD1), the magic
+        #   comment is not required and the file is processed only if it actually carries an annotation — see
+        #   {#annotated?}. When `true` (the old ADR-32 WD2 gate), only files opening with
+        #   `# rbs_inline: enabled` are processed, and upstream's opt-in semantics apply verbatim.
         def initialize(require_magic_comment:)
           @require_magic_comment = require_magic_comment
           freeze
@@ -55,6 +71,9 @@ module Rigor
           return nil if source.empty?
 
           result = ::Prism.parse(source)
+          _, result = neutralize_rdoc_directives(source, result)
+          return nil if !@require_magic_comment && !annotated?(result)
+
           # `opt_in: true` is rbs-inline's "require the magic comment" mode (per upstream parser.rb:62).
           # The plugin's `require_magic_comment:` config knob maps directly onto it.
           parsed = ::RBS::Inline::Parser.parse(result, opt_in: @require_magic_comment)
@@ -71,6 +90,56 @@ module Rigor
           # message, without crashing analysis.
           [:error, "#{e.class}: #{e.message.to_s.lines.first.to_s.strip}"]
         end
+
+        private
+
+        # True when the file carries at least one rbs-inline annotation. Gates the magic-comment-free mode,
+        # and is the difference between "honour annotations wherever they are" and "fabricate signatures for
+        # code nobody annotated" — upstream's opt-out mode does the latter, emitting a full
+        # `def f: (untyped x) -> untyped` skeleton for EVERY unannotated def. Rigor trusts an accepted
+        # signature over body inference, so those skeletons would replace real inferred types with `untyped`:
+        # measured on mail (zero annotations) as 26 → 42 diagnostics, i.e. the mode actively fought the
+        # analysis on exactly the projects that write no annotations. The spec binds Rigor to treat
+        # annotations as type sources "whenever present" (`overview.md` § "Compatibility hierarchy"); it does
+        # not ask for untyped shadows of unannotated code.
+        #
+        # Detection delegates to upstream's own `AnnotationParser` rather than scanning for `#:` / `@rbs`
+        # with a regexp: the annotation grammar is upstream's to define (ADR-32 WD3), and this keeps a doc
+        # comment that merely mentions `@rbs`, or a URL containing `#:`, from opting a file in. A file with
+        # the magic comment keeps upstream's semantics verbatim — the author opted that file in explicitly,
+        # skeletons and all, which is what `rbs-inline --output` would generate for it.
+        def annotated?(prism_result)
+          ::RBS::Inline::AnnotationParser.parse(prism_result.comments)
+                                         .any? { |parsed| parsed.each_annotation.any? }
+        end
+
+        # Rewrite every RDoc directive comment to its spaced spelling (`#:nodoc:` -> `# :nodoc:`) so
+        # upstream's annotation grammar never sees it, and re-parse. Two reasons this happens here rather
+        # than in {#annotated?}: the directive must not gate a file in, AND it must not reach the synthesis,
+        # because one mis-parsed directive takes the whole class down with it. `def f #:nodoc:` renders as
+        # `def f: (untyped x) -> nodoc`; `nodoc` resolves to nothing, `RBS::DefinitionBuilder` raises
+        # `NoTypeFoundError` for the class, and every real annotation in that class is silently lost —
+        # measured on a class whose `#: (String) -> Integer` method fell back to body inference because a
+        # sibling method carried `#:nodoc:`. `fileutils.rb` alone carries 29 of these.
+        #
+        # The rewrite touches comment text only, so it cannot change what Ruby does; it shifts columns
+        # within the comment, which nothing downstream reads (the synthesized RBS is fresh text with its own
+        # buffer). Prism decides what is a comment, so a `#:nodoc:` inside a string literal stays put. Files
+        # without a directive re-parse nothing.
+        def neutralize_rdoc_directives(source, prism_result)
+          offsets = prism_result.comments.filter_map do |comment|
+            location = comment.location
+            # `start_character_offset`, not `start_offset`: the latter counts BYTES while `String#insert`
+            # indexes CHARACTERS, so on a file with any multi-byte content the space lands mid-word and
+            # rewrites `#:nodoc:` to `#:n odoc:` — still a directive to upstream, and now a corrupted one.
+            location.start_character_offset if RDOC_DIRECTIVE_COMMENT.match?(location.slice)
+          end
+          return [source, prism_result] if offsets.empty?
+
+          # Back to front, so each insertion leaves the earlier offsets valid.
+          rewritten = offsets.sort.reverse.inject(source.dup) { |acc, offset| acc.insert(offset + 1, " ") }
+          [rewritten, ::Prism.parse(rewritten)]
+        end
       end
 
       manifest(
@@ -87,11 +156,16 @@ module Rigor
       # override (returned by `#manifest`, which `Plugin::Registry#source_rbs_synthesizers` consults via
       # `plugin.manifest.source_rbs_synthesizer`).
       #
-      # ADR-32 WD10 — `require_magic_comment` defaults to `true`. Setting it to `false` in `.rigor.yml`
-      # flips the synthesizer into "process every file" mode.
+      # ADR-93 WD1 — `require_magic_comment` defaults to `false`: annotations are official type sources
+      # "always parsed whenever present" per the binding spec (overview.md § Compatibility hierarchy), so
+      # a file is processed when it actually carries an annotation, with the magic comment not required.
+      # The magic-comment-free mode is annotation-presence-gated (see {Synthesizer#annotated?}), so an
+      # unannotated file contributes nothing and the flip cannot regress it. Set `require_magic_comment:
+      # true` in `.rigor.yml` to restore the ADR-32 opt-in behaviour; `# rbs_inline: disabled` remains the
+      # per-file opt-out either way (honoured by upstream unconditionally).
       def initialize(services:, config: {})
         super
-        @require_magic_comment = config.fetch("require_magic_comment", true) ? true : false
+        @require_magic_comment = config.fetch("require_magic_comment", false) ? true : false
         @synthesizer = Synthesizer.new(require_magic_comment: @require_magic_comment)
         # Build the per-instance manifest eagerly (before `freeze`) so the registry's repeated reads
         # return the same object and we don't need to mutate a frozen instance later.

data/plugins/rigor-rbs-inline/lib/rigor-rbs-inline.rb

@@ -3,16 +3,20 @@
 # rigor-rbs-inline — ingests rbs-inline-shaped comments (`# @rbs name: T`, `#: () -> T`, `# @rbs return: T`,
 # attribute `#:`, ivars, generics, override, …) as RBS contributions to the analysis environment.
 #
-# Per ADR-32 the plugin gates per file on the upstream `# rbs_inline: enabled` magic comment by default. A
-# host context that owns the entire analysis scope (e.g. the ADR-29 browser playground) can set
-# `require_magic_comment: false` in the plugin config to skip the gate — every file the synthesizer sees is
-# treated as if it carried the magic comment.
+# Since ADR-93 WD1 the plugin defaults to `require_magic_comment: false`: annotations are official type
+# sources wherever present, gated only on a file actually carrying one, with `# rbs_inline: disabled` the
+# per-file opt-out. ADR-93 WD2 default-wires this plugin from `Configuration.load` when the upstream
+# `rbs-inline` library is resolvable, so most projects need no `plugins:` entry at all. Restore the old
+# ADR-32 magic-comment gate, or opt out of the auto-wire, through config:
 #
 #     # .rigor.yml
 #     plugins:
 #       - id: rigor-rbs-inline
 #         config:
-#           require_magic_comment: false   # default true
+#           require_magic_comment: true    # default false — restore the ADR-32 magic-comment gate
+#       # or disable the auto-wired default entirely:
+#       # - gem: rigor-rbs-inline
+#       #   enabled: false
 #
 # The plugin depends on the upstream `rbs-inline` gem; Rigor's core `rigortype` gemspec stays zero-dep per
 # ADR-0 / ADR-32 WD1.

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_scope_index.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -89,7 +91,7 @@ module Rigor
             return
           end
 
-          node.compact_child_nodes.each do |child|
+          node.rigor_each_child do |child|
             collect(child, anchor: anchor, accumulator: accumulator)
           end
         end

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/scope_walker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -70,7 +72,7 @@ module Rigor
           if rspec_describe_call?(node)
             scopes << build_scope(node, kind: :rspec_describe)
           else
-            node.compact_child_nodes.each { |child| walk_top_level(child, scopes) }
+            node.rigor_each_child { |child| walk_top_level(child, scopes) }
           end
         end
 

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

@@ -97,6 +97,17 @@ module Rigor
         let_binding_return_type(call_node, scope)
       end
 
+      # ADR-88 WD1 — both contributions are per-file: the matcher narrowing facts come from the call's own AST,
+      # and the `let`-binding return types come from each spec file's OWN `describe`/`let` structure (`let` is
+      # file-scoped). A spec file's edit changes its own content (re-analysed already). The one cross-file input
+      # — the optional factorybot `:factory_index` fact this plugin consumes — is itself an ADR-9 publication
+      # captured in the incremental fact-surface digest via factorybot's own channel, so it need not appear
+      # here. A stable sentinel declares "no OWN cross-file fact surface", keeping the plugin
+      # incremental-capable; `--verify-incremental` backstops the claim.
+      def incremental_state_fingerprint
+        "per-file-lets"
+      end
+
       private
 
       # The `file_methods:` gate set — every `let` / `subject` name the file declares anywhere. A safe

data/plugins/rigor-rspec-rails/lib/rigor/plugin/rspec_rails/http_status_codes.rb

@@ -43,7 +43,10 @@ module Rigor
 
           require "rack/utils"
           @rack_status_symbols = Rack::Utils::SYMBOL_TO_STATUS_CODE.keys.to_set.freeze
-        rescue LoadError, StandardError
+        rescue ::LoadError, ::StandardError
+          # `::`-qualified: in this lexical scope a bare `LoadError` resolves to `Rigor::Plugin::LoadError`
+          # (the plugin-loading error, a StandardError), so the real `::LoadError` (a ScriptError) from a
+          # failed require would escape instead of declining.
           @rack_status_symbols = nil
         end
       end

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_discoverer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 require_relative "worker_index"
@@ -67,7 +69,7 @@ module Rigor
           when Prism::ClassNode then visit_class(node, lexical_path, &)
           when Prism::ModuleNode then visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk_for_workers(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk_for_workers(child, lexical_path, &) }
           end
         end
 
@@ -133,7 +135,7 @@ module Rigor
         def lookup_perform_def(body)
           return nil if body.nil?
 
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::DefNode) && node.name == :perform
             next if node.receiver.is_a?(Prism::SelfNode)
 

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog_walker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 require_relative "method_signature"
@@ -58,7 +60,7 @@ module Rigor
             # A `def` not preceded by a `sig` is fine; we just don't record anything for it. The
             # interesting case is in `walk_statements`, which pairs sig+def.
           else
-            node.compact_child_nodes.each do |child|
+            node.rigor_each_child do |child|
               walk_node(child, state, lexical_path: lexical_path, in_singleton_class: in_singleton_class)
             end
           end