rigortype 0.1.19 → 0.2.1

data/lib/rigor/type/struct_class.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "../value_semantics"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # The class object produced by `Struct.new(:x, :y)` (ADR-48 Struct
+    # follow-up). The mutable sibling of {DataClass}: it models the *class*
+    # (the value bound to `Point` in `Point = Struct.new(:x, :y)`, or the
+    # anonymous superclass in `class Point < Struct.new(:x, :y)`), carrying
+    # the ordered member-name list so `Point.new(...)` can materialise a
+    # {StructInstance}.
+    #
+    # `keyword_init` records the `Struct.new(..., keyword_init: true)` flag
+    # so `.new` only materialises a precise instance for the matching call
+    # form — a positional `.new(1, 2)` on a `keyword_init: true` struct, or
+    # a keyword `.new(x: 1)` on a positional struct, is a different runtime
+    # shape and must degrade rather than fold a wrong member map.
+    #
+    # `class_name` carries the binding name when known (the named-subclass
+    # form) and is `nil` for the anonymous result of a bare `Struct.new(...)`
+    # before it is assigned to a constant.
+    #
+    # Equality and hashing are structural over the member list, the class
+    # name, and the keyword-init flag.
+    #
+    # See docs/adr/48-data-struct-value-folding.md § "Struct follow-up".
+    class StructClass
+      attr_reader :members, :class_name, :keyword_init
+
+      # @param members [Array<Symbol>] ordered member names.
+      # @param class_name [String, nil] the bound class name, or nil for
+      #   the anonymous `Struct.new(...)` result.
+      # @param keyword_init [Boolean] the `keyword_init:` flag.
+      def initialize(members, class_name = nil, keyword_init: false)
+        unless members.is_a?(Array) && members.all?(Symbol)
+          raise ArgumentError, "members must be an Array of Symbols, got #{members.inspect}"
+        end
+        unless class_name.nil? || (class_name.is_a?(String) && !class_name.empty?)
+          raise ArgumentError, "class_name must be a non-empty String or nil, got #{class_name.inspect}"
+        end
+
+        @members = members.dup.freeze
+        @class_name = class_name&.freeze
+        @keyword_init = keyword_init ? true : false
+        freeze
+      end
+
+      def describe(_verbosity = :short)
+        return "singleton(#{class_name})" if class_name
+
+        "Struct.new(#{members.map(&:inspect).join(', ')})"
+      end
+
+      def erase_to_rbs
+        "singleton(#{class_name || 'Struct'})"
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      include Rigor::ValueSemantics
+
+      value_fields :members, :class_name, :keyword_init
+
+      def inspect
+        "#<Rigor::Type::StructClass #{describe(:short)}>"
+      end
+    end
+  end
+end

data/lib/rigor/type/struct_instance.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+require_relative "../value_semantics"
+require_relative "acceptance_router"
+require_relative "plain_lattice"
+
+module Rigor
+  module Type
+    # A `Struct.new` value instance (ADR-48 Struct follow-up) —
+    # `Point.new(1, 2)`. The mutable sibling of {DataInstance}: a closed,
+    # total, class-tagged member map (member name -> value type),
+    # HashShape-shaped but nominal.
+    #
+    # Unlike {DataInstance}, a `Struct` instance is **mutable** — `s.x = v`,
+    # `s[:x] = v`, and escape can invalidate the member map. The folding
+    # tier therefore only projects member reads off a **fresh** instance
+    # (the transient receiver of a `.new(...).x` / `.with(...).x` chain,
+    # which provably cannot have been mutated between materialisation and
+    # the read); a read off a *stored* binding degrades to `Dynamic[top]`
+    # rather than fold a possibly-stale member value. Promoting the
+    # fold to mutation-free bound locals is the deferred slice 3 (see ADR).
+    #
+    # That mutability-gating lives in the dispatch tier (`StructFolding`),
+    # not the carrier: the carrier itself just records the member map. Like
+    # {DataInstance}, non-folded methods project to the `Struct` nominal (or
+    # the tagged class) through {RbsDispatch}'s `receiver_descriptor`, so
+    # non-member calls resolve without mis-firing undefined-method.
+    #
+    # Equality and hashing are structural over the (member -> type) map and
+    # the class name.
+    #
+    # See docs/adr/48-data-struct-value-folding.md § "Struct follow-up".
+    class StructInstance
+      attr_reader :members, :class_name
+
+      # @param members [Hash{Symbol => Rigor::Type}] ordered member -> type
+      #   map. Every declared member is present (Struct instances are total).
+      # @param class_name [String, nil] the tagging class name, or nil for
+      #   an instance of an anonymous `Struct.new(...)` class.
+      def initialize(members, class_name = nil)
+        unless members.is_a?(Hash) && members.each_key.all?(Symbol)
+          raise ArgumentError, "members must be a Hash with Symbol keys, got #{members.inspect}"
+        end
+        unless class_name.nil? || (class_name.is_a?(String) && !class_name.empty?)
+          raise ArgumentError, "class_name must be a non-empty String or nil, got #{class_name.inspect}"
+        end
+
+        @members = members.dup.freeze
+        @class_name = class_name&.freeze
+        freeze
+      end
+
+      # @return [Array<Symbol>] ordered member names.
+      def member_names
+        members.keys
+      end
+
+      # @return [Rigor::Type, nil] the member's value type, or nil when the
+      #   name is not a declared member.
+      def member_type(name)
+        members[name]
+      end
+
+      def describe(verbosity = :short)
+        rendered = members.map { |name, type| "#{name}: #{type.describe(verbosity)}" }
+        "#{class_name || 'Struct'}(#{rendered.join(', ')})"
+      end
+
+      # Erases to the tagging class nominal (conservative: the structural
+      # members are not RBS-expressible as a class instance). The
+      # anonymous case erases to the `Struct` supertype.
+      def erase_to_rbs
+        name = class_name
+        return "Struct" if name.nil?
+
+        name
+      end
+
+      include Rigor::Type::PlainLattice
+
+      include Rigor::Type::AcceptanceRouter
+
+      include Rigor::ValueSemantics
+
+      value_fields :members, :class_name
+
+      def inspect
+        "#<Rigor::Type::StructInstance #{describe(:short)}>"
+      end
+    end
+  end
+end

data/lib/rigor/type/tuple.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -17,10 +18,9 @@ module Rigor
     #
     # Slice 5 phase 1 introduces the carrier and surfaces it from the
     # `ArrayNode` literal handler when every element is a non-splat
-    # value. Tuple-aware refinements for `tuple[0]`, `tuple.first`, and
-    # destructuring assignment are deferred to Slice 5 phase 2; they
-    # will run as a higher-priority dispatch tier above
-    # {Rigor::Inference::MethodDispatcher::RbsDispatch}.
+    # value. Tuple-aware refinements (`tuple[0]`, `tuple.first`,
+    # destructuring) are implemented in `ShapeDispatch`, which runs
+    # above {Rigor::Inference::MethodDispatcher::RbsDispatch}.
     #
     # Equality and hashing are structural across an ordered, frozen
     # element list. The empty Tuple `Tuple[]` is permitted; the array
@@ -53,17 +53,7 @@ module Rigor
         "[#{elements.map(&:erase_to_rbs).join(', ')}]"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type.rb

@@ -21,6 +21,8 @@ require_relative "type/tuple"
 require_relative "type/hash_shape"
 require_relative "type/data_class"
 require_relative "type/data_instance"
+require_relative "type/struct_class"
+require_relative "type/struct_instance"
 require_relative "type/union"
 require_relative "type/difference"
 require_relative "type/refined"

data/lib/rigor/version.rb

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

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

@@ -26,7 +26,7 @@ module Rigor
       #   `stream_for` call) so the analyzer knows it can't
       #   be sure of every stream name.
       #
-      # Limitations (intentional for v0.1.0):
+      # Intentional limitations:
       #
       # - Direct-superclass match only.
       # - Public-vs-private is not tracked; the framework

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

@@ -69,9 +69,9 @@ module Rigor
         # True when at least one discovered channel uses a
         # dynamic stream registration. The analyzer treats
         # this as "we can't be sure any literal name is
-        # missing" and downgrades unknown-stream from
-        # `:warning` to `:info` (or drops it entirely;
-        # current behaviour: skip warnings).
+        # missing" and skips the `unknown-stream` warning
+        # entirely — absence of a literal match doesn't prove
+        # the name is wrong.
         def any_dynamic_streams?
           @entries.any?(&:dynamic_streams)
         end

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

@@ -41,7 +41,7 @@ module Rigor
     #    `stream_for record`) — the absence of a literal
     #    match doesn't prove absence.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **Direct-superclass match only.** Indirect
     #   inheritance (`AdminChannel < BaseChannel <
@@ -51,8 +51,8 @@ module Rigor
     #   ActionCable actions are invoked from JS via
     #   `subscription.perform("action_name", data)`; we
     #   don't analyse JS so the action-method index is
-    #   currently informational only (future cross-plugin
-    #   handoff to a hypothetical JS-side analyzer).
+    #   informational only (deferred: cross-plugin handoff
+    #   to a JS-side analyzer).
     # - **`broadcast_to` arity isn't checked.** The method
     #   takes any record + any data hash; there's no
     #   useful arity envelope.

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

@@ -301,19 +301,11 @@ module Rigor
             [entry.method_name, entry]
           end
 
-          # Merge in actions from include'd modules. The
-          # discoverer pre-collected every module's defs as
-          # `module_actions` keyed by fully-qualified module
-          # name. We resolve each include against that map —
-          # tries the full include name first, then walks down
-          # the class's lexical chain looking for a nested
-          # match (e.g. `Emails::Issues` inside `class Notify`
-          # at top-level resolves to top-level `Emails::Issues`).
-          # Includes we cannot resolve are silently skipped;
-          # the per-mailer `unresolved_includes?` predicate
-          # below (consumed by the analyzer) downgrades
-          # `unknown-action` to silence when any include is
-          # unresolved.
+          # Merge actions from include'd modules (pre-collected
+          # in `module_actions` keyed by fully-qualified name).
+          # Unresolvable includes are tracked; `unresolved_includes?`
+          # (consumed by the analyzer) downgrades `unknown-action`
+          # to silence when any include remains unresolved.
           unresolved_includes = []
           includes.each do |include_name|
             inc_actions = module_actions[include_name]

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

@@ -33,9 +33,8 @@ module Rigor
         # Phase 2 — filter-chain DSL methods. Each takes a
         # variadic list of filter names (Symbols / Strings) plus
         # optional `only:` / `except:` / `if:` / `unless:`
-        # modifiers. The validation key is the filter NAMES; the
-        # modifiers are accepted but their action-name argument
-        # is not yet validated (Phase 2.5).
+        # modifiers. Only the filter NAMES are validated; the
+        # `only:`/`except:` action-name arguments are not (deferred).
         FILTER_DSL_METHODS = %i[
           before_action after_action around_action
           skip_before_action skip_after_action skip_around_action
@@ -43,18 +42,14 @@ module Rigor
         ].freeze
 
         # Phase 3 — render-target template extensions checked in
-        # priority order. The first six cover the templating
-        # engines used by the projects this plugin is regularly
-        # exercised against: ERB (Rails default — `.html.erb`,
-        # `.text.erb`), HAML (Mastodon, Solidus admin —
-        # `.html.haml`), Slim, and JSON (`.json.jbuilder` plus a
-        # raw `.json.erb` for hand-rolled API responses). When a
-        # template exists under any of these extensions, the
-        # missing-template diagnostic stays silent.
-        # Configurable extension list is queued — see the
-        # `external-author plugin SKILL` track (v0.2.0). For now
-        # this set is wide enough to cover the surveyed real-world
-        # projects without leaking FPs.
+        # priority order. Covers the engines used by surveyed
+        # projects: ERB (Rails default — `.html.erb`, `.text.erb`),
+        # HAML (Mastodon, Solidus admin — `.html.haml`), Slim, and
+        # JSON (`.json.jbuilder` plus `.json.erb` for hand-rolled API
+        # responses). When a template exists under any of these
+        # extensions, the missing-template diagnostic stays silent.
+        # A configurable extension list is deferred; this set is wide
+        # enough to cover surveyed real-world projects without FPs.
         RENDER_TEMPLATE_EXTENSIONS = %w[
           .html.erb
           .text.erb
@@ -167,8 +162,7 @@ module Rigor
         # list (looked up via the model_index fact published by
         # `rigor-activerecord`). Calls whose `:require` argument is a
         # non-literal Symbol are passed through; namespaced models
-        # (`params.require(:admin_user)` → `Admin::User`) are deferred to a
-        # Phase 1.5 follow-up.
+        # (`params.require(:admin_user)` → `Admin::User`) are deferred.
         #
         # @param call_node [Prism::Node]
         # @param model_index [Hash{String => Hash}]

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

@@ -68,17 +68,14 @@ module Rigor
     class Actionpack < Rigor::Plugin::Base
       manifest(
         id: "actionpack",
-        # Bumped 2026-06-02 — ADR-37 node_rule migration. The four
-        # phases (helper / filter / render / strong-params) now run
-        # per-call over the engine-owned walk instead of the
-        # hand-rolled `diagnostics_for_file` traversal; the enclosing
-        # controller is read from the node-rule `NodeContext` ancestors.
-        # Nested-module qualification is preserved — a
-        # `module Admin; class DomainBlocksController; end` file still
+        # ADR-37: the four phases (helper / filter / render /
+        # strong-params) run per-call over the engine-owned walk;
+        # the enclosing controller is read from the node-rule
+        # `NodeContext` ancestors. Nested-module qualification is
+        # preserved — `module Admin; class DomainBlocksController`
         # resolves as `Admin::DomainBlocksController` (matching the
-        # `ControllerDiscoverer`), so render paths
-        # (`admin/domain_blocks/new`) and filter-chain validation on
-        # nested controllers are unchanged.
+        # `ControllerDiscoverer`), so render paths and filter-chain
+        # validation on nested controllers are correct.
         version: "0.8.0",
         description: "Validates Action Pack route-helper calls and filter chains inside controllers.",
         config_schema: {

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

@@ -12,8 +12,9 @@ module Rigor
       # (`Float::INFINITY` for the upper bound when `*args`
       # is present). `keyword_required` lists any required
       # keyword arguments — Active Job supports keyword args
-      # but they're rare in user code, so the analyzer only
-      # validates positional arity for v0.1.0.
+      # but they're rare in user code, so the analyzer
+      # validates positional arity only (keyword arity
+      # validation is deferred).
       class JobIndex
         Entry = Data.define(:class_name, :min_arity, :max_arity, :keyword_required) do
           # Flexible-friendly textual form of the arity for

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

@@ -227,8 +227,8 @@ module Rigor
         # Recognised single-instance and collection association
         # DSL methods. The kind drives the eventual return-type
         # contribution: singular associations narrow to
-        # `Nominal[Target] | nil`, plural ones currently degrade
-        # to the RBS envelope (relation types are a future track).
+        # `Nominal[Target] | nil`, plural ones narrow to
+        # `ActiveRecord::Relation[Target]`.
         #
         # `composed_of` value-object aggregations and
         # `delegated_type` roles are folded in here too — both
@@ -447,8 +447,8 @@ module Rigor
 
         # `scope :active, -> { ... }`. Records the scope name
         # only (the body is intentionally NOT introspected —
-        # scopes return ActiveRecord::Relation, which Rigor
-        # doesn't carry a precise type for yet).
+        # the caller contributes `ActiveRecord::Relation[Model]`
+        # based on the name alone via `class_scope_return_type`).
         def lookup_scopes(body)
           return [] if body.nil?
 

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

@@ -75,10 +75,9 @@ module Rigor
           "model_base_classes" => { kind: :array, default: %w[ApplicationRecord ActiveRecord::Base] }
         },
         produces: [:model_index],
-        # ADR-25 — the bundled `ActiveRecord::Relation` RBS, the
-        # type `flow_contribution_for`'s relation-typed call sites
-        # (`has_many` accessors, `Model.where`, scopes) dispatch
-        # against.
+        # ADR-25 — the bundled `ActiveRecord::Relation` RBS that
+        # relation-typed call sites (`has_many` accessors,
+        # `Model.where`, scopes) dispatch against.
         signature_paths: ["sig"],
         # ADR-26 — `ActiveRecord::Relation` is an "open" receiver:
         # it delegates an unbounded set of user-defined scopes /
@@ -89,7 +88,7 @@ module Rigor
       )
 
       # The class the bundled `sig/active_record/relation.rbs`
-      # describes; `flow_contribution_for` contributes
+      # describes; `dynamic_return` contributes
       # `ActiveRecord::Relation[Model]` for relation-returning
       # call sites (`has_many` accessors, `Model.where`, scopes).
       RELATION_CLASS_NAME = "ActiveRecord::Relation"
@@ -261,9 +260,8 @@ module Rigor
         names
       end
 
-      # The migrated body of the legacy `flow_contribution_for` —
-      # same resolution order, returning the bare type the
-      # `dynamic_return` contract expects.
+      # Resolution body for `dynamic_return` — same four-path
+      # order, returning the bare type the contract expects.
       def contribution_return_type(call_node, scope)
         return nil unless call_node.is_a?(Prism::CallNode)
 

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

@@ -11,13 +11,11 @@ module Rigor
       # plugin recognised so users can verify the model →
       # attachment mapping the plugin sees.
       #
-      # No `:error` diagnostics in this slice — the
-      # `dynamic_return` return-type narrowing carries
-      # the type-checking value; surfacing unknown attachment
-      # names as errors requires a coupled receiver-class
-      # narrowing pass that the integration spec doesn't yet
-      # rely on. A future slice can add `unknown-attachment`
-      # similar to `rigor-activerecord`'s `unknown-column`.
+      # No `:error` diagnostics here — the `dynamic_return`
+      # return-type narrowing carries the type-checking value.
+      # An `unknown-attachment` rule (similar to
+      # `rigor-activerecord`'s `unknown-column`) is deferred:
+      # it requires a coupled receiver-class narrowing pass.
       class Analyzer
         attr_reader :diagnostics
 

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

@@ -132,8 +132,7 @@ module Rigor
         # ADR-60 WD3 record-and-validate: the producer's in-block
         # `AttachmentDiscoverer` reads are captured into the
         # dependency descriptor after the block runs, and the
-        # producer's `watch:` covers model-file additions — so no
-        # priming walk is needed (it used to run the discover twice).
+        # producer's `watch:` covers model-file additions.
         @attachment_index = cache_for(:attachment_index, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_errors << "rigor-activestorage: #{e.message}"

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

@@ -44,19 +44,17 @@ module Rigor
     # `send_reset_password_instructions`, etc. resolve through the
     # synthetic-method tier without `call.undefined-method`.
     #
-    # ## Floor / ceiling per ADR-16 WD13
+    # ## Precision tier
     #
-    # Slice 3 ships at the **floor**: synthesised method names
-    # emit and the dispatcher's `try_synthetic_method` tier
-    # returns `Type::Combinator.untyped` (Dynamic[T]) for every
-    # match. Per the slice-3 design judgment (1) the precision
-    # promotion — looking up the module's authored RBS return
-    # type at dispatch time — is **slice-6 ceiling work** and is
-    # NOT a delivery commitment of slice 3c. The `origin_module:`
-    # provenance field is recorded so the ceiling slice can
-    # promote without rescanning.
+    # The scanner records `origin_module:` in each synthetic
+    # method's provenance. The dispatcher's slice-6a TierB path
+    # (`promote_via_origin_module`) redispatches on
+    # `Nominal[origin_module]` via `RbsDispatch`, so Devise's
+    # authored RBS return types win: `valid_password?` returns
+    # `bool`, not `Dynamic[T]`. Unknown return types degrade
+    # gracefully to `Dynamic[T]`.
     #
-    # ## Scope (slice 3c minimum)
+    # ## Scope
     #
     # - Recognises model-side `devise :a, :b` on any AR::Base
     #   subclass; trait symbol set mirrors `lib/devise/modules.rb`.

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

@@ -35,16 +35,15 @@ module Rigor
     # other files then dispatch through the synthetic record rather
     # than falling through to `call.undefined-method`.
     #
-    # ## Floor / ceiling per ADR-16 WD13
+    # ## Precision model (ADR-16 WD13 + ADR-18)
     #
-    # Slice 2 ships at the **floor**: the synthetic reader's return
-    # type degrades to `Dynamic[T]`. The manifest's `returns: "Object"`
-    # is recorded but not resolved — precise return-type promotion
-    # (so `attribute :city, Types::String` makes `address.city`
-    # return `String`) is the **ceiling**, deferred to slice 6
-    # (ADR-13 `Plugin::TypeNodeResolver` chain). The plugin's manifest
-    # value of `returns:` would today be the upstream gem's reader
-    # return shape; slice 6 unlocks precision without re-authoring.
+    # The synthetic reader's return type is resolved via ADR-18's
+    # `returns_from_arg:` fact lookup: the call-site's second argument
+    # (`Types::String` etc.) is looked up through the `:dry_type_aliases`
+    # fact published by `rigor-dry-types`, yielding `Nominal[String]`
+    # for common cases. When the lookup misses (e.g. inline method-chain
+    # argument whose chain-head isn't currently extracted), the row
+    # falls back to `Dynamic[Top]` silently.
     #
     # ## Scope (slice 2c minimum)
     #

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

@@ -22,9 +22,8 @@ module Rigor
     # Other dry-rb adapter plugins consume this fact:
     #
     # - `rigor-dry-struct` reads it so `attribute :city, Types::String`
-    #   can promote `address.city` from `Dynamic[T]` to `Nominal[String]`
-    #   (gated on the slice-6 precision-promotion work + ADR-13
-    #   resolver chain).
+    #   promotes `address.city` from `Dynamic[Top]` to `Nominal[String]`
+    #   via ADR-18's `returns_from_arg:` fact lookup.
     # - `rigor-dry-validation` / `rigor-dry-schema` read it for
     #   per-key type recognition in `schema { … }` / `params { … }`
     #   blocks (separate plugin slice).
@@ -43,17 +42,19 @@ module Rigor
     #   "<UnderlyingClass>" }` so consumers can match on the
     #   qualified constant name they see in source.
     #
-    # The **ceiling** (slice 2+):
+    # Implemented beyond the floor:
     #
-    # - Recognises nested namespaces (`Types::Coercible::Integer`,
+    # - Nested-namespace aliases (`Types::Coercible::Integer`,
     #   `Types::Strict::Symbol`, `Types::Params::Bool`,
-    #   `Types::JSON::Date`) — each is a separate dry-types
-    #   "category" with its own coercion semantics.
-    # - Recognises user-authored compositions
-    #   (`Types::String.constrained(min_size: 1)`,
-    #   `Email = Types::String.constrained(format: …)`) so the
-    #   alias surface extends beyond the canonical names.
-    # - Emits `dry-types.unknown-alias` / `dry-types.alias-shadow`
+    #   `Types::JSON::Date`) — the four coercion categories each
+    #   map to the same underlying class as their canonical shortcut.
+    # - User-authored compositions (`Email = Types::String.constrained(...)`,
+    #   transitive resolution through composition chains) — the alias
+    #   surface extends beyond the 15 canonical names.
+    #
+    # Deferred:
+    #
+    # - `dry-types.unknown-alias` / `dry-types.alias-shadow`
     #   diagnostics when downstream code references a name that
     #   wasn't published.
     #

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

@@ -21,10 +21,9 @@ module Rigor
     #   cross-plugin fact.
     # - Ships an RBS overlay (`sig/dry_validation.rbs`) typing
     #   `Dry::Validation::Contract#call` (returns Result) and
-    #   `Dry::Validation::Result#{success?, failure?, to_h}`. Users
-    #   add the path to their `.rigor.yml`'s `signature_paths:` so
-    #   `contract.call(input).to_h` infers cleanly. See the README
-    #   for the wiring step.
+    #   `Dry::Validation::Result#{success?, failure?, to_h}`.
+    #   The manifest's `signature_paths: ["sig"]` auto-contributes
+    #   the overlay (ADR-25) — no project-side wiring needed.
     #
     # Slice 2 (deferred, per design note):
     #

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

@@ -86,14 +86,14 @@ module Rigor
         # a `Prism::SymbolNode` is treated as a literal
         # attribute reference.
         #
-        # Phase 1 (c) — when `model_index` (the cross-plugin
-        # `:model_index` fact published by rigor-activerecord)
-        # is present, the effective accepted key set is the
-        # UNION of the factory's declared attributes plus the
-        # corresponding model's columns. FactoryBot's runtime
-        # accepts any AR attribute regardless of whether the
-        # factory declared it, so the cross-check broadens the
-        # acceptance accordingly.
+        # When `model_index` (the cross-plugin `:model_index`
+        # fact published by rigor-activerecord) is present,
+        # the effective accepted key set is the UNION of the
+        # factory's declared attributes plus the corresponding
+        # model's columns. FactoryBot's runtime accepts any AR
+        # attribute regardless of whether the factory declared
+        # it, so the cross-check broadens the acceptance
+        # accordingly.
         def unknown_attribute_violations(call_node, entry, model_index)
           accepted_keys, suggestion_dictionary = effective_keys(entry, model_index)
           attr_spell_checker = DidYouMean::SpellChecker.new(dictionary: suggestion_dictionary)