rigortype 0.1.19 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e2fede9ea7407238b1f9c8f5784cc43f22724ee86decdf81f4a148c4ddff763
-  data.tar.gz: 57e9757b838f29185d9b936ddff586d372126540afe12cefb1e98dbc7e0a6109
+  metadata.gz: 11db7e9c0140dbb303b0644587e80cc683e5a9ee32791c007234dd12e37ecb21
+  data.tar.gz: 375cbd7387b2f8cac6d668db993b34e627d19ebacf74e5092c17c8717191b401
 SHA512:
-  metadata.gz: 33b889562fefed7516dec175b7d85cc9f725ebcc7d94df30b5a58a436322709517a02bda2a0de10d746004c8c2d198aaa673f12577ddfe3ffeb37405508e1d9c
-  data.tar.gz: f5773b727c0fb718df1ab1163add87f0dd7e94913fefd0599e7465e5a40afbfa201b2b14a09eb524b2e98dc6e30bd84ab0424355802ded977386f5a706d84837
+  metadata.gz: 42a9121e67acbf27afc287c586c7b3cd9fbd271a0de9e0a7f28a1e57703ffb578572213402e37f57b7327572c944f799a186ccc0a13dbe1fba49eca02c39df6b
+  data.tar.gz: d5b333586309d0b25b17880608797e005a2083bad60d91e2a20163265cb31b948a08363ef4f37920862dc7ee5da3fb0cd1d7c67a7af6f64b1bc37d8721469f6c

data/README.md

@@ -204,12 +204,15 @@ the reference companions.
 
 ## Status
 
-Current release: **`v0.1.18`** (2026-06-11), with `v0.2.0` — the first
-evaluation release — landing shortly. Rigor analyses real Ruby today:
-the `0.1.x` line has been hardened against Mastodon, Redmine, and
-GitLab FOSS, and the deliberately conservative rule catalogue grows
-only as fast as the zero-false-positive bar allows. Release history:
-[`CHANGELOG.md`](CHANGELOG.md) · forward-looking commitments:
+Current release: **`v0.2.0`** (2026-06-17) — the first
+publicly-announced (general / evaluation) release. It publishes an
+enumerated [compatibility surface](docs/compatibility.md) as a
+minor-non-break trial, rehearsing the contract that hard-freezes at
+`v1.0.0`. Rigor analyses real Ruby today: it has been hardened against
+Mastodon, Redmine, and GitLab FOSS, and the deliberately conservative
+rule catalogue grows only as fast as the zero-false-positive bar
+allows. Release history: [`CHANGELOG.md`](CHANGELOG.md) ·
+forward-looking commitments:
 [Roadmap](https://rigor.typedduck.fail/reference/roadmap/).
 
 ## Contributing
@@ -221,3 +224,35 @@ contributors should read.
 ## License
 
 Mozilla Public License Version 2.0. See [`LICENSE`](LICENSE).
+
+## Sponsors
+
+Rigor is built and maintained by one person, who has spent the better
+part of the last month — nearly every spare hour of personal time — on
+this project. Sustainable development depends on sustainable funding.
+
+**The current monthly budget is well short of the $200 minimum needed
+to keep this pace going; $600 or more would let me work on it
+properly.** If Rigor is saving you time or catching real bugs, please
+consider contributing:
+
+- **GitHub Sponsors**: [github.com/sponsors/zonuexe](https://github.com/sponsors/zonuexe)
+- **FANBOX** (credit-card / PayPal): [tadsan.fanbox.cc](https://tadsan.fanbox.cc/)
+
+**For individuals** — any amount is welcome and genuinely appreciated.
+Even a small recurring pledge (think of it as buying me one coffee a
+month) makes a difference when it adds up across many users.
+
+**For companies** using Rigor in production — please consider a
+contribution that reflects the engineering hours Rigor is saving you.
+A modest business sponsorship goes a long way toward keeping this
+project alive and actively maintained.
+
+**Sponsors at $50/month or more** are listed here with a banner.
+*(This threshold will likely move to $100/month at some point — early
+sponsors lock in the lower bar.)*
+
+To the sponsors who have already contributed: **thank you sincerely.**
+Your support makes the difference between a project that stalls and
+one that ships.
+

data/data/core_overlay/numeric.rbs

@@ -0,0 +1,33 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# This directory holds Rigor-owned reopenings of Ruby core classes that
+# add methods upstream `ruby/rbs` does not declare on a class but which
+# every concrete value of that class answers at runtime. It is loaded
+# LAST into the RBS environment (after core + stdlib + vendored gem
+# sigs), so an upstream declaration always wins on conflict — these
+# entries only fill genuine holes.
+#
+# Provenance: hand-authored against the documented CRuby behaviour, not
+# extracted. Keep each addition justified by an observed false positive.
+#
+# --- Numeric coercion methods ---
+#
+# `ruby/rbs`'s `Numeric` declares only `to_c` and `to_int`; the three
+# value-coercion selectors `to_f` / `to_i` / `to_r` are declared solely
+# on the concrete subclasses (`Integer`, `Float`, `Rational`, `Complex`).
+# But Rigor routinely *widens* an arithmetic chain to the abstract
+# `Numeric` nominal — `Complex#abs -> Numeric`, or an overload join over
+# `Integer | Float` — and the instant a widened value is asked for
+# `.to_f`, dispatch misses and `call.undefined-method` fires on plain,
+# correct arithmetic (observed four times across actionview's
+# `date_helper`: `(distance_in_minutes.to_f / 60.0)`).
+#
+# Every concrete `Numeric` responds to all three, so the widening must
+# not strip the capability. Returns mirror the concrete subclass
+# signatures. `to_int` is already upstream and intentionally not
+# duplicated here.
+class Numeric
+  def to_f: () -> Float
+  def to_i: () -> Integer
+  def to_r: () -> Rational
+end

data/data/core_overlay/pathname.rbs

@@ -0,0 +1,25 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- Pathname#expand_path ---
+#
+# Upstream `ruby/rbs` declares `Pathname#expand_path` as:
+#
+#   def expand_path: (?String dir) -> Pathname
+#
+# But `Pathname#expand_path` delegates to `File.expand_path`, whose `dir`
+# parameter is typed as `path` (= `string | _ToPath`). Passing a `Pathname`
+# as the base directory is the idiomatic Bundler pattern:
+#
+#   Pathname.new(path).expand_path(Bundler.root)   # root → Pathname
+#
+# With the ADR-57 self-call adoption gate now resolving `Bundler.root` to
+# `Pathname`, all five call sites in bundler.rb / bundler/source/git.rb fire
+# `argument type mismatch at parameter 'dir'`.  The upstream sig is simply
+# under-typed: the runtime accepts any `to_path`-bearing object.
+#
+# The overlay widens `dir` to `String | Pathname`, matching the runtime
+# delegation and the `File.expand_path` `path` alias used elsewhere in RBS.
+class Pathname
+  def expand_path: (?String | Pathname dir) -> Pathname
+                 | ...
+end

data/data/core_overlay/string_scanner.rbs

@@ -0,0 +1,28 @@
+# Rigor core overlay — supplemental core signatures.
+#
+# --- StringScanner#[] ---
+#
+# The pinned `rbs` gem (4.0.2) declares `StringScanner#[]` as only:
+#
+#   def []: (Integer) -> String?
+#
+# But `StringScanner#[]` also accepts a capture-group *name* — a `String`
+# or `Symbol` — and returns the named capture from the most recent match.
+# Named-capture access (`scanner[:key]`) is the idiomatic form when the
+# scan pattern uses named groups:
+#
+#   scanner.skip(/(?<key>\w+)=/)
+#   scanner[:key]   # => the captured String, or nil
+#
+# Newer `ruby/rbs` already widens the signature to
+# `(Integer | String | Symbol) -> String?`; the pinned 4.0.2 gem lags.
+# Without the wider overload, a named-capture access such as Mastodon's
+# `scanner[:key]` false-fires `call.argument-type-mismatch` (the lone
+# overload rejects a `Symbol`).
+#
+# The overlay supplies the runtime-accurate overload; drop it once the
+# pinned `rbs` gem carries the wider signature.
+class StringScanner
+  def []: (Integer | String | Symbol) -> String?
+        | ...
+end

data/data/gem_overlay/activesupport/core_ext.rbs

@@ -0,0 +1,473 @@
+# ActiveSupport core_ext — Gemfile.lock-gated bundled RBS overlay (ADR-72).
+#
+# Rigor loads this overlay AUTOMATICALLY when `activesupport` is locked
+# in the project's Gemfile.lock but ships no RBS through any resolution
+# path (the `:missing` coverage class — no `rbs collection`, no bundled
+# `sig/`, not a default library). It turns the systematic false
+# `call.undefined-method` on Rails core-ext call sites (`3.minutes`,
+# `"x".underscore`, `hash.symbolize_keys`, …) into a no-op, while a
+# project WITHOUT activesupport still sees the genuine diagnostic.
+#
+# This is the auto-applied twin of the opt-in, hand-curated
+# `rigor-activesupport-core-ext` plugin (`plugins/rigor-activesupport-
+# core-ext/sig/active_support/core_ext.rbs`). The two files carry the
+# same surface on purpose; the plugin remains the authoring home and
+# may grow more exhaustive, and when its plugin id is loaded this
+# overlay stands down (Environment.for_project) to avoid a duplicate
+# declaration. Keep the two in sync when extending coverage.
+#
+# Scope: the most-frequently-flagged ActiveSupport extension methods
+# from a four-project Rails survey (Redmine, Discourse, Mastodon,
+# GitLab FOSS — see `docs/notes/20260515-real-world-rails-survey.md`),
+# roughly the top ~40 selectors by `call.undefined-method` frequency.
+# Not exhaustive.
+
+# ---------------------------------------------------------------
+# Object — universal predicates and helpers
+# ---------------------------------------------------------------
+
+class Object
+  # @return [bool]
+  def blank?: () -> bool
+
+  # @return [bool]
+  def present?: () -> bool
+
+  # @return [self?]
+  def presence: () -> self?
+
+  # `active_support/core_ext/object/json` monkey-patches
+  # `as_json` onto Object (default returns the object's
+  # `instance_values` hash) plus per-class overrides on
+  # NilClass / TrueClass / FalseClass / Numeric / String /
+  # Symbol / Time / Date / Array / Hash / Range / Regexp /
+  # Struct / Enumerable. Most call-site code uses the
+  # universal `obj.as_json` shape so a single Object row
+  # restores type coverage at the Mastodon-derived
+  # `as_json` call sites (`fan_out_on_write_service.rb`,
+  # `push_update_worker.rb`, `media_component_helper.rb`).
+  # `options` is the standard `only:` / `except:` / `methods:`
+  # / `include:` hash — left as untyped because the surface
+  # is large and per-call-site precision is rarely useful.
+  def as_json: (?untyped options) -> untyped
+
+  # `try` swallows NoMethodError; declared return is `untyped`
+  # because the called method's signature is not known to RBS
+  # at this call site.
+  def try: (Symbol | String) -> untyped
+         | (Symbol | String, *untyped) -> untyped
+         | (Symbol | String, *untyped) { (?) -> untyped } -> untyped
+
+  def try!: (Symbol | String) -> untyped
+          | (Symbol | String, *untyped) -> untyped
+          | (Symbol | String, *untyped) { (?) -> untyped } -> untyped
+
+  # `acts_like?(:string)` / `acts_like?(:date)` / `acts_like?(:time)`
+  # is ActiveSupport's "duck-typing helper" predicate.
+  def acts_like?: (Symbol | String) -> bool
+end
+
+# `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
+# call sites the survey turned up.
+class NilClass
+  def blank?: () -> true
+  def present?: () -> false
+  def presence: () -> nil
+  def try: (*untyped) -> nil
+  def try!: (*untyped) -> nil
+end
+
+class TrueClass
+  def blank?: () -> false
+  def present?: () -> true
+end
+
+class FalseClass
+  def blank?: () -> true
+  def present?: () -> false
+end
+
+# ---------------------------------------------------------------
+# String — ActiveSupport `core_ext/string/*`
+# ---------------------------------------------------------------
+
+class String
+  # `core_ext/string/inflections`
+  def underscore: () -> String
+  def camelize: (?Symbol upper_case_first) -> String
+  def camelcase: (?Symbol upper_case_first) -> String
+  def classify: () -> String
+  def constantize: () -> untyped
+  def safe_constantize: () -> untyped
+  def demodulize: () -> String
+  def deconstantize: () -> String
+  def titleize: () -> String
+  def parameterize: (?separator: String, ?preserve_case: bool, ?locale: Symbol?) -> String
+  def tableize: () -> String
+  def foreign_key: (?bool separate_class_name_and_id_with_underscore) -> String
+  def pluralize: (?Integer count, ?Symbol locale) -> String
+  def singularize: (?Symbol locale) -> String
+  def humanize: (?capitalize: bool, ?keep_id_suffix: bool) -> String
+
+  # `core_ext/string/filters`
+  def squish: () -> String
+  def squish!: () -> String
+  def truncate: (Integer truncate_at, ?omission: String, ?separator: String | Regexp | nil) -> String
+  def truncate_bytes: (Integer truncate_at, ?omission: String) -> String
+  def truncate_words: (Integer words_count, ?omission: String, ?separator: String | Regexp | nil) -> String
+
+  # `core_ext/string/output_safety` — `html_safe` returns an
+  # `ActiveSupport::SafeBuffer` (a String subclass). The closest
+  # RBS-canonical carrier is plain `String`; precision lost is the
+  # `html_safe?` predicate value.
+  def html_safe: () -> String
+  def html_safe?: () -> bool
+
+  # `core_ext/string/indent`
+  def indent: (Integer amount, ?String indent_string, ?bool indent_empty_lines) -> String
+  def indent!: (Integer amount, ?String indent_string, ?bool indent_empty_lines) -> String?
+
+  # `core_ext/string/starts_ends_with` — also covered by core
+  # `start_with?` / `end_with?`; these are the ActiveSupport aliases.
+  def starts_with?: (*String prefixes) -> bool
+  def ends_with?: (*String suffixes) -> bool
+
+  # `core_ext/string/conversions` — `to_time` / `to_date` /
+  # `to_datetime` return Time / Date / DateTime.
+  def to_time: (?Symbol form) -> Time?
+  def to_date: () -> Date?
+  def to_datetime: () -> DateTime
+  def to_hours: () -> Float
+
+  # `core_ext/string/access`
+  def at: (Integer | Range[Integer] | Regexp position) -> String?
+  def from: (Integer position) -> String
+  def to: (Integer position) -> String
+  def first: (?Integer limit) -> String
+  def last: (?Integer limit) -> String
+
+  # `core_ext/string/strip` — leading-blank strip with shared margin.
+  def strip_heredoc: () -> String
+
+  # `core_ext/string/multibyte`
+  def mb_chars: () -> untyped
+
+  # `core_ext/string/inquiry`
+  def inquiry: () -> untyped # ActiveSupport::StringInquirer
+
+  # `core_ext/string/exclude` (an ActiveSupport addition)
+  def exclude?: (String) -> bool
+end
+
+# ---------------------------------------------------------------
+# Integer — `core_ext/integer/*`
+# ---------------------------------------------------------------
+
+class Integer
+  # `core_ext/numeric/time` — Duration multipliers.
+  def second: () -> untyped # ActiveSupport::Duration
+  def seconds: () -> untyped
+  def minute: () -> untyped
+  def minutes: () -> untyped
+  def hour: () -> untyped
+  def hours: () -> untyped
+  def day: () -> untyped
+  def days: () -> untyped
+  def week: () -> untyped
+  def weeks: () -> untyped
+  def fortnight: () -> untyped
+  def fortnights: () -> untyped
+  def month: () -> untyped
+  def months: () -> untyped
+  def year: () -> untyped
+  def years: () -> untyped
+
+  # `core_ext/numeric/bytes`
+  def byte: () -> Integer
+  def bytes: () -> Integer
+  def kilobyte: () -> Integer
+  def kilobytes: () -> Integer
+  def megabyte: () -> Integer
+  def megabytes: () -> Integer
+  def gigabyte: () -> Integer
+  def gigabytes: () -> Integer
+  def terabyte: () -> Integer
+  def terabytes: () -> Integer
+  def petabyte: () -> Integer
+  def petabytes: () -> Integer
+  def exabyte: () -> Integer
+  def exabytes: () -> Integer
+
+  # `core_ext/integer/multiple`
+  def multiple_of?: (Integer) -> bool
+
+  # `core_ext/integer/inflections`
+  def ordinal: () -> String
+  def ordinalize: () -> String
+end
+
+# ---------------------------------------------------------------
+# Float — same Duration / Bytes pattern as Integer
+# ---------------------------------------------------------------
+
+class Float
+  def second: () -> untyped
+  def seconds: () -> untyped
+  def minute: () -> untyped
+  def minutes: () -> untyped
+  def hour: () -> untyped
+  def hours: () -> untyped
+  def day: () -> untyped
+  def days: () -> untyped
+  def week: () -> untyped
+  def weeks: () -> untyped
+  def month: () -> untyped
+  def months: () -> untyped
+  def year: () -> untyped
+  def years: () -> untyped
+
+  def byte: () -> Float
+  def bytes: () -> Float
+  def kilobyte: () -> Float
+  def kilobytes: () -> Float
+  def megabyte: () -> Float
+  def megabytes: () -> Float
+  def gigabyte: () -> Float
+  def gigabytes: () -> Float
+end
+
+# ---------------------------------------------------------------
+# Time — singleton + instance extensions
+# ---------------------------------------------------------------
+
+class Time
+  def self.current: () -> Time
+  def self.zone: () -> untyped # ActiveSupport::TimeZone | nil
+  def self.zone=: (String | Symbol | untyped) -> untyped
+
+  # `core_ext/time/conversions` — also `Time.parse` from stdlib
+  # `time`, which is already in core RBS.
+  def self.httpdate: (String) -> Time
+  def self.iso8601: (String) -> Time
+
+  # `core_ext/time/calculations`
+  def yesterday: () -> Time
+  def tomorrow: () -> Time
+  def beginning_of_day: () -> Time
+  def end_of_day: () -> Time
+  def beginning_of_hour: () -> Time
+  def end_of_hour: () -> Time
+  def beginning_of_minute: () -> Time
+  def end_of_minute: () -> Time
+  def beginning_of_week: (?Symbol start_day) -> Time
+  def end_of_week: (?Symbol start_day) -> Time
+  def beginning_of_month: () -> Time
+  def end_of_month: () -> Time
+  def beginning_of_year: () -> Time
+  def end_of_year: () -> Time
+  def ago: (Numeric seconds) -> Time
+  def since: (Numeric seconds) -> Time
+  def in: (Numeric seconds) -> Time
+  def change: (**untyped) -> Time
+  def at_beginning_of_day: () -> Time
+  def at_end_of_day: () -> Time
+  def at_beginning_of_week: () -> Time
+  def at_end_of_week: () -> Time
+  def at_midnight: () -> Time
+  def at_noon: () -> Time
+  def midday: () -> Time
+  def midnight: () -> Time
+  def noon: () -> Time
+  def utc?: () -> bool
+  def acts_like_time?: () -> true
+end
+
+# ---------------------------------------------------------------
+# Date — `core_ext/date/*`
+# ---------------------------------------------------------------
+
+class Date
+  def self.current: () -> Date
+  def self.yesterday: () -> Date
+  def self.tomorrow: () -> Date
+  def self.beginning_of_week: () -> Date
+  def self.end_of_week: () -> Date
+  def self.beginning_of_month: () -> Date
+  def self.end_of_month: () -> Date
+  def self.beginning_of_year: () -> Date
+  def self.end_of_year: () -> Date
+
+  def yesterday: () -> Date
+  def tomorrow: () -> Date
+  def beginning_of_week: (?Symbol start_day) -> Date
+  def end_of_week: (?Symbol start_day) -> Date
+  def beginning_of_month: () -> Date
+  def end_of_month: () -> Date
+  def beginning_of_year: () -> Date
+  def end_of_year: () -> Date
+  def ago: (Numeric seconds) -> Time
+  def since: (Numeric seconds) -> Time
+  def acts_like_date?: () -> true
+
+  # `core_ext/date/calculations` — `Date#midnight` /
+  # `Date#at_midnight` are aliases for `beginning_of_day`.
+  # Rails' `beginning_of_day` on Date returns a Time at
+  # midnight of that day (not a Date). Mastodon's
+  # `Date.current.at_midnight` shape relies on this.
+  def beginning_of_day: () -> Time
+  def midnight: () -> Time
+  def at_midnight: () -> Time
+  def at_beginning_of_day: () -> Time
+  def end_of_day: () -> Time
+  def at_end_of_day: () -> Time
+end
+
+# ---------------------------------------------------------------
+# Array — singleton wrapper + instance extensions
+# ---------------------------------------------------------------
+
+class Array[unchecked out Elem]
+  # `Array.wrap(x)` is the dominant Rails idiom: `nil → []`,
+  # `Array x → x`, `else → [x]`.
+  def self.wrap: (untyped) -> Array[untyped]
+
+  # `core_ext/array/access`
+  def from: (Integer position) -> Array[Elem]
+  def to: (Integer position) -> Array[Elem]
+  def second: () -> Elem?
+  def third: () -> Elem?
+  def fourth: () -> Elem?
+  def fifth: () -> Elem?
+  def forty_two: () -> Elem?
+
+  # `core_ext/array/grouping`
+  def in_groups_of: (Integer number, ?untyped fill_with) -> Array[Array[Elem]]
+                  | (Integer number, ?untyped fill_with) { (Array[Elem]) -> void } -> Array[Elem]
+  def in_groups: (Integer number, ?untyped fill_with) -> Array[Array[Elem]]
+               | (Integer number, ?untyped fill_with) { (Array[Elem]) -> void } -> Array[Elem]
+  def split: (?untyped value) -> Array[Array[Elem]]
+           | () { (Elem) -> bool } -> Array[Array[Elem]]
+
+  # `core_ext/array/conversions`
+  def to_sentence: (?two_words_connector: String, ?last_word_connector: String, ?words_connector: String, ?locale: Symbol?) -> String
+  def to_formatted_s: (?Symbol format) -> String
+  def to_fs: (?Symbol format) -> String
+  def to_xml: (**untyped) -> String
+
+  # `core_ext/array/inquiry`
+  def inquiry: () -> untyped # ActiveSupport::ArrayInquirer
+
+  # `core_ext/array/extract`
+  def extract!: () { (Elem) -> bool } -> Array[Elem]
+
+  # `core_ext/object/blank` / `core_ext/enumerable` — both
+  # ActiveSupport additions, shipped on Array specifically.
+  def compact_blank: () -> Array[Elem]
+  def compact_blank!: () -> self
+  def exclude?: (Elem) -> bool
+end
+
+# ---------------------------------------------------------------
+# Enumerable — `core_ext/enumerable`
+# ---------------------------------------------------------------
+
+module Enumerable[unchecked out Elem]
+  def index_by: () { (Elem) -> untyped } -> Hash[untyped, Elem]
+  def index_with: (?untyped default) { (Elem) -> untyped } -> Hash[Elem, untyped]
+                | (untyped default) -> Hash[Elem, untyped]
+  def exclude?: (Elem) -> bool
+  def including: (*Elem) -> Array[Elem]
+  def excluding: (*Elem) -> Array[Elem]
+  def without: (*Elem) -> Array[Elem]
+  def pluck: (Symbol | String) -> Array[untyped]
+           | (*Symbol | String) -> Array[Array[untyped]]
+  def pick: (Symbol | String) -> untyped
+          | (*Symbol | String) -> Array[untyped]?
+  def maximum: (Symbol | String) -> untyped
+  def minimum: (Symbol | String) -> untyped
+  def sole: () -> Elem
+  def compact_blank: () -> Array[Elem]
+end
+
+# ---------------------------------------------------------------
+# Hash — `core_ext/hash/*`
+# ---------------------------------------------------------------
+
+class Hash[unchecked out K, unchecked out V]
+  # `core_ext/hash/keys`
+  def symbolize_keys: () -> Hash[Symbol, V]
+  def symbolize_keys!: () -> self
+  def deep_symbolize_keys: () -> Hash[untyped, untyped]
+  def deep_symbolize_keys!: () -> self
+  def stringify_keys: () -> Hash[String, V]
+  def stringify_keys!: () -> self
+  def deep_stringify_keys: () -> Hash[untyped, untyped]
+  def deep_stringify_keys!: () -> self
+  def assert_valid_keys: (*K | Array[K]) -> self
+  def deep_transform_keys: () { (K) -> K } -> Hash[K, untyped]
+  def deep_transform_keys!: () { (K) -> K } -> self
+  def deep_transform_values: () { (V) -> untyped } -> Hash[K, untyped]
+  def deep_transform_values!: () { (V) -> untyped } -> self
+
+  # `core_ext/hash/deep_dup`
+  def deep_dup: () -> Hash[K, V]
+
+  # `core_ext/hash/deep_merge`
+  def deep_merge: (Hash[K, V]) -> Hash[K, 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
+
+  # `core_ext/hash/except` — `Hash#except` is in core RBS as of
+  # Ruby 3.0+; `except!` is ActiveSupport-only. ActiveSupport
+  # also aliases `Hash#without` to `Hash#except`, used by
+  # `Mastodon`-shaped `options.without('type').merge(...)` chains.
+  def except!: (*K) -> self
+  def without: (*K) -> Hash[K, V]
+
+  # `core_ext/hash/conversions`
+  def to_query: (?String namespace) -> String
+  def to_param: (?String namespace) -> String
+  def to_xml: (**untyped) -> String
+
+  # `core_ext/hash/indifferent_access`
+  def with_indifferent_access: () -> untyped
+
+  # `core_ext/hash/conversions`
+  def self.from_xml: (String, ?Symbol disallowed_types) -> Hash[String, untyped]
+  def self.from_trusted_xml: (String) -> Hash[String, untyped]
+
+  # `core_ext/object/blank` / `core_ext/hash`
+  def compact_blank: () -> Hash[K, V]
+  def compact_blank!: () -> self
+
+  # `core_ext/hash/reverse_merge`
+  def reverse_merge: (Hash[K, V]) -> Hash[K, V]
+  def reverse_merge!: (Hash[K, V]) -> self
+
+  # `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.
+  def slice!: (*K) -> Hash[K, V]
+end
+
+# ---------------------------------------------------------------
+# DateTime — `core_ext/date_time/*`
+# ---------------------------------------------------------------
+
+class DateTime
+  def utc: () -> Time
+  def to_time: () -> Time
+  def in_time_zone: (?String | Symbol zone) -> untyped
+  def yesterday: () -> DateTime
+  def tomorrow: () -> DateTime
+  def ago: (Numeric seconds) -> DateTime
+  def since: (Numeric seconds) -> DateTime
+  def beginning_of_day: () -> DateTime
+  def end_of_day: () -> DateTime
+  def beginning_of_hour: () -> DateTime
+  def end_of_hour: () -> DateTime
+  def beginning_of_minute: () -> DateTime
+  def end_of_minute: () -> DateTime
+  def acts_like_time?: () -> true
+end