rigortype 0.2.7 → 0.2.9

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

@@ -12,51 +12,41 @@ module Rigor
     # [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md)
     # § "3D".
     #
-    # Recognises `class T < GraphQL::Schema::Object` subclasses
-    # and walks every `field :name, Type, null: false` declaration
-    # inside, publishing the resulting field-type map as the
-    # `:graphql_type_table` cross-plugin fact (ADR-9). The macro
-    # expansion library survey at
-    # [docs/notes/20260515-macro-expansion-library-survey.md](../../../../../docs/notes/20260515-macro-expansion-library-survey.md)
-    # § "GraphQL-Ruby" documents WHY this is a pure metadata-recorder
-    # plugin rather than an ADR-16 substrate consumer: graphql-ruby's
-    # `field` DSL emits NO Ruby methods (it just records a
-    # `Schema::Field` on the class's `own_fields`). The user writes
-    # resolver methods themselves; rigor's value here is producing a
-    # static type table downstream consumers can cross-reference.
+    # Recognises `class T < GraphQL::Schema::Object` subclasses and walks every `field :name, Type,
+    # null: false` declaration inside, publishing the resulting field-type map as the
+    # `:graphql_type_table` cross-plugin fact (ADR-9). The macro expansion library survey at
+    # docs/notes/20260515-macro-expansion-library-survey.md § "GraphQL-Ruby" documents WHY this is a
+    # pure metadata-recorder plugin rather than an ADR-16
+    # substrate consumer: graphql-ruby's `field` DSL emits NO Ruby methods (it just records a
+    # `Schema::Field` on the class's `own_fields`). The user writes resolver methods themselves; rigor's
+    # value here is producing a static type table downstream consumers can cross-reference.
     #
     # ## What downstream consumers DO with the published facts
     #
-    # The tables are the substrate for two future capabilities
-    # (demand-driven, not yet implemented):
+    # The tables are the substrate for two future capabilities (demand-driven, not yet implemented):
     #
-    # - Resolver-method check: for each `field :name, Type` whose
-    #   `name` is also defined as a Ruby method on the class, verify
-    #   the method's return type matches `Type`'s underlying class.
-    # - Schema-query result typing: a future `rigor-graphql-execute`
-    #   plugin could type `Schema.execute(query).to_h` against the
-    #   queried fields.
+    # - Resolver-method check: for each `field :name, Type` whose `name` is also defined as a Ruby method
+    #   on the class, verify the method's return type matches `Type`'s underlying class.
+    # - Schema-query result typing: a future `rigor-graphql-execute` plugin could type
+    #   `Schema.execute(query).to_h` against the queried fields.
     #
     # ## What's recognised
     #
-    # - `class T < GraphQL::Schema::Object` subclasses (including
-    #   nested namespaces); `field :name, Type, null: ...`
-    #   declarations with constant-reference or list-array types
-    #   and GraphQL→Ruby scalar mapping.
+    # - `class T < GraphQL::Schema::Object` subclasses (including nested namespaces); `field :name, Type,
+    #   null: ...` declarations with constant-reference or list-array types and GraphQL→Ruby scalar
+    #   mapping.
     # - `class T < GraphQL::Schema::Enum`; `value "ACTIVE"` calls.
-    # - `class T < GraphQL::Schema::InputObject` /
-    #   `GraphQL::Schema::Mutation`; `argument :name, Type,
+    # - `class T < GraphQL::Schema::InputObject` / `GraphQL::Schema::Mutation`; `argument :name, Type,
     #   required: ...` declarations.
     # - No user-facing diagnostics yet.
     #
     # ## Deferred (demand-driven)
     #
     # - **`resolver:` / `mutation:` reroute** recognition.
-    # - **String type expressions** (`field :foo, "User"`) — defeats
-    #   static resolution by design (graphql-ruby's `BuildType.parse_type`
-    #   constantizes at runtime); a future slice could surface these
-    #   as `graphql.string-type` `:info` diagnostics pointing the
-    #   user at the constant-reference form for static typing.
+    # - **String type expressions** (`field :foo, "User"`) — defeats static resolution by design
+    #   (graphql-ruby's `BuildType.parse_type` constantizes at runtime); a future slice could surface
+    #   these as `graphql.string-type` `:info` diagnostics pointing the user at the constant-reference
+    #   form for static typing.
     class Graphql < Rigor::Plugin::Base
       manifest(
         id: "graphql",

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# Gem entry point. Required by Rigor's plugin loader when
-# `.rigor.yml` lists `rigor-graphql` under `plugins:`. The
-# loader expects this `require` to side-effect a call to
-# `Rigor::Plugin.register`, which the body of
-# `lib/rigor/plugin/graphql.rb` performs at load time.
+# Gem entry point. Required by Rigor's plugin loader when `.rigor.yml` lists `rigor-graphql` under
+# `plugins:`. The loader expects this `require` to side-effect a call to `Rigor::Plugin.register`,
+# which the body of `lib/rigor/plugin/graphql.rb` performs at load time.
 require_relative "rigor/plugin/graphql"

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

@@ -5,16 +5,12 @@ require "prism"
 module Rigor
   module Plugin
     class Hanami < Rigor::Plugin::Base
-      # Checks the "presence" half of the Hanami::Action
-      # ADR-28 protocol contract.
+      # Checks the "presence" half of the Hanami::Action ADR-28 protocol contract.
       #
-      # Every class defined in a file matching a contract's
-      # `path_glob` must declare `#handle(request, response)`.
-      # The "provide" half — binding `Hanami::Action::Request`
-      # and `Hanami::Action::Response` into the method body —
-      # is handled engine-side by
-      # `Inference::MethodParameterBinder`. Return type is
-      # void so no conformance check is performed here.
+      # Every class defined in a file matching a contract's `path_glob` must declare `#handle(request,
+      # response)`. The "provide" half — binding `Hanami::Action::Request` and `Hanami::Action::Response`
+      # into the method body — is handled engine-side by `Inference::MethodParameterBinder`. Return type
+      # is void so no conformance check is performed here.
       class ActionChecker
         FNMATCH_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB
 
@@ -22,11 +18,10 @@ module Rigor
           @contracts = contracts
         end
 
-        # Per-`ClassNode` check over the engine-owned walk (ADR-37):
-        # called once per class node the `node_rule` in `hanami.rb`
-        # dispatches, against every contract whose `path_glob` matches
-        # the file. No cross-class-node state is needed, so the checker
-        # ships no `class_nodes` traversal of its own.
+        # Per-`ClassNode` check over the engine-owned walk (ADR-37): called once per class node the
+        # `node_rule` in `hanami.rb` dispatches, against every contract whose `path_glob` matches the
+        # file. No cross-class-node state is needed, so the checker ships no `class_nodes` traversal of
+        # its own.
         def check_class(class_node, path:)
           @contracts.filter_map do |contract|
             next unless path_matches?(contract.path_glob, path)
@@ -42,9 +37,8 @@ module Rigor
 
         private
 
-        # Contract globs are project-root-relative; the analyzer
-        # may supply a relative or absolute path, so the glob is
-        # matched both directly and with a `**/`-prefixed suffix.
+        # Contract globs are project-root-relative; the analyzer may supply a relative or absolute path,
+        # so the glob is matched both directly and with a `**/`-prefixed suffix.
         def path_matches?(glob, path)
           return false if path.nil?
 

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

@@ -9,37 +9,28 @@ module Rigor
   module Plugin
     # rigor-hanami — enforces the Hanami::Action protocol.
     #
-    # Hanami 3.x actions inherit from `Hanami::Action` and
-    # define a single entry-point:
+    # Hanami 3.x actions inherit from `Hanami::Action` and define a single entry-point:
     #
     #   def handle(request, response)
     #     response.status = 200
     #     response.body = "Hello"
     #   end
     #
-    # The method is void — the response is mutated in-place;
-    # the return value is discarded by the framework.
+    # The method is void — the response is mutated in-place; the return value is discarded by the
+    # framework.
     #
-    # This plugin uses the **ADR-28 path-scoped
-    # method-protocol contract** to:
+    # This plugin uses the **ADR-28 path-scoped method-protocol contract** to:
     #
-    # 1. **Provide** `Hanami::Action::Request` and
-    #    `Hanami::Action::Response` as the types of the
-    #    first and second parameters of every `#handle`
-    #    method defined inside `app/actions/**/*.rb`.
-    #    The engine substitutes these types for the usual
-    #    `Dynamic[Top]` fallback, so misuse of `request` or
-    #    `response` inside an action body surfaces as a
-    #    core diagnostic.
+    # 1. **Provide** `Hanami::Action::Request` and `Hanami::Action::Response` as the types of the first
+    #    and second parameters of every `#handle` method defined inside `app/actions/**/*.rb`. The
+    #    engine substitutes these types for the usual `Dynamic[Top]` fallback, so misuse of `request` or
+    #    `response` inside an action body surfaces as a core diagnostic.
     #
-    # 2. **Check** that every class under `app/actions/`
-    #    defines `#handle`. Missing definitions emit
+    # 2. **Check** that every class under `app/actions/` defines `#handle`. Missing definitions emit
     #    `missing-handle-method`.
     #
-    # Return-type conformance is NOT checked — Hanami
-    # actions are void by contract, and checking a void
-    # return would produce false positives on every `if`
-    # branch that doesn't end with an explicit `nil`.
+    # Return-type conformance is NOT checked — Hanami actions are void by contract, and checking a void
+    # return would produce false positives on every `if` branch that doesn't end with an explicit `nil`.
     #
     # ## Configuration
     #
@@ -55,10 +46,8 @@ module Rigor
     # | action class defines no `#handle`        | `:error` | `missing-handle-method` |
     # | `request` / `response` misuse in body    | core engine diagnostic  |
     #
-    # A misused `request` or `response` (e.g.
-    # `request.no_such_method`) surfaces as a standard
-    # engine `call.undefined-method` diagnostic once the
-    # plugin provides the parameter types.
+    # A misused `request` or `response` (e.g. `request.no_such_method`) surfaces as a standard engine
+    # `call.undefined-method` diagnostic once the plugin provides the parameter types.
     class Hanami < Rigor::Plugin::Base
       manifest(
         id: "hanami",
@@ -91,20 +80,17 @@ module Rigor
           end
       end
 
-      # ADR-28: override so the per-project `action_path` config
-      # reaches both the engine's parameter-provision tier and
-      # this plugin's check half.
+      # ADR-28: override so the per-project `action_path` config reaches both the engine's
+      # parameter-provision tier and this plugin's check half.
       def protocol_contracts
         @protocol_contracts || manifest.protocol_contracts
       end
 
-      # ADR-37 — per-class-node validation over the engine-owned walk.
-      # Each `Prism::ClassNode` is checked against every contract
-      # independently, so the plugin no longer ships its own `class_nodes`
-      # traversal; `ActionChecker#check_class` keeps the per-class
-      # contract logic. (A per-class contract check is exactly what
-      # `node_rule` is for — the return type is void, so no `scope`
-      # query is needed.)
+      # ADR-37 — per-class-node validation over the engine-owned walk. Each `Prism::ClassNode` is checked
+      # against every contract independently, so the plugin no longer ships its own `class_nodes`
+      # traversal; `ActionChecker#check_class` keeps the per-class contract logic. (A per-class contract
+      # check is exactly what `node_rule` is for — the return type is void, so no `scope` query is
+      # needed.)
       node_rule Prism::ClassNode do |node, _scope, path|
         contracts = protocol_contracts
         next [] if contracts.empty?

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

@@ -5,75 +5,54 @@ require "rigor/plugin"
 
 module Rigor
   module Plugin
-    # rigor-mangrove — precision plugin for the
-    # [Mangrove](https://github.com/kazzix14/mangrove) functional
+    # rigor-mangrove — precision plugin for the [Mangrove](https://github.com/kazzix14/mangrove) functional
     # toolkit (Result / Option carriers).
     #
     # ## Why this plugin exists (and what it deliberately is NOT)
     #
-    # Mangrove is a Sorbet-first library: every carrier method is
-    # annotated with an inline `sig { ... }`, and the Enum DSL's
-    # dynamic variants are materialised by a bundled Tapioca DSL
-    # compiler. So the *type source* for Mangrove is already
-    # covered by `rigor-sorbet` (sig ingestion + RBI walking) —
-    # this plugin is NOT a parallel type source. See
-    # `docs/notes/20260530-mangrove-library-survey.md`.
+    # Mangrove is a Sorbet-first library: every carrier method is annotated with an inline `sig { ... }`, and
+    # the Enum DSL's dynamic variants are materialised by a bundled Tapioca DSL compiler. So the *type source*
+    # for Mangrove is already covered by `rigor-sorbet` (sig ingestion + RBI walking) — this plugin is NOT a
+    # parallel type source. See `docs/notes/20260530-mangrove-library-survey.md`.
     #
-    # What sig-ingestion (Sorbet-level precision) structurally
-    # cannot do is **instantiate the carrier's generic
-    # type-member at the unwrap call site**. Mangrove's `Result`
-    # interface declares:
+    # What sig-ingestion (Sorbet-level precision) structurally cannot do is **instantiate the carrier's generic
+    # type-member at the unwrap call site**. Mangrove's `Result` interface declares:
     #
     #     sig { abstract.returns(OkType) }
     #     def unwrap!; end
     #
-    # `OkType` is a `type_member(:out)`. When the receiver's
-    # static type is `Mangrove::Result[String, StandardError]`,
-    # `unwrap!` *should* yield `String` — but resolving the
-    # abstract `OkType` to the receiver's first type argument is
-    # generic instantiation, which neither `rigor-sorbet` (it
-    # contributes the cataloged sig's return type verbatim) nor a
-    # bare-`def unwrap!: () -> untyped` RBS stub performs. The
-    # call degrades to `Dynamic[top]`.
+    # `OkType` is a `type_member(:out)`. When the receiver's static type is
+    # `Mangrove::Result[String, StandardError]`, `unwrap!` *should* yield `String` — but resolving the abstract
+    # `OkType` to the receiver's first type argument is generic instantiation, which neither `rigor-sorbet` (it
+    # contributes the cataloged sig's return type verbatim) nor a bare-`def unwrap!: () -> untyped` RBS stub
+    # performs. The call degrades to `Dynamic[top]`.
     #
-    # This plugin closes exactly that gap. At every recognised
-    # unwrap-family call on a known Mangrove carrier, it reads the
-    # receiver's `Rigor::Type::Nominal#type_args` and contributes
-    # the first argument (the `OkType` / `InnerType`) as the
-    # call's return type. The receiver type is already known, so
-    # this only ever *sharpens* an existing `Dynamic[top]` into a
-    # concrete type — it never invents a receiver type and never
-    # emits a diagnostic of its own, so it cannot frighten working
-    # code (Rigor's false-positive discipline).
+    # This plugin closes exactly that gap. At every recognised unwrap-family call on a known Mangrove carrier,
+    # it reads the receiver's `Rigor::Type::Nominal#type_args` and contributes the first argument (the
+    # `OkType` / `InnerType`) as the call's return type. The receiver type is already known, so this only ever
+    # *sharpens* an existing `Dynamic[top]` into a concrete type — it never invents a receiver type and never
+    # emits a diagnostic of its own, so it cannot frighten working code (Rigor's false-positive discipline).
     #
     # ## Scope (slice 1)
     #
-    # - Result unwrap family → `OkType` (`type_args[0]`):
-    #   `unwrap!`, `unwrap_in`, `expect!`, `expect_with!`,
-    #   `unwrap_or_raise!`, `unwrap_or_raise_with!`,
-    #   `unwrap_or_raise_inner!`.
-    # - Option unwrap family → `InnerType` (`type_args[0]`):
-    #   `unwrap`, `unwrap!`, `unwrap_or`, `expect!`,
+    # - Result unwrap family → `OkType` (`type_args[0]`): `unwrap!`, `unwrap_in`, `expect!`, `expect_with!`,
+    #   `unwrap_or_raise!`, `unwrap_or_raise_with!`, `unwrap_or_raise_inner!`.
+    # - Option unwrap family → `InnerType` (`type_args[0]`): `unwrap`, `unwrap!`, `unwrap_or`, `expect!`,
     #   `expect_with!`.
     #
-    # The contribution fires only when the receiver resolves to a
-    # carrier Nominal carrying a non-empty `type_args` — i.e. when
-    # the Result/Option came from a method whose declared return
-    # type is an applied generic (`-> Result[String, E]`), the
-    # realistic Mangrove shape. The bare-constructor shape
-    # (`Result::Ok.new("x")`) currently yields a raw Nominal with
-    # no `type_args` (the engine does not infer generics from
-    # constructor arguments), so the plugin no-ops there rather
-    # than guessing — a conservative floor, not a regression.
+    # The contribution fires only when the receiver resolves to a carrier Nominal carrying a non-empty
+    # `type_args` — i.e. when the Result/Option came from a method whose declared return type is an applied
+    # generic (`-> Result[String, E]`), the realistic Mangrove shape. The bare-constructor shape
+    # (`Result::Ok.new("x")`) currently yields a raw Nominal with no `type_args` (the engine does not infer
+    # generics from constructor arguments), so the plugin no-ops there rather than guessing — a conservative
+    # floor, not a regression.
     #
     # ## Out of scope (tracked elsewhere)
     #
-    # - `is_a?(Result::Ok)` / `Some` / `None` exhaustive
-    #   narrowing — core control-flow analysis over a sealed
+    # - `is_a?(Result::Ok)` / `Some` / `None` exhaustive narrowing — core control-flow analysis over a sealed
     #   hierarchy, not a plugin surface.
-    # - The `variants do variant Const, Type end` Enum DSL is handled
-    #   via ADR-36 `nested_class_templates:` in this plugin's manifest
-    #   (Slice A — see `nested_class_templates:` block below).
+    # - The `variants do variant Const, Type end` Enum DSL is handled via ADR-36 `nested_class_templates:` in
+    #   this plugin's manifest (Slice A — see `nested_class_templates:` block below).
     class Mangrove < Rigor::Plugin::Base
       manifest(
         id: "mangrove",
@@ -90,10 +69,9 @@ module Rigor
         #     end
         #   end
         #
-        # mints `Shape::Circle < Shape` with `#inner : Float`. The
-        # substrate resolves the variant constant + its `#inner`
-        # reader statically so `Shape::Circle.new(1.0).inner`
-        # types as `Float` without running Mangrove's `const_missing`.
+        # mints `Shape::Circle < Shape` with `#inner : Float`. The substrate resolves the variant constant +
+        # its `#inner` reader statically so `Shape::Circle.new(1.0).inner` types as `Float` without running
+        # Mangrove's `const_missing`.
         nested_class_templates: [
           Rigor::Plugin::Macro::NestedClassTemplate.new(
             receiver_constraint: "Mangrove::Enum",
@@ -106,11 +84,9 @@ module Rigor
         ]
       )
 
-      # Carrier class names whose FIRST type argument is the
-      # value the unwrap family yields (`OkType` for Result,
-      # `InnerType` for Option). Matched with and without a
-      # leading `::` because `scope.type_of` reports the lexical
-      # form while user code may root the constant.
+      # Carrier class names whose FIRST type argument is the value the unwrap family yields (`OkType` for
+      # Result, `InnerType` for Option). Matched with and without a leading `::` because `scope.type_of`
+      # reports the lexical form while user code may root the constant.
       RESULT_CARRIERS = [
         "Mangrove::Result",
         "Mangrove::Result::Ok",
@@ -123,23 +99,19 @@ module Rigor
         "Mangrove::Option::None"
       ].freeze
 
-      # Methods on the Result carriers that return `OkType`
-      # (`type_args[0]`). All of these are documented as yielding
-      # the success value, raising / short-circuiting on `Err`.
+      # Methods on the Result carriers that return `OkType` (`type_args[0]`). All of these are documented as
+      # yielding the success value, raising / short-circuiting on `Err`.
       RESULT_UNWRAP_METHODS = %i[
         unwrap! unwrap_in expect! expect_with!
         unwrap_or_raise! unwrap_or_raise_with! unwrap_or_raise_inner!
       ].freeze
 
-      # Methods on the Option carriers that return `InnerType`
-      # (`type_args[0]`).
+      # Methods on the Option carriers that return `InnerType` (`type_args[0]`).
       OPTION_UNWRAP_METHODS = %i[unwrap unwrap! unwrap_or expect! expect_with!].freeze
 
-      # ADR-37 slice 2 — a pure return-type contributor. The engine
-      # gates on the receiver being a known carrier class (so the block
-      # only runs on Result/Option receivers); the block then confirms
-      # the call is an unwrap method on an instantiated carrier and
-      # yields the carried `type_args[0]`.
+      # ADR-37 slice 2 — a pure return-type contributor. The engine gates on the receiver being a known
+      # carrier class (so the block only runs on Result/Option receivers); the block then confirms the call
+      # is an unwrap method on an instantiated carrier and yields the carried `type_args[0]`.
       dynamic_return receivers: (RESULT_CARRIERS + OPTION_CARRIERS) do |call_node, scope|
         receiver = call_node.receiver
         next nil if receiver.nil?
@@ -152,18 +124,16 @@ module Rigor
 
       private
 
-      # @return [Rigor::Type, nil] the receiver's inferred type, or
-      #   nil when the engine raises on a synthetic / unrecognised
-      #   node (mirrors rigor-sorbet's defensive degrade).
+      # @return [Rigor::Type, nil] the receiver's inferred type, or nil when the engine raises on a synthetic
+      #   / unrecognised node (mirrors rigor-sorbet's defensive degrade).
       def receiver_type_of(receiver, scope)
         scope.type_of(receiver)
       rescue StandardError
         nil
       end
 
-      # The value the unwrap family yields for this receiver, or
-      # nil when the call is not an unwrap on a known carrier, or
-      # the carrier is raw (no `type_args` to instantiate).
+      # The value the unwrap family yields for this receiver, or nil when the call is not an unwrap on a
+      # known carrier, or the carrier is raw (no `type_args` to instantiate).
       def carried_type(receiver_type, method_name)
         class_name = normalize(receiver_type.class_name)
         type_args = receiver_type.type_args

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

@@ -8,9 +8,8 @@ require "rigor/flow_contribution/fact"
 module Rigor
   module Plugin
     class Minitest < Rigor::Plugin::Base
-      # Recognises the four shapes of Minitest / Test::Unit
-      # assertions and emits a `post_return_fact` that narrows
-      # the named local on the post-call edge.
+      # Recognises the four shapes of Minitest / Test::Unit assertions and emits a `post_return_fact` that
+      # narrows the named local on the post-call edge.
       #
       # ## Recognised call shapes
       #
@@ -29,9 +28,8 @@ module Rigor
       #   refute_nil(x)               →  narrow x AWAY from nil
       #   refute_equal(literal, x)    →  narrow x AWAY from Constant<literal>
       #
-      # Test::Unit's `assert_not_nil(x)` / `assert_not_equal(...)` /
-      # `assert_not_kind_of(...)` / `assert_not_instance_of(...)`
-      # share the recognizer with `refute_*` (they're aliases).
+      # Test::Unit's `assert_not_nil(x)` / `assert_not_equal(...)` / `assert_not_kind_of(...)` /
+      # `assert_not_instance_of(...)` share the recognizer with `refute_*` (they're aliases).
       #
       # ### (3) Minitest/spec `_(x).must_*` (positive) ###
       #
@@ -41,12 +39,10 @@ module Rigor
       #   _(x).must_equal(literal)    →  narrow x to Constant<literal>
       #   _(x).must_match(regex)      →  narrow x to String
       #
-      # The legacy bare `x.must_be_kind_of(T)` form (Minitest <
-      # 6.0 monkey-patched onto Object) is intentionally NOT
-      # recognised — the receiver is the value itself rather
-      # than a wrapping `_(value)`, so the analyzer has nothing
-      # to narrow against. Users who still rely on the legacy
-      # form should migrate to `_(x).must_*`.
+      # The legacy bare `x.must_be_kind_of(T)` form (Minitest < 6.0 monkey-patched onto Object) is
+      # intentionally NOT recognised — the receiver is the value itself rather than a wrapping `_(value)`,
+      # so the analyzer has nothing to narrow against. Users who still rely on the legacy form should
+      # migrate to `_(x).must_*`.
       #
       # ### (4) Minitest/spec `_(x).wont_*` (negative) ###
       #
@@ -56,14 +52,10 @@ module Rigor
       #
       # ## Not yet recognised
       #
-      # `assert_predicate(x, :foo?)` (custom predicate) /
-      # `assert_respond_to(x, :method)` / `assert_includes` /
-      # `assert_operator` / `assert_throws` /
-      # `assert_raises(T) { ... }` etc. — each either needs a
-      # carrier Rigor doesn't model today (predicate-state,
-      # respond-to-set) or a multi-edge fact that the
-      # `post_return_facts` slot can't express. Queued for
-      # follow-up slices.
+      # `assert_predicate(x, :foo?)` (custom predicate) / `assert_respond_to(x, :method)` / `assert_includes`
+      # / `assert_operator` / `assert_throws` / `assert_raises(T) { ... }` etc. — each either needs a
+      # carrier Rigor doesn't model today (predicate-state, respond-to-set) or a multi-edge fact that the
+      # `post_return_facts` slot can't express. Queued for follow-up slices.
       module AssertionAnalyzer
         module_function
 
@@ -83,16 +75,12 @@ module Rigor
 
         # --- assert_* / refute_* / assert_not_* form ---
 
-        # Maps each recognised assertion name to a tuple
-        # `[shape, negative]`. `shape` is one of:
+        # Maps each recognised assertion name to a tuple `[shape, negative]`. `shape` is one of:
         #
-        # - :class_then_local   — `assert_kind_of(T, x)`, T at
-        #   args[0], local at args[1].
+        # - :class_then_local   — `assert_kind_of(T, x)`, T at args[0], local at args[1].
         # - :nil_local          — `assert_nil(x)`, local at args[0].
-        # - :literal_then_local — `assert_equal(literal, x)`,
-        #   literal at args[0], local at args[1].
-        # - :regex_then_local   — `assert_match(regex, x)`,
-        #   regex at args[0], local at args[1].
+        # - :literal_then_local — `assert_equal(literal, x)`, literal at args[0], local at args[1].
+        # - :regex_then_local   — `assert_match(regex, x)`, regex at args[0], local at args[1].
         ASSERT_FORM = {
           assert_kind_of: [:class_then_local, false],
           assert_instance_of: [:class_then_local, false],
@@ -123,8 +111,7 @@ module Rigor
 
         # --- _(x).must_* / .wont_* form ---
 
-        # Maps the spec-style matcher names to `[shape,
-        # negative]`. `shape`:
+        # Maps the spec-style matcher names to `[shape, negative]`. `shape`:
         # - :class_arg   — `_(x).must_be_kind_of(T)`, T at args[0].
         # - :no_arg_nil  — `_(x).must_be_nil`, no args.
         # - :literal_arg — `_(x).must_equal(literal)`, literal at args[0].
@@ -144,8 +131,8 @@ module Rigor
         }.freeze
         private_constant :SPEC_MATCHER_FORM
 
-        # ADR-37 slice 2 — the method names this analyzer narrows on,
-        # for the plugin's `narrowing_facts methods:` gate.
+        # ADR-37 slice 2 — the method names this analyzer narrows on, for the plugin's
+        # `narrowing_facts methods:` gate.
         SUPPORTED_METHODS = (ASSERT_FORM.keys + SPEC_MATCHER_FORM.keys).freeze
 
         def spec_form_fact(call_node, environment:)
@@ -160,10 +147,9 @@ module Rigor
           fact_for_spec_shape(shape, target_local, args, negative: negative, environment: environment)
         end
 
-        # `_(x)` returns a `Minitest::Expectation` wrapping x.
-        # Some specs use `value(x)` or `expect(x)` interchangeably
-        # (Minitest provides all three as aliases). Recognises the
-        # local-variable arg in any of those receiver-call shapes.
+        # `_(x)` returns a `Minitest::Expectation` wrapping x. Some specs use `value(x)` or `expect(x)`
+        # interchangeably (Minitest provides all three as aliases). Recognises the local-variable arg in
+        # any of those receiver-call shapes.
         SPEC_WRAPPER_NAMES = %i[_ value expect].freeze
         private_constant :SPEC_WRAPPER_NAMES