rigortype 0.1.4 → 0.1.5

data/lib/rigor/plugin/macro.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "macro/block_as_method"
+require_relative "macro/external_file"
+require_relative "macro/heredoc_template"
+require_relative "macro/trait_registry"
+
+module Rigor
+  module Plugin
+    # Substrate declarations for the macro / DSL expansion tiers
+    # introduced by ADR-16. Plugin authors declare entries under
+    # `Plugin::Manifest` slots (`block_as_methods:`,
+    # `trait_registries:`, `heredoc_macros:`,
+    # `external_file_inclusions:`) and the substrate consumes them
+    # to recognise the call shapes a library exposes to its users.
+    #
+    # Slice 1a (this file's first delivery) ships the Tier A value
+    # class only. The other tiers' value classes + their manifest
+    # slots arrive in subsequent slices per ADR-16 § Implementation
+    # slicing. The namespace is reserved here so subsequent slices
+    # add files alongside `block_as_method.rb` without churn.
+    #
+    # Per ADR-16 § WD13, substrate-produced output ships at a
+    # **floor** in v0.1.x ("substrate-affected code parses cleanly
+    # and has its identifiers resolved"); precise return-type
+    # emission is the ceiling and arrives in a later slice through
+    # the ADR-13 `Plugin::TypeNodeResolver` chain.
+    module Macro
+    end
+  end
+end

data/lib/rigor/plugin/manifest.rb

@@ -38,12 +38,14 @@ module Rigor
       end
 
       attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes,
-                  :owns_receivers, :type_node_resolvers
+                  :owns_receivers, :type_node_resolvers, :block_as_methods, :heredoc_templates,
+                  :trait_registries, :external_files
 
       def initialize( # rubocop:disable Metrics/ParameterLists
         id:, version:,
         description: nil, protocols: [], config_schema: {},
-        produces: [], consumes: [], owns_receivers: [], type_node_resolvers: []
+        produces: [], consumes: [], owns_receivers: [], type_node_resolvers: [],
+        block_as_methods: [], heredoc_templates: [], trait_registries: [], external_files: []
       )
         validate_id!(id)
         validate_version!(version)
@@ -52,17 +54,21 @@ module Rigor
         validate_produces!(produces)
         validate_owns_receivers!(owns_receivers)
         validate_type_node_resolvers!(type_node_resolvers)
+        validate_block_as_methods!(block_as_methods)
+        validate_heredoc_templates!(heredoc_templates)
+        validate_trait_registries!(trait_registries)
+        validate_external_files!(external_files)
 
         assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
-                      type_node_resolvers)
+                      type_node_resolvers, block_as_methods, heredoc_templates, trait_registries, external_files)
         freeze
       end
 
       private
 
-      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
       def assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
-                        type_node_resolvers)
+                        type_node_resolvers, block_as_methods, heredoc_templates, trait_registries, external_files)
         @id = id.dup.freeze
         @version = version.dup.freeze
         @description = description.nil? ? nil : description.to_s.dup.freeze
@@ -72,8 +78,12 @@ module Rigor
         @consumes = coerce_consumes(consumes)
         @owns_receivers = owns_receivers.map { |c| c.to_s.dup.freeze }.freeze
         @type_node_resolvers = type_node_resolvers.dup.freeze
+        @block_as_methods = block_as_methods.dup.freeze
+        @heredoc_templates = heredoc_templates.dup.freeze
+        @trait_registries = trait_registries.dup.freeze
+        @external_files = external_files.dup.freeze
       end
-      # rubocop:enable Metrics/ParameterLists
+      # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize
 
       public
 
@@ -110,7 +120,11 @@ module Rigor
           "produces" => produces.map(&:to_s),
           "consumes" => consumes.map { |c| consumption_hash(c) },
           "owns_receivers" => owns_receivers,
-          "type_node_resolvers" => type_node_resolvers.map { |r| r.class.name }
+          "type_node_resolvers" => type_node_resolvers.map { |r| r.class.name },
+          "block_as_methods" => block_as_methods.map(&:to_h),
+          "heredoc_templates" => heredoc_templates.map(&:to_h),
+          "trait_registries" => trait_registries.map(&:to_h),
+          "external_files" => external_files.map(&:to_h)
         }
       end
 
@@ -208,6 +222,63 @@ module Rigor
               "Rigor::Plugin::TypeNodeResolver instances, got #{resolvers.inspect}"
       end
 
+      # ADR-16 slice 1a — `block_as_methods:` declares the Tier A
+      # substrate entries the plugin contributes. Slice 1a carries
+      # the declarations on the manifest; the engine hook that
+      # actually narrows `Scope#self_type` for matching blocks
+      # arrives in a subsequent slice.
+      def validate_block_as_methods!(entries)
+        return if entries.is_a?(Array) && entries.all?(Macro::BlockAsMethod)
+
+        raise ArgumentError,
+              "plugin manifest block_as_methods must be an Array of " \
+              "Rigor::Plugin::Macro::BlockAsMethod instances, got #{entries.inspect}"
+      end
+
+      # ADR-16 slice 2a — `heredoc_templates:` declares the Tier C
+      # substrate entries (heredoc-template synthesis on class-level
+      # DSL calls). Slice 2a carries the declarations on the
+      # manifest; the pre-pass + `SyntheticMethodIndex` that actually
+      # emit synthetic methods arrive in slice 2b.
+      def validate_heredoc_templates!(entries)
+        return if entries.is_a?(Array) && entries.all?(Macro::HeredocTemplate)
+
+        raise ArgumentError,
+              "plugin manifest heredoc_templates must be an Array of " \
+              "Rigor::Plugin::Macro::HeredocTemplate instances, got #{entries.inspect}"
+      end
+
+      # ADR-16 slice 3a — `trait_registries:` declares the Tier B
+      # substrate entries (trait-inlining via bundled module
+      # registry). Slice 3a carries the declarations on the
+      # manifest; the scanner + per-method explosion through
+      # `SyntheticMethodIndex` (slice 2b primitive) arrives in
+      # slice 3b.
+      def validate_trait_registries!(entries)
+        return if entries.is_a?(Array) && entries.all?(Macro::TraitRegistry)
+
+        raise ArgumentError,
+              "plugin manifest trait_registries must be an Array of " \
+              "Rigor::Plugin::Macro::TraitRegistry instances, got #{entries.inspect}"
+      end
+
+      # ADR-16 slice 5a — `external_files:` declares the Tier D
+      # substrate entries (external-Ruby-file inclusion under a
+      # declared `self`). Slice 5a carries the declarations on
+      # the manifest; the engine integration that walks the
+      # matched files + narrows their entry scope is **queued for
+      # slice 5b**, gated on demonstrated demand from concrete
+      # plugin targets (Redmine webhook payloads, tDiary plugin
+      # loader, etc.). Plugin authors MAY declare entries today;
+      # the substrate does not yet act on them.
+      def validate_external_files!(entries)
+        return if entries.is_a?(Array) && entries.all?(Macro::ExternalFile)
+
+        raise ArgumentError,
+              "plugin manifest external_files must be an Array of " \
+              "Rigor::Plugin::Macro::ExternalFile instances, got #{entries.inspect}"
+      end
+
       def coerce_consumes(consumes)
         unless consumes.is_a?(Array)
           raise ArgumentError, "plugin manifest consumes must be an Array, got #{consumes.inspect}"

data/lib/rigor/plugin/registry.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "blueprint"
+
 module Rigor
   module Plugin
     # Read-side query API over the plugins loaded for a single
@@ -13,20 +15,48 @@ module Rigor
     # the order in which {Rigor::Plugin::Loader} resolved
     # configuration entries, which is project-config order with
     # plugin-id alphabetical as the tie-breaker.
+    #
+    # ADR-15 Phase 3 — alongside the instantiated `plugins`, the
+    # registry carries `blueprints`: a frozen, Ractor-shareable
+    # `Array<Blueprint>` that records how to re-instantiate the
+    # same plugin set in a worker Ractor. The eventual Phase 4
+    # pool ships `blueprints` across the boundary and calls
+    # {.materialize} per-Ractor; the live `plugins` carriage on
+    # the coordinator registry stays unchanged.
     class Registry
-      attr_reader :plugins, :load_errors
+      attr_reader :plugins, :load_errors, :blueprints
 
       # @param plugins [Array<Rigor::Plugin::Base>] instantiated
       #   plugin instances in deterministic order.
       # @param load_errors [Array<Rigor::Plugin::LoadError>] failures
       #   surfaced during loading. Each error is also turned into a
       #   diagnostic by the runner.
-      def initialize(plugins: [], load_errors: [])
+      # @param blueprints [Array<Rigor::Plugin::Blueprint>] frozen,
+      #   Ractor-shareable replay descriptors aligned 1:1 with
+      #   `plugins`. The loader fills this in; callers that
+      #   construct Registry manually MAY pass `[]` and accept
+      #   that {.materialize} cannot replay the set.
+      def initialize(plugins: [], load_errors: [], blueprints: [])
         @plugins = plugins.dup.freeze
         @load_errors = load_errors.dup.freeze
+        @blueprints = blueprints.dup.freeze
         freeze
       end
 
+      # ADR-15 Phase 3 — build a fresh Registry from the supplied
+      # blueprint set by replaying {Blueprint#materialize} per
+      # entry against `services`. The returned registry carries
+      # NEW plugin instances (mutable per-Ractor accumulators
+      # included) and the same blueprint set, so a worker can
+      # hand the materialised registry to Environment without
+      # losing the replay handle. `load_errors` is intentionally
+      # empty: load-time failures already surfaced in the
+      # coordinator registry and don't repeat per worker.
+      def self.materialize(blueprints:, services:)
+        plugins = blueprints.map { |bp| bp.materialize(services: services) }
+        new(plugins: plugins, blueprints: blueprints, load_errors: [])
+      end
+
       def find(id)
         id_s = id.to_s
         plugins.find { |plugin| plugin.manifest.id == id_s }

data/lib/rigor/plugin.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "plugin/type_node_resolver"
+require_relative "plugin/macro"
 require_relative "plugin/manifest"
 require_relative "plugin/access_denied_error"
 require_relative "plugin/trust_policy"

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/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_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.5"
 end

data/sig/rigor/environment.rbs

@@ -11,16 +11,18 @@ module Rigor
     attr_reader rbs_extended_reporter: untyped?
     attr_reader boundary_cross_reporter: untyped?
     attr_reader name_scope: untyped?
+    attr_reader synthetic_method_index: 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?) -> 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?) -> void
     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 +44,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/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,7 +104,7 @@ 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
+      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped, ?workers: Integer, ?collect_stats: bool) -> void
       def run: (?Array[String] paths) -> Result
     end
   end