rigortype 0.3.9 → 0.4.0

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,6 +39,7 @@ 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

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

@@ -23,6 +23,7 @@ module Rigor
         response_body: -> { Rigor::Type::Combinator.nominal_of("String") },
         response_headers: -> { Rigor::Type::Combinator.nominal_of("String") }
       }.freeze
+      Ractor.make_shareable(EASY_RETURN_TYPES)
 
       dynamic_return receivers: ["Ethon::Easy"], methods: EASY_RETURN_TYPES.keys do |call_node, _scope|
         builder = EASY_RETURN_TYPES[call_node.name]

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/types.rb

@@ -20,7 +20,7 @@ module Rigor
         ].to_set.freeze
 
         # Regex anchor must match end of string \z
-        NOMINAL_OPAQUE_REGEX = Regexp.new("(_ptr|_handle|Ptr|Handle)\\z")
+        NOMINAL_OPAQUE_REGEX = Regexp.new("(_ptr|_handle|Ptr|Handle)\\z").freeze
 
         BOOL_TYPE = Rigor::Type::Combinator.union(
           Rigor::Type::Combinator.constant_of(true),

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # rigor-grape — recognises the Grape endpoint-declaration DSL (`class API < Grape::API`) and the
+    # grape-entity exposure DSL (`class E < Grape::Entity`) so the calls stop reading `Dynamic[top]`
+    # (issue #1099; gitlab's `lib/api` accounted for ~10k opaque implicit-self sends in the
+    # 2026-09-19 survey — `expose` ~3.9k, `optional` ~2.2k, `route_setting` ~1.5k, `desc` ~1.4k,
+    # `requires` ~1.4k).
+    #
+    # Grape is more dynamic than the frameworks the ADR-16 substrate was built for:
+    #
+    # - `Grape::API` subclasses have NO static class methods — every declaration call is forwarded
+    #   to the base `Grape::API::Instance` class object at runtime (`delegate_missing_to` +
+    #   `override_all_methods!`, `lib/grape/api.rb`). The bundled sig declares the shared surface
+    #   once in `Grape::DSL::ClassMethods` and `extend`s it onto both `Grape::API` (reached from
+    #   source subclasses via `rbs_complete_ancestors`, ADR-43 WD4) and `Grape::API::Instance`
+    #   (reached inside `namespace` bodies, whose `self` is the Instance class object).
+    # - Block `self` bindings differ per macro family — `params` bodies `instance_eval` on a
+    #   `Grape::Validations::ParamsScope` instance, `namespace`/`route_param`/`version`/`given`/
+    #   `mounted` bodies on the Instance class object, and verb bodies run as `Grape::Endpoint`
+    #   instance methods. `block_as_methods` entries carry a named `self_type` ("Foo" /
+    #   "singleton(Foo)") so each body binds the object Grape actually evaluates it on.
+    # - `Grape::Entity`'s `expose` bodies run via `block.call` — `self` stays the Entity class
+    #   object — so nested `expose` calls need no entry; the `def self.` declarations cover them.
+    #
+    # ## Deferred (documented in README)
+    #
+    # - `helpers do ... end` bodies (`class_eval` on an anonymous Module — unnamed self).
+    # - Typing `present`/`declared` results against the declared entity/params (runtime shape).
+    class Grape < Rigor::Plugin::Base
+      # `namespace`-family bodies evaluate as instance methods of the Instance *class object*
+      # (`Instance.nest` / `evaluate_as_instance_with_configuration` do `instance_eval(&block)`).
+      # `scope` belongs here too: `Grape::DSL::Routing#scope` is `within_namespace { nest(block) }`,
+      # so its body `instance_eval`s on the same Instance class object as `namespace`.
+      NAMESPACE_METHODS = %i[
+        namespace group resource resources segment scope route_param version given mounted
+      ].freeze
+      # HTTP verb macros are generated over `Grape::HTTP_SUPPORTED_METHODS` and delegate to `route`;
+      # their bodies run inside `Grape::Endpoint` instances.
+      VERB_METHODS = %i[get put post delete head patch options route].freeze
+      # `params` bodies evaluate on a `ParamsScope` instance; the block-carrying scope macros re-enter
+      # a child scope the same way.
+      PARAMS_SCOPE_METHODS = %i[requires optional given with].freeze
+
+      manifest(
+        id: "grape",
+        target_gems: %w[grape grape-entity],
+        version: "0.1.0",
+        description: "Types the Grape endpoint-declaration DSL (`Grape::API` subclasses: `params`, " \
+                     "`namespace`, HTTP verb macros, `desc`, `route_setting`, `helpers`) and the " \
+                     "grape-entity exposure DSL (`Grape::Entity` subclasses: `expose`), including " \
+                     "the `instance_eval`'d block `self` bindings.",
+        signature_paths: ["sig"],
+        # ADR-43 WD4 — `Grape::API`/`Grape::Entity` subclasses bridge their class-level DSL calls to
+        # the bundled sig's `def self.` declarations. Justified because the bundled sig IS the
+        # authority (neither gem ships RBS) and the declared surface is what the DSL exposes.
+        rbs_complete_ancestors: %w[
+          Grape::API
+          Grape::Entity
+        ],
+        # All five classes have genuinely open runtime surfaces (`override_all_methods!` generates
+        # and forwards methods on API subclasses; ParamsScope/Endpoint pick up DSL modules) — calls
+        # we don't declare must stay opaque, not diagnosed.
+        open_receivers: %w[
+          Grape::API
+          Grape::API::Instance
+          Grape::Entity
+          Grape::Validations::ParamsScope
+          Grape::Endpoint
+        ],
+        block_as_methods: [
+          # Class-body context: `class API < Grape::API; namespace :x do ... end`.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: NAMESPACE_METHODS,
+            self_type: "singleton(Grape::API::Instance)"
+          ),
+          # Inside an already-narrowed namespace body (self is the Instance class object), nested
+          # `namespace`/`version`/`given` calls re-enter the same context.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: NAMESPACE_METHODS,
+            self_type: "singleton(Grape::API::Instance)"
+          ),
+          # `params do ... end` — body `instance_eval`s on a `ParamsScope` instance.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: %i[params],
+            self_type: "Grape::Validations::ParamsScope"
+          ),
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: %i[params],
+            self_type: "Grape::Validations::ParamsScope"
+          ),
+          # `requires :x, type: Hash do ... end` inside a params body re-enters a child ParamsScope —
+          # the receiver is already the `Nominal[ParamsScope]` `self` of the enclosing body, which is
+          # what named-instance `self_type` entries additionally match.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::Validations::ParamsScope",
+            method_names: PARAMS_SCOPE_METHODS,
+            self_type: "Grape::Validations::ParamsScope"
+          ),
+          # `desc 'x' do ... end` — the config block `instance_exec`s on a generated
+          # `SettingsContainer` subclass (`StrictHashConfiguration.config_class(*Desc::
+          # ROUTE_ATTRIBUTES)` in dsl/desc.rb): `detail`, `success`, `failure`, `tags`, `entity`,
+          # `hidden`, `is_array`, `consumes`, `headers`, … each take one value and return it.
+          # Modelled as the `Grape::DSL::Desc::ConfigContext` sig carrier — a closed surface, so a
+          # misspelt or invented setter still reads `call.undefined-method`, matching the runtime
+          # NoMethodError.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: %i[desc],
+            self_type: "Grape::DSL::Desc::ConfigContext"
+          ),
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: %i[desc],
+            self_type: "Grape::DSL::Desc::ConfigContext"
+          ),
+          # Verb bodies run inside `Grape::Endpoint` instances.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: VERB_METHODS,
+            self_type: "Grape::Endpoint"
+          ),
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: VERB_METHODS,
+            self_type: "Grape::Endpoint"
+          )
+        ]
+      )
+    end
+
+    Rigor::Plugin.register(Grape)
+  end
+end

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

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

data/plugins/rigor-grape/sig/grape.rbs

@@ -0,0 +1,263 @@
+# Bundled RBS for the Grape / grape-entity declaration DSL (issue #1099).
+#
+# Grape's class-level endpoint DSL is dynamic at runtime: `Grape::API` subclasses forward every
+# declaration call to the base `Grape::API::Instance` class object via `delegate_missing_to` /
+# `override_all_methods!` (`lib/grape/api.rb`), and the Instance class gets the real definitions
+# from the `included do ... end` bodies of `Grape::DSL::{Routing,Validations,Configuration,
+# Helpers,Callbacks,Middleware,RequestResponse}`. Both sides answer the same singleton surface, so
+# the signatures live once in `Grape::DSL::ClassMethods` and are `extend`ed onto both classes.
+#
+# Return carriers follow the runtime implementation (grape 2.4.0, grape-entity 1.0): setup-style
+# declarations return the bookkeeping collection or the stored setting value, so `::Object?` /
+# `::Array[untyped]` is the honest reading — `void` would be dishonest AND is collapsed to
+# `Dynamic[top]` by the engine's void-value-use recovery, which is exactly what this plugin exists
+# to prevent.
+#
+# Provenance (docs/agents/type-authoring.md): `rigor sig-gen` cannot produce this file — the DSL
+# methods it declares have no `def` in the gems' source (they are generated through
+# `override_all_methods!` / `delegate_missing_to` / `StrictHashConfiguration`), so every entry was
+# hand-derived by reading the grape 2.4.x / grape-entity 1.0 source. Members that do not exist at
+# that version's runtime location are deliberately absent — declaring them would let a genuinely
+# failing call resolve silently.
+#
+# Block `self` bindings are NOT modelled here — they come from the manifest's `block_as_methods`
+# entries (`params` bodies on `Grape::Validations::ParamsScope`, `namespace` bodies on the
+# `Grape::API::Instance` class object, verb bodies on `Grape::Endpoint`).
+
+module Grape
+  module DSL
+    # Class-level declaration surface shared by `Grape::API` subclasses and `Grape::API::Instance`.
+    module ClassMethods
+      # Validations — `params` opens a `Grape::Validations::ParamsScope` and `instance_eval`s the
+      # block on it; returns the new scope (dsl/validations.rb).
+      def params: () ?{ () -> untyped } -> Grape::Validations::ParamsScope
+      def contract: (?untyped) ?{ () -> untyped } -> ::Object?
+
+      # Routing — the HTTP verbs are generated over `Grape::HTTP_SUPPORTED_METHODS` and delegate to
+      # `route` (`def route(methods, paths = ['/'], route_options = {}, &block)`).
+      def get: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def put: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def post: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def delete: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def head: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def patch: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def options: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def route: (untyped, ?untyped, ?untyped) ?{ () -> untyped } -> ::Object?
+
+      # Namespace family — `namespace`/`scope`/`route_param`/`version`/`given`/`mounted`
+      # `instance_eval` their block on the Instance class object and return the block's value.
+      # `group`/`resource`/`resources`/`segment` are aliases of `namespace`; `scope` routes
+      # through `within_namespace { nest(block) }` (dsl/routing.rb).
+      def namespace: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def route_param: (untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def group: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def resource: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def resources: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def segment: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def version: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def given: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def mounted: () { () -> untyped } -> ::Object?
+      def mount: (untyped, *untyped) -> ::Object?
+      def scope: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def prefix: (?untyped) -> ::Object?
+
+      # Settings / configuration (dsl/settings.rb, dsl/configuration.rb).
+      def route_setting: (untyped, ?untyped) -> ::Object?
+      def unset_route_setting: (untyped) -> ::Object?
+      def global_setting: (untyped, ?untyped) -> ::Object?
+      def unset_global_setting: (untyped) -> ::Object?
+      # `description` / `entity` / `detail` / `failure` / `success` and friends are NOT API-level
+      # methods — they belong to the anonymous `config_context` a `desc` block `instance_exec`s on
+      # (`Grape::Util::StrictHashConfiguration`). That surface is deferred (README); declaring the
+      # names here would silently resolve calls that fail at runtime.
+      def desc: (untyped, ?untyped) ?{ () -> untyped } -> ::Object?
+      def content_type: (untyped, untyped) -> ::Object?
+      def default_format: (?untyped) -> ::Object?
+      def format: (?untyped) -> ::Object?
+      def formatter: (untyped, untyped) -> ::Object?
+      def parser: (untyped, untyped) -> ::Object?
+      def default_error_formatter: (?untyped) -> ::Object?
+      def default_error_status: (?untyped) -> ::Object?
+      def error_formatter: (untyped, untyped) -> ::Object?
+      def cascade: (?untyped) -> ::Object?
+      def do_not_route_head!: () -> ::Object?
+      def do_not_route_options!: () -> ::Object?
+      def do_not_document!: () -> ::Object?
+      def http_basic: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def auth: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def http_digest: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def rescue_from: (*untyped, **untyped) ?{ (*untyped) -> untyped } -> ::Object?
+      # `represent` forwards to `Entity.represent`, whose result is an entity, an array of
+      # entities, or a `{root => inner}` Hash depending on the call — untyped is the honest
+      # carrier (a `::Object` return invents `undefined method` findings on every chained call).
+      # Runtime arity is `represent(model_class, options)` (dsl/request_response.rb).
+      def represent: (untyped, untyped) -> untyped
+
+      # Helpers / middleware / callbacks.
+      def helpers: (*untyped) ?{ () -> untyped } -> ::Object?
+      def use: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def middleware: () -> ::Object?
+      def insert_before: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def insert_after: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def before: () { () -> untyped } -> ::Object?
+      def before_validation: () { () -> untyped } -> ::Object?
+      def after_validation: () { () -> untyped } -> ::Object?
+      def after: () { () -> untyped } -> ::Object?
+      def finally: () { () -> untyped } -> ::Object?
+    end
+
+    module Desc
+      # The `instance_exec` target of a `desc 'x' do ... end` config block. At runtime this is an
+      # anonymous class built by `StrictHashConfiguration.config_class(*Desc::ROUTE_ATTRIBUTES)`
+      # (`dsl/desc.rb` `desc_container`) — a CLOSED surface of one-argument setters that store and
+      # return the assigned value (`@settings[name] = new_value`), plus the `success`/`failure`
+      # aliases singleton-defined on the context. Names outside `ROUTE_ATTRIBUTES` raise
+      # `NoMethodError` at runtime, so this receiver stays out of `open_receivers`: an undeclared
+      # call inside a `desc` block genuinely fails.
+      class ConfigContext
+        def body_name: (untyped) -> ::Object?
+        def consumes: (untyped) -> ::Object?
+        def default: (untyped) -> ::Object?
+        def deprecated: (untyped) -> ::Object?
+        def description: (untyped) -> ::Object?
+        def detail: (untyped) -> ::Object?
+        def entity: (untyped) -> ::Object?
+        def headers: (untyped) -> ::Object?
+        def hidden: (untyped) -> ::Object?
+        def http_codes: (untyped) -> ::Object?
+        def is_array: (untyped) -> ::Object?
+        def named: (untyped) -> ::Object?
+        def nickname: (untyped) -> ::Object?
+        def params: (untyped) -> ::Object?
+        def produces: (untyped) -> ::Object?
+        def security: (untyped) -> ::Object?
+        def summary: (untyped) -> ::Object?
+        def tags: (untyped) -> ::Object?
+        def success: (*untyped) -> ::Object?
+        def failure: (*untyped) -> ::Object?
+        def configuration: () -> untyped
+        def to_hash: () -> ::Hash[untyped, untyped]
+      end
+    end
+  end
+
+  class API
+    extend DSL::ClassMethods
+
+    # The class object a `Grape::API` subclass's declaration calls are forwarded to. `namespace`
+    # bodies `instance_eval` on this class object, so the same `extend`ed surface covers calls made
+    # inside them.
+    class Instance
+      extend DSL::ClassMethods
+    end
+  end
+
+  module Validations
+    # The receiver `params`/`requires`/`optional`/`given`/`with` blocks `instance_eval` on. Its
+    # DSL lives in `Grape::DSL::Parameters`; the declarations here cover the block-relevant and
+    # commonly-called subset.
+    class ParamsScope
+      def requires: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def optional: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def given: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def with: (*untyped, **untyped) ?{ () -> untyped } -> ::Object?
+      def use: (*untyped) -> ::Object?
+      def mutually_exclusive: (*untyped) -> ::Object?
+      def exactly_one_of: (*untyped) -> ::Object?
+      def at_least_one_of: (*untyped) -> ::Object?
+      def all_or_none_of: (*untyped) -> ::Object?
+    end
+  end
+
+  # Runtime route context — verb bodies execute as `Grape::Endpoint` instance methods
+  # (`Grape::Endpoint#run` evaluates the stored block inside the endpoint instance). The methods
+  # here are `Grape::DSL::InsideRoute`, `Grape::DSL::Headers`, `Grape::DSL::Settings`, and the
+  # `def_delegators :request` surface (`params`/`headers`/`cookies`).
+  class Endpoint
+    def params: () -> ::Hash[untyped, untyped]
+    def headers: () -> ::Hash[untyped, untyped]
+    # `Endpoint#cookies` delegates to `Grape::Request#cookies`, which builds a `Grape::Cookies`
+    # wrapper — not a Hash (`lib/grape/cookies.rb`, `lib/grape/request.rb`).
+    def cookies: () -> Grape::Cookies
+    def env: () -> ::Hash[untyped, untyped]
+    # `request` is a `Grape::Request` (Rack::Request subclass) at runtime — untyped rather than
+    # `::Object` so `request.params`/`request.GET` chains don't read as undefined-method findings.
+    def request: () -> untyped
+    def declared: (*untyped, **untyped) -> ::Hash[untyped, untyped]
+    def version: () -> ::Object?
+    def error!: (*untyped, **untyped) -> bot
+    def redirect: (untyped url, ?permanent: untyped, ?body: untyped) -> ::Object?
+    def status: (?untyped) -> ::Object?
+    def content_type: (?untyped) -> ::Object?
+    def body: (?untyped) -> ::Object?
+    # `present` returns the representation (entity, Hash, or the bare object) — untyped.
+    def present: (*untyped, **untyped) -> untyped
+    # `route` is the `Grape::Router::Route` for the current endpoint — untyped.
+    def route: () -> untyped
+    def header: (?untyped, ?untyped) -> ::Object?
+    def route_setting: (untyped, ?untyped) -> ::Object?
+    def stream: (?untyped) -> ::Object?
+    def sendfile: (?untyped) -> ::Object?
+    # `error_response` lives on `Grape::Middleware::Error`, not on the endpoint — not declared here.
+  end
+
+  # The Rack-cookie wrapper `Grape::Request#cookies` returns (`def_delegators :cookies` for `[]`
+  # and `each`, plus its own `[]=` / `delete` / `response_cookies`). Not a Hash.
+  class Cookies
+    def []: (untyped) -> untyped
+    def []=: (untyped, untyped) -> untyped
+    def each: (*untyped) ?{ (*untyped) -> untyped } -> untyped
+    def response_cookies: () { (untyped, untyped) -> untyped } -> untyped
+    def delete: (untyped, **untyped) -> untyped
+  end
+
+  # grape-entity's declaration target (`class Foo < Grape::Entity`). `expose` bodies run via
+  # `block.call` — `self` stays the Entity subclass's class object — so nested `expose` calls
+  # resolve through the same singleton surface without a `block_as_methods` entry.
+  class Entity
+    def self.expose: (*untyped, **untyped) ?{ () -> untyped } -> ::Array[untyped]
+    def self.unexpose: (*untyped) -> ::Object?
+    def self.unexpose_all: () -> ::Object?
+    def self.with_options: (untyped) { () -> untyped } -> ::Object?
+    def self.documentation: () -> ::Hash[untyped, untyped]
+    # Returns `formatters[name.to_sym] = block` — the registered Proc.
+    def self.format_with: (untyped) { (untyped) -> untyped } -> ::Proc
+    def self.root: (untyped, ?untyped) -> ::Object?
+    def self.root_element: (untyped) -> ::Object?
+    # Result is an Entity instance, an Array of them, or a `{root => inner}` Hash
+    # (`lib/grape_entity/entity.rb` `self.represent`) — untyped, not `::Object`, so chained
+    # `serializable_hash` / `map` / exposed-attribute reads stay quiet.
+    def self.represent: (*untyped, **untyped) -> untyped
+    def self.present_collection: (?untyped, ?untyped) -> ::Object?
+    # Runtime returns `Exposure::NestingExposure::NestedExposures` — an `Enumerable` wrapper with
+    # `find_by` / `select_by` / `delete_by` that Array does not have.
+    def self.root_exposures: () -> Exposure::NestingExposure::NestedExposures
+
+    # The instance-side output surface — `serializable_hash` is the primary representation
+    # output (`nil` when the wrapped object is nil); `as_json`/`to_json` delegate to it.
+    def serializable_hash: (?untyped) -> ::Hash[untyped, untyped]?
+    def as_json: (*untyped, **untyped) -> untyped
+
+    module Exposure
+      class NestingExposure
+        # `Enumerable` wrapper over the exposure list (grape-entity `nested_exposures.rb`):
+        # `each`/`to_ary`/`to_a`/`[]`/`size`/`empty?`/`==` delegate to the inner Array, and
+        # `find_by`/`select_by`/`delete_by`/`<<`/`clear` are its own API.
+        class NestedExposures
+          include Enumerable[untyped]
+          def find_by: (untyped) -> untyped
+          def select_by: (untyped) -> untyped
+          def <<: (untyped) -> untyped
+          def delete_by: (*untyped) -> untyped
+          def clear: () -> untyped
+          def to_ary: () -> ::Array[untyped]
+          def to_a: () -> ::Array[untyped]
+          def []: (*untyped) -> untyped
+          def ==: (untyped) -> bool
+          def size: () -> ::Integer
+          def empty?: () -> bool
+        end
+      end
+    end
+  end
+end

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

@@ -40,6 +40,21 @@ module Rigor
     #   required: ...` declarations.
     # - No user-facing diagnostics yet.
     #
+    # ## Shipped DSL signature (`sig/graphql.rbs`)
+    #
+    # Since graphql-ruby ships no RBS, the manifest's `signature_paths:` contributes the class-level
+    # DSL surface — `field`/`argument`/`value`/`implements`/`description`/`graphql_name` and friends —
+    # following graphql-ruby's real `Member`-rooted ancestry so subclass bodies stop reading every
+    # DSL call as `Dynamic[top]`. Return types are the real carriers (`field` → `Schema::Field`,
+    # `Enum.value` → `Schema::EnumValue`, setter/getter macros → their configured value) rather than
+    # `void`, which the engine recovers as `top`. Scope and deferrals are documented at the top of
+    # the sig file.
+    #
+    # The declared classes stay in `open_receivers:` because graphql-ruby's real surface is open:
+    # schema plugins (`use`-able extensions) and user base classes add class-level DSL methods this
+    # signature does not enumerate, so `call.undefined-method` must not read these classes as
+    # closed.
+    #
     # ## Deferred (demand-driven)
     #
     # - **`resolver:` / `mutation:` reroute** recognition.
@@ -51,11 +66,66 @@ module Rigor
       manifest(
         id: "graphql",
         target_gems: ["graphql"],
-        version: "0.1.0",
+        # 0.2.0, 2026-09-20 (#1100) — `signature_paths:` contributes the graphql-ruby class-level DSL
+        # surface (`field`/`argument`/`value`/…), typed with the real carriers (`Field`/`Argument`/
+        # `EnumValue`/…) so DSL calls stop reading `Dynamic[top]` inside recognised subclasses.
+        version: "0.2.0",
         description: "Recognises `class T < GraphQL::Schema::{Object,Enum,InputObject,Mutation}` " \
                      "subclasses; publishes the per-type field-type table, the per-enum value " \
                      "list, the per-input-object argument table, and the per-mutation arguments+fields " \
-                     "table.",
+                     "table; ships the graphql-ruby class-level DSL signature surface.",
+        signature_paths: ["sig"],
+        # ADR-43 WD4 — the classes the bundled sig covers completely enough that a Ruby-source subclass
+        # (`class PostType < GraphQL::Schema::Object`) may bridge inherited calls to the RBS ancestor.
+        # Listing one turns on `call.undefined-method`/arity checks for inherited DSL calls on every
+        # subclass — justified here because the sig IS the authority (graphql-ruby ships none).
+        rbs_complete_ancestors: %w[
+          GraphQL::Schema
+          GraphQL::Schema::Member
+          GraphQL::Schema::Object
+          GraphQL::Schema::Resolver
+          GraphQL::Schema::Mutation
+          GraphQL::Schema::RelayClassicMutation
+          GraphQL::Schema::Subscription
+          GraphQL::Schema::InputObject
+          GraphQL::Schema::Enum
+          GraphQL::Schema::EnumValue
+          GraphQL::Schema::Union
+          GraphQL::Schema::Scalar
+          GraphQL::Schema::Directive
+          GraphQL::Schema::Field
+          GraphQL::Schema::Argument
+          GraphQL::Dataloader::Source
+          GraphQL::Types::Relay::BaseConnection
+          GraphQL::Types::Relay::BaseEdge
+          GraphQL::Types::Relay::PageInfo
+          GraphQL::Types::Relay::BaseField
+        ],
+        open_receivers: %w[
+          GraphQL::Schema
+          GraphQL::Schema::Member
+          GraphQL::Schema::Object
+          GraphQL::Schema::Resolver
+          GraphQL::Schema::Mutation
+          GraphQL::Schema::RelayClassicMutation
+          GraphQL::Schema::Subscription
+          GraphQL::Schema::InputObject
+          GraphQL::Schema::Enum
+          GraphQL::Schema::EnumValue
+          GraphQL::Schema::Union
+          GraphQL::Schema::Scalar
+          GraphQL::Schema::Directive
+          GraphQL::Schema::Field
+          GraphQL::Schema::Argument
+          GraphQL::Schema::Interface
+          GraphQL::Query
+          GraphQL::Query::Context
+          GraphQL::Dataloader
+          GraphQL::Dataloader::Source
+          GraphQL::Types::Relay::BaseConnection
+          GraphQL::Types::Relay::BaseEdge
+          GraphQL::Types::Relay::BaseField
+        ],
         produces: %i[graphql_type_table graphql_enum_table graphql_input_object_table graphql_mutation_table]
       )