rigortype 0.1.4 → 0.1.6

data/lib/rigor/rbs_extended.rb

@@ -4,6 +4,7 @@ require_relative "type"
 require_relative "builtins/imported_refinements"
 require_relative "flow_contribution"
 require_relative "rbs_extended/reporter"
+require_relative "rbs_extended/hkt_directives"
 
 module Rigor
   # Slice 7 phase 15 — first-preview reader for the
@@ -385,13 +386,15 @@ module Rigor
 
       name_scope = environment&.name_scope
       reporter = environment&.rbs_extended_reporter
+      hkt_registry = environment&.hkt_registry
 
       annotations.each do |annotation|
         type = parse_return_type_override(
           annotation.string,
           name_scope: name_scope,
           reporter: reporter,
-          source_location: annotation.location
+          source_location: annotation.location,
+          hkt_registry: hkt_registry
         )
         return type if type
       end
@@ -417,10 +420,40 @@ module Rigor
     /x
     private_constant :RETURN_DIRECTIVE_PATTERN
 
-    def parse_return_type_override(string, name_scope: nil, reporter: nil, source_location: nil)
+    # ADR-20 slice 2d — recognises `App[<uri>, <ClassName>, ...]`
+    # syntax in a `rigor:v1:return:` payload before falling
+    # through to the refinement-name parser. The match captures
+    # the namespaced URI (`json::value`) plus a comma-separated
+    # list of bare class names (`String`, `Symbol`, `Integer`).
+    # Slice 2d keeps the arg vocabulary intentionally narrow;
+    # parameterised forms (`Array[T]`, `Hash[K, V]`), unions,
+    # and refinements inside `App[...]` wait for a follow-up
+    # slice's expression parser.
+    APP_PAYLOAD_PATTERN = /
+      \A
+      App\[
+      \s*
+      (?<uri>[a-z_][a-z0-9_]*(?:::[a-z_][a-z0-9_]*)+)
+      \s*,\s*
+      (?<args>[^\[\]]+?)
+      \s*\]
+      \z
+    /x
+    private_constant :APP_PAYLOAD_PATTERN
+
+    def parse_return_type_override(string, name_scope: nil, reporter: nil, source_location: nil, hkt_registry: nil)
       match = RETURN_DIRECTIVE_PATTERN.match(string)
       return nil if match.nil?
 
+      app_type = parse_app_payload(
+        match[:payload],
+        name_scope: name_scope,
+        reporter: reporter,
+        source_location: source_location,
+        hkt_registry: hkt_registry
+      )
+      return app_type if app_type
+
       type = Builtins::ImportedRefinements.parse(
         match[:payload],
         name_scope: name_scope,
@@ -431,6 +464,53 @@ module Rigor
       type
     end
 
+    # ADR-20 slice 2d. Parses `App[<uri>, <ClassName>, ...]`
+    # syntax into a `Rigor::Type::App`. When `hkt_registry` is
+    # supplied and the URI is registered with a body_tree, the
+    # `App` is reduced eagerly via {Inference::HktRegistry#reduce}
+    # so call sites observe the unfolded form (e.g.
+    # `Union[nil, true, false, ..., Array[App[json::value,
+    # String]], Hash[String, App[json::value, String]]]`)
+    # rather than the opaque carrier. When the registry is
+    # absent or the URI is unregistered, the carrier with its
+    # registry-supplied bound (or `untyped` as a last-resort
+    # fallback) is returned as-is.
+    def parse_app_payload(payload, name_scope: nil, reporter: nil, source_location: nil, hkt_registry: nil)
+      match = APP_PAYLOAD_PATTERN.match(payload)
+      return nil if match.nil?
+
+      uri = match[:uri].to_sym
+      arg_classes = match[:args].split(",").map(&:strip)
+      args = arg_classes.map { |name| resolve_app_arg(name, name_scope: name_scope) }
+
+      if args.any?(&:nil?)
+        record_unresolved(reporter, "App payload `#{payload}`: unresolved arg class name", source_location)
+        return nil
+      end
+
+      registration = hkt_registry&.registration(uri)
+      bound = registration&.bound || Type::Combinator.untyped
+      app = Type::App.new(uri, args, bound: bound)
+
+      return app if hkt_registry.nil? || !hkt_registry.defined?(uri)
+
+      reduced = hkt_registry.reduce(app)
+      reduced || app
+    end
+
+    def resolve_app_arg(class_name, name_scope: nil)
+      return nil unless /\A(?:::)?(?:[A-Z]\w*)(?:::[A-Z]\w*)*\z/.match?(class_name)
+
+      normalized = class_name.sub(/\A::/, "")
+      return Type::Nominal.new(normalized) if name_scope.nil?
+
+      if name_scope.respond_to?(:nominal_for_name)
+        resolved = name_scope.nominal_for_name(normalized)
+        return resolved if resolved
+      end
+      Type::Nominal.new(normalized)
+    end
+
     # Returned for `rigor:v1:param: <name> <refinement>`. The
     # parameter name is a Ruby identifier (Symbol); the type
     # is any `Rigor::Type` the refinement parser resolves

data/lib/rigor/sig_gen/generator.rb

@@ -52,6 +52,15 @@ module Rigor
         @paths = paths
         @observations = normalize_observations(observations)
         @include_private = include_private
+        # Per-file scratch state. `analyse_file` resets each
+        # one to a fresh container for every file walked so
+        # candidates from one file don't leak into another;
+        # initialising empty here gives downstream consumers
+        # (`build_candidate`, `method_def_prefix`) a never-nil
+        # invariant without per-call-site defensive guards.
+        @namespace_kinds = {}
+        @module_function_methods = Set.new
+        @class_shells = Set.new
       end
 
       # Lifts legacy plain-`Array[Type]` observation entries
@@ -270,8 +279,8 @@ module Rigor
       # `Const = Data.define(...)` declarations.
       def build_candidate(**)
         MethodCandidate.new(
-          namespace_kinds: @namespace_kinds || {},
-          class_shells: (@class_shells || Set.new).to_a,
+          namespace_kinds: @namespace_kinds,
+          class_shells: @class_shells.to_a,
           **
         )
       end
@@ -282,7 +291,7 @@ module Rigor
       # dispatch at runtime), or "def " (plain instance).
       def method_def_prefix(class_name, method_name, kind)
         return "def self." if kind == :singleton
-        return "def self?." if @module_function_methods&.include?([class_name, method_name])
+        return "def self?." if @module_function_methods.include?([class_name, method_name])
 
         "def "
       end

data/lib/rigor/trinary.rb

@@ -10,18 +10,16 @@ module Rigor
   class Trinary
     VALUES = %i[yes no maybe].freeze
 
+    # ADR-15 Phase 4b.x — eager singleton instances so the
+    # class-level `@yes` / `@no` / `@maybe` ivars are populated
+    # on the main Ractor at load time. Workers READ the ivars
+    # via `Trinary.yes` etc. without performing the `||=`
+    # write that non-main Ractors are forbidden from doing.
+    # The actual `@yes = new(:yes).freeze` allocation happens
+    # at the bottom of the file, AFTER `def initialize` is
+    # defined.
     class << self
-      def yes
-        @yes ||= new(:yes).freeze
-      end
-
-      def no
-        @no ||= new(:no).freeze
-      end
-
-      def maybe
-        @maybe ||= new(:maybe).freeze
-      end
+      attr_reader :yes, :no, :maybe
 
       def from_symbol(symbol)
         case symbol
@@ -104,5 +102,11 @@ module Rigor
 
       raise TypeError, "expected Rigor::Trinary, got #{other.class}"
     end
+
+    # ADR-15 Phase 4b.x eager singletons (see `class << self`
+    # above). Allocated after `initialize` is defined.
+    @yes = new(:yes).freeze
+    @no = new(:no).freeze
+    @maybe = new(:maybe).freeze
   end
 end

data/lib/rigor/type/app.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "../trinary"
+
+module Rigor
+  module Type
+    # A defunctionalised higher-kinded type application — the abstract
+    # "apply type-constructor `uri` to argument list `args`" carrier.
+    #
+    # `uri` is a namespaced `Symbol` of the form `:author::name`
+    # (e.g. `:"json::value"`, `:"dry_monads::result"`); the `::`
+    # namespace separator is mandatory per ADR-20 WD1 to prevent
+    # cross-plugin tag collisions.
+    #
+    # `args` is an ordered, frozen `Array` of `Rigor::Type` values
+    # carrying the application's argument list. At least one argument
+    # is required; arity-zero "HKT" forms are not modelled by this
+    # carrier (use a plain type alias instead).
+    #
+    # `bound` is a `Rigor::Type` representing the value Rigor MUST
+    # erase to when this `App` cannot be reduced — registered at
+    # `%a{rigor:v1:hkt_register}` time, defaulting to
+    # `Rigor::Type::Dynamic[Rigor::Type::Top]` per ADR-20 D5 / WD2. It
+    # also drives the lattice probes (`top` / `bot` / `dynamic`) and
+    # the acceptance fallback while no reduction is wired (Slice 1).
+    #
+    # Slice 1 ships the carrier as **opaque**: every operation
+    # delegates to `bound` since no reduction surface exists yet. Slice
+    # 2 introduces the conditional / indexed-access evaluator that
+    # reduces `App` to its registered body before delegating; the
+    # carrier shape stays identical.
+    #
+    # Display form per ADR-20 OQ5: bare RBS-style `uri[arg1, arg2]`,
+    # not the wrapped `App[uri, [arg1, arg2]]` faithful form. Two
+    # `App` values are structurally equal iff their `uri`, `args`,
+    # AND `bound` match.
+    #
+    # See docs/adr/20-lightweight-hkt.md.
+    class App
+      URI_SEPARATOR = "::"
+
+      attr_reader :uri, :args, :bound
+
+      def initialize(uri, args, bound:)
+        raise ArgumentError, "uri must be a Symbol, got #{uri.class}" unless uri.is_a?(Symbol)
+        unless uri.to_s.include?(URI_SEPARATOR)
+          raise ArgumentError,
+                "uri must be namespaced as `:author#{URI_SEPARATOR}name` per ADR-20 WD1, got #{uri.inspect}"
+        end
+        raise ArgumentError, "args must be an Array, got #{args.class}" unless args.is_a?(Array)
+        raise ArgumentError, "args must be non-empty (use a plain type alias for arity-0 forms)" if args.empty?
+        raise ArgumentError, "bound must be a Rigor type, got #{bound.class}" if bound.nil?
+
+        @uri = uri
+        @args = args.dup.freeze
+        @bound = bound
+        freeze
+      end
+
+      def describe(verbosity = :short)
+        rendered = args.map { |t| t.describe(verbosity) }.join(", ")
+        "#{uri}[#{rendered}]"
+      end
+
+      def erase_to_rbs
+        bound.erase_to_rbs
+      end
+
+      def top
+        bound.top
+      end
+
+      def bot
+        bound.bot
+      end
+
+      def dynamic
+        bound.dynamic
+      end
+
+      def accepts(other, mode: :gradual)
+        Inference::Acceptance.accepts(bound, other, mode: mode)
+      end
+
+      def ==(other)
+        other.is_a?(App) && uri == other.uri && args == other.args && bound == other.bound
+      end
+      alias eql? ==
+
+      def hash
+        [App, uri, args, bound].hash
+      end
+
+      def inspect
+        "#<Rigor::Type::App #{describe(:short)} (bound=#{bound.describe(:short)})>"
+      end
+
+      # ADR-20 Slice 2a — reduce this application against a
+      # registry. Returns the reducer's output (`bound` when
+      # reduction is blocked or fuel exhausts).
+      def reduce(registry, fuel: nil)
+        fuel ||= Inference::HktReducer::DEFAULT_FUEL
+        registry.reduce(self, fuel: fuel)
+      end
+    end
+  end
+end

data/lib/rigor/type/bot.rb

@@ -8,10 +8,13 @@ module Rigor
     # expressions that cannot terminate normally. See
     # docs/type-specification/special-types.md.
     class Bot
+      # ADR-15 Phase 4b.x — eager singleton so workers READ
+      # `@instance` without performing the lazy `||=` write
+      # that non-main Ractors are forbidden from doing.
+      @instance = new.freeze
+
       class << self
-        def instance
-          @instance ||= new.freeze
-        end
+        attr_reader :instance
 
         private :new
       end

data/lib/rigor/type/combinator.rb

@@ -36,8 +36,14 @@ module Rigor
         Bot.instance
       end
 
+      # ADR-15 Phase 4b.x — read the eagerly-allocated
+      # `@untyped` ivar instead of `||=`. The singleton-class
+      # `@untyped = Dynamic.new(top)` initializer runs at module
+      # body (below) on the main Ractor at load time. Workers
+      # READ the populated ivar without performing the lazy
+      # write that non-main Ractors are forbidden from doing.
       def untyped
-        @untyped ||= Dynamic.new(top)
+        @untyped
       end
 
       # Wraps the static facet in a Dynamic[T] carrier. Idempotent on the
@@ -809,6 +815,11 @@ module Rigor
           members.sort_by { |m| m.describe(:short) }
         end
       end
+
+      # ADR-15 Phase 4b.x — eager-allocate the singleton
+      # `Dynamic[Top]` carrier on the main Ractor at load time.
+      # The `untyped` reader above just returns this ivar.
+      @untyped = Dynamic.new(Top.instance)
     end
   end
 end

data/lib/rigor/type/integer_range.rb

@@ -78,13 +78,13 @@ module Rigor
         Float::INFINITY
       end
 
-      ALIAS_NAMES = {
-        [NEG_INFINITY, POS_INFINITY] => "int",
-        [1, POS_INFINITY] => "positive-int",
-        [0, POS_INFINITY] => "non-negative-int",
-        [NEG_INFINITY, -1] => "negative-int",
-        [NEG_INFINITY, 0] => "non-positive-int"
-      }.freeze
+      ALIAS_NAMES = Ractor.make_shareable({
+                                            [NEG_INFINITY, POS_INFINITY] => "int",
+                                            [1, POS_INFINITY] => "positive-int",
+                                            [0, POS_INFINITY] => "non-negative-int",
+                                            [NEG_INFINITY, -1] => "negative-int",
+                                            [NEG_INFINITY, 0] => "non-positive-int"
+                                          })
 
       def describe(_verbosity = :short)
         ALIAS_NAMES[[min, max]] || generic_description

data/lib/rigor/type/refined.rb

@@ -165,18 +165,24 @@ module Rigor
       # kebab-case canonical name. Registered shapes print
       # through `describe`; unregistered combinations fall back
       # to the operator form.
-      CANONICAL_NAMES = {
-        ["String", :lowercase] => "lowercase-string",
-        ["String", :not_lowercase] => "non-lowercase-string",
-        ["String", :uppercase] => "uppercase-string",
-        ["String", :not_uppercase] => "non-uppercase-string",
-        ["String", :numeric] => "numeric-string",
-        ["String", :not_numeric] => "non-numeric-string",
-        ["String", :decimal_int] => "decimal-int-string",
-        ["String", :octal_int] => "octal-int-string",
-        ["String", :hex_int] => "hex-int-string",
-        ["String", :literal_string] => "literal-string"
-      }.freeze
+      #
+      # ADR-15 Phase 4b.x — `Ractor.make_shareable` (not `.freeze`)
+      # because the keys are nested two-element Arrays. Plain
+      # `.freeze` would leave the inner arrays mutable, so a
+      # worker Ractor reading `CANONICAL_NAMES[[base, predicate]]`
+      # would trip `Ractor::IsolationError`.
+      CANONICAL_NAMES = Ractor.make_shareable({
+                                                ["String", :lowercase] => "lowercase-string",
+                                                ["String", :not_lowercase] => "non-lowercase-string",
+                                                ["String", :uppercase] => "uppercase-string",
+                                                ["String", :not_uppercase] => "non-uppercase-string",
+                                                ["String", :numeric] => "numeric-string",
+                                                ["String", :not_numeric] => "non-numeric-string",
+                                                ["String", :decimal_int] => "decimal-int-string",
+                                                ["String", :octal_int] => "octal-int-string",
+                                                ["String", :hex_int] => "hex-int-string",
+                                                ["String", :literal_string] => "literal-string"
+                                              })
       private_constant :CANONICAL_NAMES
 
       # Bidirectional `predicate_id ↔ complement_predicate_id`

data/lib/rigor/type/top.rb

@@ -7,10 +7,11 @@ module Rigor
     # The top of the value lattice: contains every value, including untyped
     # boundaries. See docs/type-specification/special-types.md.
     class Top
+      # ADR-15 Phase 4b.x — eager singleton (see Bot.rb).
+      @instance = new.freeze
+
       class << self
-        def instance
-          @instance ||= new.freeze
-        end
+        attr_reader :instance
 
         private :new
       end

data/lib/rigor/type.rb

@@ -23,6 +23,7 @@ require_relative "type/union"
 require_relative "type/difference"
 require_relative "type/refined"
 require_relative "type/intersection"
+require_relative "type/app"
 require_relative "type/bound_method"
 require_relative "type/accepts_result"
 require_relative "type/combinator"

data/lib/rigor/type_node/generic.rb

@@ -38,7 +38,13 @@ module Rigor
                 "TypeNode::IntegerLiteral, got #{args.inspect}"
         end
 
-        super(head: head, args: args.freeze)
+        # Freeze the String head + Array args so the Data
+        # object is `Ractor.shareable?`. Each `a` is already a
+        # shareable TypeNode value object (checked above), so
+        # freezing the wrapping Array is sufficient.
+        frozen_head = head.frozen? ? head : head.dup.freeze
+        frozen_args = args.frozen? ? args : args.dup.freeze
+        super(head: frozen_head, args: frozen_args)
       end
 
       private

data/lib/rigor/type_node/identifier.rb

@@ -23,7 +23,15 @@ module Rigor
                 "got #{name.inspect}"
         end
 
-        super
+        # Freeze the String field so the resulting Data object
+        # is `Ractor.shareable?` regardless of whether the
+        # caller passed a `# frozen_string_literal: true`
+        # constant or a dynamically built String. The same
+        # discipline applies to every other TypeNode value
+        # object — they live in the parser's hot path and are
+        # the natural carriers to flow through future Ractor
+        # boundaries (see CURRENT_WORK Open Items #8).
+        super(name: name.frozen? ? name : name.dup.freeze)
       end
     end
   end

data/lib/rigor/type_node/string_literal.rb

@@ -22,7 +22,10 @@ module Rigor
                 "got #{value.inspect}"
         end
 
-        super
+        # Freeze the String field so the Data object is
+        # `Ractor.shareable?` regardless of caller frozen-
+        # string-literal state.
+        super(value: value.frozen? ? value : value.dup.freeze)
       end
     end
   end

data/lib/rigor/version.rb

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

data/sig/rigor/environment.rbs

@@ -8,19 +8,25 @@ module Rigor
     attr_reader rbs_loader: RbsLoader?
     attr_reader plugin_registry: untyped?
     attr_reader dependency_source_index: untyped?
-    attr_reader rbs_extended_reporter: untyped?
-    attr_reader boundary_cross_reporter: untyped?
+    attr_reader reporters: untyped
     attr_reader name_scope: untyped?
+    attr_reader synthetic_method_index: untyped?
+    attr_reader project_patched_methods: untyped?
+    attr_reader hkt_registry: untyped?
 
     def self.default: () -> Environment
-    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?) -> Environment
+    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?bundler_bundle_path: String?, ?bundler_auto_detect: bool, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> Environment
 
-    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?) -> void
+    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> void
+    def rbs_extended_reporter: () -> untyped?
+    def boundary_cross_reporter: () -> untyped?
+    def attach_reporters!: (rbs_extended_reporter: untyped?, boundary_cross_reporter: untyped?) -> nil
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?
     def class_known?: (String | Symbol name) -> bool
     def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
+    def reflection: () -> untyped?
 
     class ClassRegistry
       def self.default: () -> ClassRegistry
@@ -42,6 +48,7 @@ module Rigor
       def self.default: () -> RbsLoader
       def self.reset_default!: () -> void
       def self.build_env_for: (libraries: Array[String], signature_paths: Array[String | _ToPath]) -> untyped
+      def self.vendored_gem_sig_paths: () -> Array[Pathname]
 
       def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath], ?cache_store: untyped?) -> void
       def class_known?: (String | Symbol name) -> bool

data/sig/rigor/inference.rbs

@@ -134,6 +134,8 @@ module Rigor
       def self?.index: (untyped root, default_scope: Scope) -> Hash[untyped, Scope]
       def self?.build_declaration_overrides: (untyped root) -> Hash[untyped, Type::t]
       def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] identity_table, Hash[String, Type::t] discovered) -> void
+      def self?.discovered_classes_for_paths: (Array[String] paths, ?buffer: untyped) -> Hash[String, Type::t]
+      def self?.collect_class_decls: (untyped node, Array[String] qualified_prefix, Hash[String, Type::t] accumulator) -> void
       def self?.qualified_name_for: (untyped constant_path_node) -> String?
       def self?.render_constant_path: (untyped node) -> String
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void

data/sig/rigor/plugin/blueprint.rbs

@@ -0,0 +1,7 @@
+class Rigor::Plugin::Blueprint
+  attr_reader klass_name: String
+  attr_reader config: Hash[untyped, untyped]
+
+  def initialize: (klass_name: String | Module, ?config: Hash[untyped, untyped]) -> void
+  def materialize: (services: untyped) -> Rigor::Plugin::Base
+end

data/sig/rigor/plugin/manifest.rbs

@@ -3,7 +3,7 @@ class Rigor::Plugin::Manifest::Consumption
 end
 
 class Rigor::Plugin::Manifest
-  def initialize: (id: untyped, version: untyped, ?description: untyped, ?protocols: untyped, ?config_schema: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?type_node_resolvers: untyped) -> void
+  def initialize: (id: untyped, version: untyped, ?description: untyped, ?protocols: untyped, ?config_schema: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?trait_registries: untyped, ?external_files: untyped) -> void
   def validate_config: (untyped) -> Array[String]
   def to_h: () -> Hash[String, untyped]
 end

data/sig/rigor/plugin/registry.rbs

@@ -1,3 +1,16 @@
 class Rigor::Plugin::Registry
-  def initialize: (?plugins: untyped, ?load_errors: untyped) -> void
+  attr_reader plugins: untyped
+  attr_reader load_errors: untyped
+  attr_reader blueprints: untyped
+
+  EMPTY: Rigor::Plugin::Registry
+
+  def self.materialize: (blueprints: untyped, services: untyped) -> Rigor::Plugin::Registry
+
+  def initialize: (?plugins: untyped, ?load_errors: untyped, ?blueprints: untyped) -> void
+  def find: (String | Symbol id) -> untyped
+  def ids: () -> Array[String]
+  def empty?: () -> bool
+  def any_load_errors?: () -> bool
+  def type_node_resolvers: () -> Array[untyped]
 end

data/sig/rigor.rbs

@@ -54,13 +54,46 @@ module Rigor
 
     class Result
       attr_reader diagnostics: Array[Diagnostic]
+      attr_reader stats: RunStats?
 
-      def initialize: (?diagnostics: Array[Diagnostic]) -> void
+      def initialize: (?diagnostics: Array[Diagnostic], ?stats: RunStats?) -> void
       def success?: () -> bool
       def error_count: () -> Integer
       def to_h: () -> Hash[String, untyped]
     end
 
+    class RunStats
+      attr_reader wall_seconds: Float
+      attr_reader peak_rss_bytes: Integer?
+      attr_reader target_files: Integer
+      attr_reader rbs_classes_total: Integer
+      attr_reader rbs_classes_project_sig: Integer
+      attr_reader rbs_classes_bundled: Integer
+      attr_reader gem_walk_classes: Integer
+      attr_reader gem_walk_gems: Integer
+      attr_reader rbs_attribution_available: bool
+
+      CACHED_SENTINEL: String
+
+      def self.peak_rss_bytes: () -> Integer?
+      def self.partition_classes: (class_decl_paths: Hash[String, String], signature_paths: Array[untyped]) -> [Integer, Integer]
+      def self.attribution_available?: (class_decl_paths: Hash[String, String]) -> bool
+
+      def initialize: (
+        wall_seconds: Float,
+        peak_rss_bytes: Integer?,
+        target_files: Integer,
+        rbs_classes_total: Integer,
+        rbs_classes_project_sig: Integer,
+        rbs_classes_bundled: Integer,
+        gem_walk_classes: Integer,
+        gem_walk_gems: Integer,
+        ?rbs_attribution_available: bool
+      ) -> void
+      def format: (untyped out, ?prefix: String) -> void
+      def to_h: () -> Hash[Symbol, untyped]
+    end
+
     class Runner
       RUBY_GLOB: String
       DEFAULT_CACHE_ROOT: String
@@ -71,8 +104,10 @@ module Rigor
       # otherwise raises `RBS::UnknownTypeName` for the named type.
       attr_reader cache_store: untyped
       attr_reader plugin_registry: untyped
-      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped) -> void
+      attr_reader buffer: untyped
+      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped, ?workers: Integer, ?collect_stats: bool, ?buffer: untyped, ?prebuilt: untyped, ?environment: untyped) -> void
       def run: (?Array[String] paths) -> Result
+      def prepare_project_scan: (?paths: Array[String]) -> untyped
     end
   end
 end