rigortype 0.3.8 → 0.4.0

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

@@ -163,6 +163,95 @@ class Object
   # exception to the try-shaped-dispatch rule above (design note § 11.2).
   %a{pure}
   def in?: (untyped) -> bool
+  # `in?(another_object) ? self : nil` — `params[:kind].presence_in(%w[a b])`.
+  # The same `#include?` dispatch as `in?`, and the same exception.
+  %a{pure}
+  def presence_in: (untyped) -> self?
+
+  # Issue #673 — `core_ext/object/to_query`, `core_ext/object/duplicable` and
+  # `core_ext/object/instance_variables` all hang off `Object`, so every
+  # RBS-known receiver reaches them; declaring them only on `Hash` (as
+  # `to_param` / `to_query` were) or only on `NilClass` (as `duplicable?` /
+  # `instance_values` were) left `"x".to_param`, `1.duplicable?` and friends a
+  # `call.undefined-method` on ordinary Rails code.
+  #
+  # `to_param` is `to_s`; `to_query(key)` interpolates two `CGI.escape` results.
+  # `key` is `untyped` because the body only calls `to_param` on it, and both
+  # `:name` and `"user[name]"` are ordinary call sites. Neither is `%a{pure}`:
+  # both dispatch `to_param` on a value whose own override is invisible here,
+  # the same reason `Hash#to_query` below carries no envelope.
+  def to_param: () -> String
+  def to_query: (untyped key) -> String
+
+  # `bool` and not `true`: `Object#duplicable?` answers true, but the
+  # `Singleton` (and, on a Ruby where methods are not duplicable, `Method` /
+  # `UnboundMethod`) overrides answer false. `-> true` on the universal
+  # receiver would make every `if x.duplicable?` an always-truthy branch —
+  # a false positive on the only shape anybody writes.
+  %a{pure}
+  def duplicable?: () -> bool
+
+  # Keys without the leading `@` for `instance_values`, with it for
+  # `instance_variable_names`.
+  def instance_values: () -> Hash[String, untyped]
+  def instance_variable_names: () -> Array[String]
+
+  # `core_ext/object/deep_dup` — `duplicable? ? dup : self`, plus `Array`
+  # (`map(&:deep_dup)`), `Hash` and `Module` overrides. `self` over-claims on
+  # an `Array` subclass, whose override answers a plain `Array`. Declared on
+  # `Object` and not only on `Hash`, where it sat alone: `[[1], [2]].deep_dup`
+  # is the common shape.
+  #
+  # NOT `%a{pure}`: on `Object` the `dup` runs the receiver class's own
+  # `initialize_copy`, an unknown-at-this-declaration dispatch like the one
+  # that keeps `as_json` bare. `Hash#deep_dup` below reaches the same `dup`
+  # through `value.deep_dup` on every value and is bare for the same reason.
+  def deep_dup: () -> self
+
+  # `core_ext/object/with` (ActiveSupport 7.1+) — sets each keyword through
+  # its public writer, yields `self`, and restores the old values in an
+  # `ensure`; the answer is the block's. There is no blockless form: `yield` without a block raises.
+  # ActiveSupport `undef_method`s it on `NilClass`, `TrueClass`, `FalseClass`,
+  # `Integer`, `Float` and `Symbol`, which RBS cannot express, so `1.with(a: 1)`
+  # resolves here where Ruby raises — a missed error, not a false one.
+  # `Data#with` (core) is a subclass override and keeps its own `-> self`.
+  #
+  # NOT `%a{pure}`: it writes the receiver's attributes through `public_send`.
+  def with: [T] (**untyped attributes) { (self) -> T } -> T
+
+  # `core_ext/object/with_options` — without a block, the
+  # `ActiveSupport::OptionMerger` proxy (not declared here); with one, the
+  # block's value. A zero-arity block is `instance_eval`ed on the proxy, the
+  # `with_options dependent: :destroy do has_many … end` model-body shape.
+  #
+  # NOT `%a{pure}`: the proxy forwards every call to the receiver through
+  # `method_missing`, a dispatch this audit cannot see.
+  def with_options: (untyped options) -> untyped
+                  | [T] (untyped options) { (?) -> T } -> T
+
+  # `core_ext/string/output_safety` — `false` on `Object`, `true` on
+  # `Numeric`, the buffer's own state on `ActiveSupport::SafeBuffer`. `bool`
+  # for the reason `duplicable?` is: `-> false` on the universal receiver makes
+  # every `if x.html_safe?` an always-falsy branch on the subclasses that answer
+  # true. All three bodies are a constant or an ivar read.
+  %a{pure}
+  def html_safe?: () -> bool
+end
+
+# ---------------------------------------------------------------
+# Kernel — `core_ext/kernel/singleton_class`
+# ---------------------------------------------------------------
+
+# `singleton_class.class_eval(*args, &block)` on any object. Declared on
+# `Kernel`, where ActiveSupport defines it; a `Module` receiver still answers
+# core `Module#class_eval`, which is its own alias of `module_eval`. The two
+# overloads mirror that `module_eval`: a string, or a block given the
+# singleton class.
+module Kernel
+  # NOT `%a{pure}`: it evaluates a string or a block in the singleton class,
+  # and a block that defines methods is the point.
+  def class_eval: (string code, ?string? filename, ?int lineno) -> untyped
+                | [U] () { (untyped singleton_class) -> U } -> U
 end
 
 # `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
@@ -185,6 +274,13 @@ class NilClass
   %a{pure}
   def duplicable?: () -> true
   def instance_values: () -> Hash[String, untyped]
+  # `core_ext/object/to_query` overrides `to_param` on the three singleton
+  # values to return `self` rather than `Object#to_param`'s `to_s`, so the
+  # `Object` row above would carry a wrong return here. `NilClass#to_query`
+  # is its own method (`CGI.escape(key.to_param)`), still a String.
+  %a{pure}
+  def to_param: () -> nil
+  def to_query: (untyped key) -> String
 end
 
 class TrueClass
@@ -192,6 +288,8 @@ class TrueClass
   def blank?: () -> false
   %a{pure}
   def present?: () -> true
+  %a{pure}
+  def to_param: () -> true
 end
 
 class FalseClass
@@ -199,6 +297,8 @@ class FalseClass
   def blank?: () -> true
   %a{pure}
   def present?: () -> false
+  %a{pure}
+  def to_param: () -> false
 end
 
 # ---------------------------------------------------------------
@@ -230,6 +330,8 @@ class String
   def dasherize: () -> String
   %a{pure}
   def upcase_first: () -> String
+  %a{pure}
+  def downcase_first: () -> String # ActiveSupport 7.1+
   # NOT %a{pure}: transliterates through `I18n.transliterate`, which reads
   # `I18n.locale` when `locale:` is left at its `nil` default — a request-
   # scoped global read the inflection-table assumption does not cover.
@@ -245,6 +347,11 @@ class String
   %a{pure}
   def humanize: (?capitalize: bool, ?keep_id_suffix: bool) -> String
 
+  # `core_ext/string/behavior` — the `acts_like?(:string)` duck-type hook, a
+  # hardcoded `true`.
+  %a{pure}
+  def acts_like_string?: () -> true
+
   # `core_ext/string/filters`
   %a{pure}
   def squish: () -> String
@@ -297,6 +404,15 @@ class String
   # follow-up to confirm and either implement or remove the declaration.
   def to_hours: () -> Float
 
+  # `core_ext/string/zones` — `Time.find_zone!(zone).parse(self)`, or
+  # `to_time` when no zone is set. `untyped` like the `Time` / `Date` rows:
+  # the parse answers an `ActiveSupport::TimeWithZone`, or `nil` on a string
+  # with no date parts. NOT `%a{pure}`: the default argument reads
+  # `Time.zone`, and `TimeZone#parse(str, now = now())` reads the clock on
+  # every call, whether or not the string names every part. The plugin's
+  # `effect_attributions:` carry both labels.
+  def in_time_zone: (?untyped zone) -> untyped
+
   # `core_ext/string/access`
   %a{pure}
   def at: (Integer | Range[Integer] | Regexp position) -> String?
@@ -316,12 +432,29 @@ class String
   # `core_ext/string/multibyte`
   %a{pure}
   def mb_chars: () -> untyped
+  # Reads `encoding` / `valid_encoding?`; the `ASCII-8BIT` branch
+  # `force_encoding`s a `dup`, never the receiver.
+  %a{pure}
+  def is_utf8?: () -> bool
 
   # `core_ext/string/inquiry`
   %a{pure}
   def inquiry: () -> untyped # ActiveSupport::StringInquirer
 end
 
+# ---------------------------------------------------------------
+# Symbol — `core_ext/symbol/starts_ends_with`
+# ---------------------------------------------------------------
+
+# `alias_method`s of core `start_with?` / `end_with?`, declared with the core
+# parameter lists.
+class Symbol
+  %a{pure}
+  def starts_with?: (*Regexp | string prefixes) -> bool
+  %a{pure}
+  def ends_with?: (*string suffixes) -> bool
+end
+
 # ---------------------------------------------------------------
 # Integer — `core_ext/integer/*`
 # ---------------------------------------------------------------
@@ -486,6 +619,22 @@ end
 # purpose — some are already covered by the separate `dynamic_return` rule for `+`/`-`/`*` below, the rest
 # are simply outside this issue's scope and remain silently `Dynamic` rather than a guess.
 module ActiveSupport
+  # Issue #534 item 7 — `ActiveSupport::Concern` was 87 unresolved constant sites on mastodon, essentially
+  # all of them the `extend ActiveSupport::Concern` line at the top of a concern module. Naming it is a
+  # constant-resolution fix and nothing more: the three members are declared because `extend`ing a module
+  # puts them on the extender's singleton, and leaving them out of a now-RBS-known module is what would
+  # turn `included do … end` into a false `call.undefined-method` in every concern in the project. The
+  # blocks are `(?) -> untyped` because their body is evaluated against the INCLUDING class, which this
+  # signature has no way to name.
+  #
+  # `Concern` is listed in the manifest's `open_receivers:` for the rest of its surface (`append_features`,
+  # `class_methods`' generated `ClassMethods` constant, …).
+  module Concern
+    def included: (?untyped base) ?{ (?) -> untyped } -> untyped
+    def prepended: (?untyped base) ?{ (?) -> untyped } -> untyped
+    def class_methods: () { (?) -> untyped } -> untyped
+  end
+
   class Duration
     # The `ago` family (issue #659). `since(time = ::Time.current)` and `ago(time = ::Time.current)` are
     # the only two real methods; `from_now` / `after` are `alias`es of the first and `until` / `before`
@@ -501,13 +650,17 @@ module ActiveSupport
     # help there: it protects a Duration receiver, and the diagnostic lands on the `Time` the call
     # RETURNS. #658 declared that surface and #670 the `Date` / `DateTime` twins, so the chains resolve.
     #
-    # `() -> Time` is the correct class, not a compromise. Under a zone these answer an
-    # `ActiveSupport::TimeWithZone` (verified by calling them), and Rails overrides `TimeWithZone#is_a?`
-    # to answer true for `::Time` — so `Time` is the class Rails ITSELF tells callers the value is, and
-    # `Time.current` above already answers `Time` for the same reason. A `Time | TimeWithZone` union was
-    # measured and rejected: it draws no `undefined-method`, but types every downstream call
-    # `Dynamic[top]` (`iso8601`, `beginning_of_day`, `to_date`, `- 1.day`), which is worth no more than
-    # leaving them undeclared while still firing a parameter mismatch on the TimeWithZone arm.
+    # `() -> TimeWithZone` since #673, where the class these actually build under a zone (verified by
+    # calling them) was finally declared — as a `::Time` SUBCLASS, so nothing a `Time` return bought is
+    # given up: every `Time` instance method still resolves on the result, every `Time`-typed parameter
+    # still accepts it, and the four TWZ-only readers (`time_zone`, `time`, `period`, `comparable_time`)
+    # stop being a false `call.undefined-method` on `1.hour.ago`. It was `() -> Time` before that, on the
+    # ground that Rails overrides `TimeWithZone#is_a?` to answer true for `::Time` — true, and the
+    # subclass is the same claim made where the analyser can also see the extra readers. A
+    # `Time | TimeWithZone` UNION was measured and rejected: it draws no `undefined-method`, but types
+    # every downstream call `Dynamic[top]` (`iso8601`, `beginning_of_day`, `to_date`, `- 1.day`), which is
+    # worth no more than leaving them undeclared while still firing a parameter mismatch on the
+    # TimeWithZone arm.
     #
     # The with-an-argument form stays `(untyped) -> untyped` on purpose, and this is not caution: the
     # runtime return depends on the argument's class AND on whether the duration carries a date-scale
@@ -520,17 +673,17 @@ module ActiveSupport
     # what stops `created_at > 7.days.ago` folding to a constant. They are already attributed `nondet.time`
     # in `lib/rigor/plugin/activesupport_core_ext/effects.rb` — annotating them here would duplicate an
     # envelope the manifest already owns, and risk the two disagreeing.
-    def ago: () -> Time
+    def ago: () -> TimeWithZone
            | (untyped time) -> untyped
-    def until: () -> Time
+    def until: () -> TimeWithZone
              | (untyped time) -> untyped
-    def before: () -> Time
+    def before: () -> TimeWithZone
               | (untyped time) -> untyped
-    def since: () -> Time
+    def since: () -> TimeWithZone
              | (untyped time) -> untyped
-    def from_now: () -> Time
+    def from_now: () -> TimeWithZone
                 | (untyped time) -> untyped
-    def after: () -> Time
+    def after: () -> TimeWithZone
              | (untyped time) -> untyped
 
     # `to_i` returns `@value.to_i` — always Integer, whether `@value` itself is Integer (`1.day`) or Float
@@ -574,6 +727,48 @@ module ActiveSupport
     %a{pure}
     def parts: () -> Hash[Symbol, Integer | Float]
   end
+
+  # ---------------------------------------------------------------
+  # ActiveSupport::TimeWithZone — issue #673
+  # ---------------------------------------------------------------
+  #
+  # `Time.current` and the `Duration#ago` family above really answer a `TimeWithZone` under a zone, and
+  # this class was not modelled at all, so the four readers a TWZ has and a `Time` does not —
+  # `time_zone`, `time`, `period`, `comparable_time` — were a false `call.undefined-method` on every
+  # `Time.current` receiver. Declaring them on `Time` instead would have been wrong: a plain `Time`
+  # genuinely lacks all four, and the diagnostic would stop firing where it is correct.
+  #
+  # `< ::Time` rather than a `Time | TimeWithZone` union at the producers. The union was measured during
+  # #632 and rejected — it types every downstream call `Dynamic[top]`. Inheritance is both cheaper and
+  # more honest: Rails overrides `TimeWithZone#is_a?` to answer true for `::Time`, so `Time` is the class
+  # Rails itself tells callers a TWZ is, and TWZ's `method_missing` forwards every name it does not
+  # define to the wrapped `::Time`, which is exactly what inheriting `Time`'s surface models. A TWZ
+  # therefore satisfies every `Time`-typed parameter, and chains keep resolving instead of collapsing.
+  #
+  # The cost, taken deliberately: `Time.current` answers a plain `Time` when `Time.zone` is nil, so
+  # `Time.current.time_zone` in a zone-less activesupport-only project is a real `NoMethodError` this
+  # now types. Rails sets `config.time_zone` ("UTC") by default, so the shape is rare, and the false
+  # positive it replaces fired on correct Rails code.
+  class TimeWithZone < ::Time
+    # `Time`'s own `initialize` takes the `(year, month, …)` parts; inheriting it would make
+    # `TimeWithZone.new(utc, zone)` — how Rails constructs one — a `call.argument-type-mismatch`.
+    # `untyped` because the zone and period carriers (`ActiveSupport::TimeZone`,
+    # `TZInfo::TimezonePeriod`) are not declared anywhere in this bundle.
+    def initialize: (untyped utc_time, untyped time_zone, ?untyped local_time, ?untyped period) -> void
+
+    # The `attr_reader`; an `ActiveSupport::TimeZone`, undeclared here.
+    %a{pure}
+    def time_zone: () -> untyped
+
+    # The wall-clock `::Time` in the zone. `utc` / `getutc` / `getgm` / `gmtime` are `Time`'s own names
+    # and stay inherited; `comparable_time` is the alias of `utc` that `Time` does not carry. Neither is
+    # `%a{pure}`: both memoise into an ivar on first call.
+    def time: () -> ::Time
+    def comparable_time: () -> ::Time
+
+    # A `TZInfo::TimezonePeriod`, undeclared here. Memoised like `time`, so not `%a{pure}`.
+    def period: () -> untyped
+  end
 end
 
 # ---------------------------------------------------------------
@@ -584,7 +779,11 @@ class Time
   # NOT %a{pure}: already attributed nondet.time/global.read/global.write
   # by `lib/rigor/plugin/activesupport_core_ext/effects.rb` (issue #387).
   # Duplicating an RBS envelope here risks the two disagreeing.
-  def self.current: () -> Time
+  #
+  # `Time.zone ? Time.zone.now : Time.now` — an `ActiveSupport::TimeWithZone` under a zone, which since
+  # #673 is declared as a `::Time` subclass so the four TWZ-only readers resolve without the rest of the
+  # chain losing its `Time` typing. See that class's own note for the zone-less cost.
+  def self.current: () -> ActiveSupport::TimeWithZone
   def self.zone: () -> untyped # ActiveSupport::TimeZone | nil
   def self.zone=: (String | Symbol | untyped) -> untyped
 
@@ -1264,6 +1463,10 @@ class Array[unchecked out Elem]
   def fifth: () -> Elem?
   %a{pure}
   def forty_two: () -> Elem?
+  %a{pure}
+  def second_to_last: () -> Elem?
+  %a{pure}
+  def third_to_last: () -> Elem?
 
   # `core_ext/array/grouping`
   %a{pure}
@@ -1295,6 +1498,9 @@ class Array[unchecked out Elem]
   # `core_ext/array/extract`
   def extract!: () { (Elem) -> bool } -> Array[Elem] # NOT %a{pure}: bang, mutates in place.
 
+  # `core_ext/array/extract_options`
+  def extract_options!: () -> Hash[untyped, untyped] # NOT %a{pure}: pops the trailing options Hash.
+
   # `core_ext/object/blank` / `core_ext/enumerable` — both
   # ActiveSupport additions, shipped on Array specifically.
   %a{pure}
@@ -1339,6 +1545,15 @@ module Enumerable[unchecked out Elem]
   def sole: () -> Elem
   %a{pure}
   def compact_blank: () -> Array[Elem]
+  %a{pure}
+  def many?: () -> bool
+           | () { (Elem) -> boolish } -> bool
+  # `key` and `series` are untyped on purpose: the default `filter: true`
+  # path is `group_by(&key).values_at(*series)`, so a Proc key or a Set /
+  # Range series is correct Rails code. `filter:` is ActiveSupport 8.x;
+  # passing it on 7.x raises, which this unversioned row does not catch.
+  %a{pure}
+  def in_order_of: (untyped key, untyped series, ?filter: boolish) -> Array[Elem]
 end
 
 # ---------------------------------------------------------------
@@ -1369,10 +1584,17 @@ class Hash[unchecked out K, unchecked out V]
   %a{pure}
   def deep_transform_values: () { (V) -> untyped } -> Hash[K, untyped]
   def deep_transform_values!: () { (V) -> untyped } -> self
+  # `alias_method`s of `symbolize_keys` / `symbolize_keys!`.
+  %a{pure}
+  def to_options: () -> Hash[Symbol, V]
+  def to_options!: () -> self
 
   # `core_ext/hash/deep_dup` — allocates a deep copy, never touches the
-  # receiver.
-  %a{pure}
+  # receiver. NOT `%a{pure}`: it calls `deep_dup` on every value, and on
+  # every key that is not a `String` or `Symbol` — an ELEMENT of unknown class
+  # whose `dup` runs that class's own `initialize_copy`. That is the dispatch
+  # the purity rule at the top of this file excludes, and the reason
+  # `Object#deep_dup` above is bare.
   def deep_dup: () -> Hash[K, V]
 
   # `core_ext/hash/deep_merge` — the block receives `(key, this_val,
@@ -1383,6 +1605,10 @@ class Hash[unchecked out K, unchecked out V]
                 | (Hash[K, V]) { (K, V, V) -> V } -> Hash[K, V]
   def deep_merge!: (Hash[K, V]) -> self
                  | (Hash[K, V]) { (K, V, V) -> V } -> self
+  # `other.is_a?(Hash)` — the hook `ActiveSupport::DeepMergeable` asks before
+  # recursing into a value. `:nodoc:`, but public.
+  %a{pure}
+  def deep_merge?: (untyped other) -> bool
 
   # `core_ext/hash/except` — `Hash#except` is in core RBS as of
   # Ruby 3.0+; `except!` is ActiveSupport-only. ActiveSupport
@@ -1407,6 +1633,9 @@ class Hash[unchecked out K, unchecked out V]
   # `%a{pure}` explicitly.
   %a{pure}
   def with_indifferent_access: () -> untyped
+  # An `alias` of `with_indifferent_access`.
+  %a{pure}
+  def nested_under_indifferent_access: () -> untyped
 
   # `core_ext/hash/conversions`
   def self.from_xml: (String, ?Symbol disallowed_types) -> Hash[String, untyped]
@@ -1417,15 +1646,57 @@ class Hash[unchecked out K, unchecked out V]
   def compact_blank: () -> Hash[K, V]
   def compact_blank!: () -> self # NOT %a{pure}: bang (`delete_if`), mutates in place.
 
-  # `core_ext/hash/reverse_merge`
+  # `core_ext/array/extract_options`
+  %a{pure}
+  def extractable_options?: () -> bool
+
+  # `core_ext/hash/reverse_merge` — `other_hash.merge(self)`, so the result
+  # carries the argument's keys and values as well as the receiver's, the
+  # same shape as core `Hash#merge`. `-> Hash[K, V]` typed
+  # `opts.reverse_merge(size: 25, velocity: 10)` as `Hash[:size, 1]`.
   %a{pure}
-  def reverse_merge: (Hash[K, V]) -> Hash[K, V]
+  def reverse_merge: [A, B] (Hash[A, B] other_hash) -> Hash[A | K, B | V]
   def reverse_merge!: (Hash[K, V]) -> self # NOT %a{pure}: bang (`replace`), mutates in place.
+  # `alias_method`s: `with_defaults` of `reverse_merge`, `with_defaults!`
+  # and `reverse_update` of `reverse_merge!`.
+  %a{pure}
+  def with_defaults: [A, B] (Hash[A, B] other_hash) -> Hash[A | K, B | V]
+  def with_defaults!: (Hash[K, V]) -> self # NOT %a{pure}: bang (`replace`), mutates in place.
+  def reverse_update: (Hash[K, V]) -> self # NOT %a{pure}: `reverse_merge!` under another name.
 
   # `core_ext/hash/slice` — `Hash#except` is in core RBS (Ruby 3.0+);
   # `Hash#slice` is in core RBS (Ruby 2.5+); the bang variants are
-  # ActiveSupport-only.
+  # ActiveSupport-only. `extract!` deletes the named keys and answers them
+  # as a new hash; a key the receiver lacks is skipped, not `nil`-filled.
   def slice!: (*K) -> Hash[K, V] # NOT %a{pure}: bang (`replace`), mutates in place.
+  def extract!: (*K) -> Hash[K, V] # NOT %a{pure}: bang, mutates via `delete`.
+end
+
+# ---------------------------------------------------------------
+# Range — `core_ext/range/*`
+# ---------------------------------------------------------------
+
+# `[out E]` matches core `range.rbs`. A reopening whose parameters differ in
+# count or variance (`class Range`, `class Range[E]`) raises
+# `RBS::GenericParameterMismatchError` and collapses `Range`.
+class Range[out E]
+  # `core_ext/range/overlap` — an `alias` of `overlap?`, which rbs declares
+  # since Ruby 3.3 (ActiveSupport defines the method itself only on an older
+  # Ruby). `overlap?` is therefore NOT redeclared here: a second declaration
+  # is a `DuplicatedMethodDefinitionError` that collapses the whole class.
+  %a{pure}
+  def overlaps?: (Range[untyped]) -> bool
+
+  # `core_ext/range/conversions` — `ActiveSupport::RangeWithFormat`, prepended
+  # onto `Range`. An unknown format falls back to `to_s`; `:db` answers `nil`
+  # for a beginless-and-endless range, which the declared `String` does not
+  # model — `(nil..nil).to_fs(:db)` is not a shape correct code writes.
+  #
+  # NOT `%a{pure}`, for the `Array#to_fs` reasons: `RANGE_FORMATS` is a
+  # mutable constant an initializer extends, and `:db` calls `to_fs(:db)` on
+  # both endpoints.
+  def to_fs: (?Symbol format) -> String
+  def to_formatted_s: (?Symbol format) -> String
 end
 
 # ---------------------------------------------------------------

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

@@ -60,6 +60,7 @@ module Rigor
     class Devise < Rigor::Plugin::Base
       manifest(
         id: "devise",
+        target_gems: ["devise"],
         version: "0.1.0",
         description: "Recognises Devise's `devise :strategy` DSL via ADR-16 Tier B.",
         trait_registries: [

data/plugins/rigor-dry-monads/lib/rigor/plugin/dry_monads.rb

@@ -30,6 +30,7 @@ module Rigor
         source_path: __FILE__,
         source_line: __LINE__
       )
+      Ractor.make_shareable(RESULT_DEFINITION)
 
       MAYBE_DEFINITION = Inference::HktRegistry.definition_with_body_tree(
         uri: :"dry_monads::maybe",
@@ -38,12 +39,14 @@ module Rigor
         source_path: __FILE__,
         source_line: __LINE__
       )
+      Ractor.make_shareable(MAYBE_DEFINITION)
 
       CONSTRUCTOR_METHODS = %i[Success Failure Some None].freeze
       UNWRAP_METHODS = %i[value! failure value_or].freeze
 
       manifest(
         id: "dry-monads",
+        target_gems: ["dry-monads"],
         version: "0.1.0",
         description: "Lightweight HKT support for dry-monads Result and Maybe carriers",
         hkt_registrations: [RESULT_REGISTRATION, MAYBE_REGISTRATION],

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

@@ -40,24 +40,26 @@ 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
+        # @param paths — absolute paths to `.rb` files the project's `paths:` resolves to.
+        # @param io_boundary — the plugin's {Rigor::Plugin::IoBoundary}; every source read goes
+        #   through it (#630) so each scanned file is a recorded cache dependency.
+        # @param type_aliases — 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
+        # @return frozen per-schema typed-key
         #   table. Empty when no recognisable schema declaration is found.
-        def scan(paths:, type_aliases: {})
+        def scan(paths:, io_boundary:, type_aliases: {})
           table = {}
           paths.each do |path|
-            scan_file(path, type_aliases).each do |schema_const, shape|
+            scan_file(path, io_boundary, type_aliases).each do |schema_const, shape|
               table[schema_const] ||= shape
             end
           end
           table.freeze
         end
 
-        def scan_file(path, type_aliases)
-          source = File.read(path)
+        def scan_file(path, io_boundary, type_aliases)
+          source = io_boundary.read_file(path)
           parse_result = Prism.parse(source, filepath: path)
           return {} unless parse_result.errors.empty?
 

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

@@ -78,6 +78,7 @@ module Rigor
     class DrySchema < Rigor::Plugin::Base
       manifest(
         id: "dry-schema",
+        target_gems: ["dry-schema"],
         version: "0.1.0",
         description: "Recognises `Dry::Schema.{Params,JSON,define} { ... }` declarations " \
                      "and publishes the per-schema typed-key table.",
@@ -130,7 +131,8 @@ module Rigor
       # `paths:`, parse errors degrade silently.
       def prepare(services)
         type_aliases = services.fact_store.read(plugin_id: "dry-types", name: :dry_type_aliases) || {}
-        table = SchemaScanner.scan(paths: scannable_paths(services), type_aliases: type_aliases)
+        table = SchemaScanner.scan(paths: scannable_paths(services), io_boundary: io_boundary,
+                                   type_aliases: type_aliases)
         return if table.empty?
 
         services.fact_store.publish(
@@ -164,11 +166,13 @@ module Rigor
         shapes[name] = entry.nil? ? nil : ResultShape.build(entry)
       end
 
+      # 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.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
-          if File.directory?(entry)
+          if io_boundary.directory?(entry)
             Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
-          elsif File.file?(entry) && entry.end_with?(".rb")
+          elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else
             []

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

@@ -51,6 +51,7 @@ module Rigor
     class DryStruct < Rigor::Plugin::Base
       manifest(
         id: "dry-struct",
+        target_gems: ["dry-struct"],
         version: "0.2.0",
         description: "Recognises dry-struct `attribute :name, T` DSL via ADR-16 Tier C; " \
                      "promotes the reader's return type through ADR-18's `returns_from_arg:` " \

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

@@ -42,11 +42,13 @@ module Rigor
 
         module_function
 
-        # @param paths [Array<String>] absolute paths to `.rb` files the project's `paths:` resolves to.
-        # @return [Hash{String => String}] frozen `{aliased_name => underlying_class_name}` map. Empty
+        # @param paths — absolute paths to `.rb` files the project's `paths:` resolves to.
+        # @param io_boundary — the plugin's {Rigor::Plugin::IoBoundary}; every source read goes
+        #   through it (#630) so each scanned file is a recorded cache dependency.
+        # @return frozen `{aliased_name => underlying_class_name}` map. Empty
         #   when no `include Dry.Types()` declaration is found.
-        def scan(paths:)
-          results = paths.flat_map { |path| scan_file(path) }
+        def scan(paths:, io_boundary:)
+          results = paths.flat_map { |path| scan_file(path, io_boundary) }
           modules = results.map { |r| r[:module_name] }.uniq
           return {}.freeze if modules.empty?
 
@@ -75,8 +77,8 @@ module Rigor
         end
         private_class_method :canonical_table
 
-        def scan_file(path)
-          source = File.read(path)
+        def scan_file(path, io_boundary)
+          source = io_boundary.read_file(path)
           parse_result = Prism.parse(source, filepath: path)
           return [] unless parse_result.errors.empty?
 

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

@@ -58,6 +58,7 @@ module Rigor
     class DryTypes < Rigor::Plugin::Base
       manifest(
         id: "dry-types",
+        target_gems: ["dry-types"],
         version: "0.1.0",
         description: "Recognises `module X; include Dry.Types(); end` and publishes the alias table.",
         produces: [:dry_type_aliases]
@@ -74,10 +75,11 @@ module Rigor
       # `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.
+      # invalidate the entry. Since #630 the scan ALSO reads each file through the `IoBoundary`, so the
+      # descriptor carries a per-file row beside the globs: the globs alone already covered the scan's
+      # input, and the per-file rows are what a subset or incremental run has to invalidate on.
       producer :dry_type_aliases, watch: -> { alias_watch_globs } do |_params|
-        AliasScanner.scan(paths: scannable_paths)
+        AliasScanner.scan(paths: scannable_paths, io_boundary: io_boundary)
       end
 
       # Builds the (cached) alias table and publishes it via the ADR-9 fact store. `producer_value` runs the
@@ -102,11 +104,13 @@ 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.
+      # 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.
       def scannable_paths
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
-          if File.directory?(entry)
+          if io_boundary.directory?(entry)
             Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
-          elsif File.file?(entry) && entry.end_with?(".rb")
+          elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else
             []
@@ -122,9 +126,9 @@ module Rigor
       # 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)
+          if io_boundary.directory?(entry)
             [entry, "**/*.rb"]
-          elsif File.file?(entry) && entry.end_with?(".rb")
+          elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [File.dirname(entry), File.basename(entry)]
           end
         end