rigortype 0.3.0 → 0.3.2

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class DryValidation < Rigor::Plugin::Base
+      # Issue #137 slices 2/3 — recognises the `<Const>.new.call(...).to_h` call chain and builds the
+      # per-contract `HashShape` from the entry {ContractScanner.scan_schema_blocks} collected.
+      module ParamsShape
+        module_function
+
+        # The Contract constant `to_h_node`'s receiver chain, or nil when the chain isn't the recognised
+        # `<Const>.new.call(...).to_h` form.
+        #
+        # Mirrors rigor-dry-schema's `ResultShape.schema_name` with one extra hop: a schema's `.call` is a
+        # bare class method on the schema constant itself, but a Contract's `.call` is an INSTANCE method
+        # (`NewUserContract.new.call(input)`), so the chain has to walk through `.new` first. Floor,
+        # matching dry-schema's own posture: the contract must be named by a constant as written at the
+        # call site. Reached through a local (`c = NewUserContract.new; c.call(x).to_h`) or a relative
+        # constant path, the chain contributes nothing and `to_h` types per the RBS overlay's generic
+        # `Hash[Symbol, untyped]` as it did before.
+        def contract_name(to_h_node)
+          return nil unless to_h_node.is_a?(Prism::CallNode) && to_h_node.name == :to_h
+          return nil unless to_h_node.arguments.nil? && to_h_node.block.nil?
+
+          call_node = to_h_node.receiver
+          return nil unless call_node.is_a?(Prism::CallNode) && call_node.name == :call
+
+          new_node = call_node.receiver
+          return nil unless new_node.is_a?(Prism::CallNode) && new_node.name == :new
+          return nil unless new_node.arguments.nil? && new_node.block.nil?
+
+          constant_name(new_node.receiver)
+        end
+
+        # Delegates the entry -> HashShape build to rigor-dry-schema's own
+        # {DrySchema::ResultShape.build} — the identical algorithm the entry was collected with (via
+        # {ContractScanner.scan_schema_blocks}, which itself delegates to
+        # {DrySchema::SchemaScanner.collect_schema_shape}). Only ever called once the caller has already
+        # confirmed rigor-dry-schema is loaded.
+        def build(entry)
+          DrySchema::ResultShape.build(entry)
+        end
+
+        # Renders `Foo` / `Foo::Bar` / `::Foo::Bar` as the `::`-joined String {ContractScanner}'s table is
+        # keyed by. Duplicated from rigor-dry-schema's identical helper rather than shared — five lines,
+        # no dependency on anything ELSE in that plugin, and reusing it would need a `registered_for`
+        # guard here too even though this leaf never touches dry-schema's own type/alias machinery.
+        def constant_name(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode then constant_path_name(node)
+          end
+        end
+
+        def constant_path_name(node)
+          parent = node.parent
+          name = node.name&.to_s
+          return nil if name.nil?
+          return name if parent.nil? # `::Foo` — the table keys are unrooted, so drop the leading `::`
+
+          prefix = constant_name(parent)
+          prefix.nil? ? nil : "#{prefix}::#{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ require "prism"
 require "rigor/plugin"
 
 require_relative "dry_validation/contract_scanner"
+require_relative "dry_validation/params_shape"
 
 module Rigor
   module Plugin
@@ -21,13 +22,21 @@ module Rigor
     #   Result) and `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):
+    # Landed since (issue #137):
     #
-    # - Integrate with `:dry_schema_table` (published by `rigor-dry-schema`) so the `params { ... }`
-    #   block inside a Contract contributes a typed `result.to_h` shape per the schema. Until this lands,
-    #   `result.to_h` types as `Hash[Symbol, untyped]` (the generic RBS overlay shape).
+    # - **Slice 2** — when `rigor-dry-schema` is loaded, a Contract's `params { ... }` block (the SAME
+    #   dry-schema DSL a top-level `Dry::Schema.X { ... }` body uses) refines
+    #   `NewUserContract.new.call(input).to_h` from the RBS overlay's generic `Hash[Symbol, untyped]` to
+    #   the schema-typed `HashShape`. See {ContractScanner.scan_schema_blocks} + {ParamsShape}.
+    # - **Slice 3** — `json { ... }` adapter parity with `params { ... }`. Same mechanism, same fact.
+    # - **`dry-validation.rule-key-mismatch`** — a `rule(:key)` referencing a key absent from the
+    #   Contract's own `params`/`json` block. Hard-gated: see {ContractScanner.rule_key_issues}'s doc for
+    #   the two all-or-nothing checks that keep it silent on anything not statically resolvable.
     #
-    # Slice 3 (deferred): `json { ... }` adapter parity with `params { ... }`. Same shape as slice 2.
+    # Without `rigor-dry-schema` loaded, `result.to_h` still types per the RBS overlay's generic
+    # `Hash[Symbol, untyped]` and `rule-key-mismatch` never fires — this plugin ships no required/optional
+    # walker of its own; it delegates to dry-schema's (see {ContractScanner}'s module doc for why that is
+    # a deliberate hard precondition, not a degrade-gracefully fallback).
     #
     # No ADR-3 amendment is needed for the validation surface itself; `Dry::Validation::Result` is a
     # generic class, not a sum type (the `success?` / `failure?` predicates narrow via existing bool flow
@@ -36,31 +45,98 @@ module Rigor
       manifest(
         id: "dry-validation",
         version: "0.1.0",
-        description: "Recognises `class T < Dry::Validation::Contract` subclasses and " \
-                     "publishes the contract FQN set.",
-        produces: [:dry_validation_contracts],
+        description: "Recognises `class T < Dry::Validation::Contract` subclasses, publishes the " \
+                     "contract FQN set, and (with rigor-dry-schema loaded) refines each contract's " \
+                     "`result.to_h` to its `params`/`json` schema shape.",
+        produces: %i[dry_validation_contracts dry_validation_params],
+        consumes: [{ plugin_id: "dry-types", name: :dry_type_aliases, optional: true }],
         # Auto-contribute the bundled RBS overlay (Contract#call -> Result, Result#success?/#to_h/...)
         # per ADR-25, so no project-side signature_paths wiring is needed.
         signature_paths: ["sig"]
       )
 
+      # ADR-37 dynamic return — refines `NewUserContract.new.call(input).to_h` to the per-contract
+      # `HashShape` when {#result_shape_for} finds one. Gated on the method name alone (mirrors
+      # rigor-dry-schema's own `.to_h` rule): the RBS overlay types `Contract#call`'s return as the
+      # generic `Result`, but that alone can't select a PER-CONTRACT shape, so the block does its own
+      # syntactic chain match via {ParamsShape.contract_name} before touching the table. When
+      # rigor-dry-schema isn't loaded, or the chain isn't a Contract call, this returns nil and the RBS
+      # overlay's generic `Hash[Symbol, untyped]` stands.
+      dynamic_return methods: [:to_h] do |call_node, _scope|
+        result_shape_for(call_node)
+      end
+
+      # ADR-37 slice 1c two-pass — the "collect" half of `dry-validation.rule-key-mismatch`. Reads the
+      # SAME `:dry_type_aliases` fact `#prepare` does (a plain `services.fact_store.read`, not
+      # `#read_fact`'s memoised wrapper — `services` at collect time is the run-wide instance, so an
+      # in-block memo isn't needed here the way it is across many per-call `dynamic_return` invocations).
+      node_file_context do |root, _scope|
+        type_aliases = services.fact_store.read(plugin_id: "dry-types", name: :dry_type_aliases) || {}
+        ContractScanner.rule_key_issues(root, type_aliases)
+      end
+
+      # Fires once per file (see rigor-dry-schema's identical `Prism::ProgramNode` rule for why).
+      node_rule Prism::ProgramNode do |_node, _scope, path, issues|
+        next [] if issues.nil? || issues.empty?
+
+        issues.map do |issue|
+          hint = Rigor::Plugin::Base.suggest(issue[:key], issue[:known_keys])
+          suffix = hint ? " (did you mean `:#{hint}`?)" : ""
+          diagnostic(
+            issue[:node],
+            path: path,
+            message: "rule(:#{issue[:key]}) references a key not declared by " \
+                     "`#{issue[:contract_fqn]}`'s params/json schema#{suffix}",
+            severity: :error,
+            rule: "dry-validation.rule-key-mismatch"
+          )
+        end
+      end
+
       def prepare(services)
         contracts = ContractScanner.scan(paths: scannable_paths(services))
-        return if contracts.empty?
+        unless contracts.empty?
+          services.fact_store.publish(
+            plugin_id: manifest.id,
+            name: :dry_validation_contracts,
+            value: contracts
+          )
+        end
+
+        type_aliases = services.fact_store.read(plugin_id: "dry-types", name: :dry_type_aliases) || {}
+        params_table = ContractScanner.scan_schema_blocks(paths: scannable_paths(services), type_aliases: type_aliases)
+        return if params_table.empty?
 
         services.fact_store.publish(
           plugin_id: manifest.id,
-          name: :dry_validation_contracts,
-          value: contracts
+          name: :dry_validation_params,
+          value: params_table
         )
       end
 
       def init(_services)
         @scannable_paths = nil
+        @params_shapes = {}
       end
 
       private
 
+      # The HashShape for a `<Const>.new.call(...).to_h` chain, or nil when the chain isn't that shape,
+      # names no contract in the table, or the contract's `params`/`json` shape declares no key.
+      # `params` wins over `json` when (unusually) a Contract declares both — mirrors dry-schema's own
+      # per-name memoisation, including nil, for the same reason: the miss is the common case.
+      def result_shape_for(call_node)
+        name = ParamsShape.contract_name(call_node)
+        return nil if name.nil?
+
+        shapes = (@params_shapes ||= {})
+        return shapes[name] if shapes.key?(name)
+
+        entry = read_fact(plugin_id: manifest.id, name: :dry_validation_params)&.[](name)
+        row = entry && (entry[:params] || entry[:json])
+        shapes[name] = row.nil? ? nil : ParamsShape.build(row)
+      end
+
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if File.directory?(entry)

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -60,9 +60,11 @@ module Rigor
         end
 
         # Return value contract:
-        # - `String` (non-empty)         → successful synthesis
-        # - `nil`                        → no contribution
-        # - `[:error, message_string]`   → parse failed, surface info diagnostic per ADR-32 WD6
+        # - `String` (non-empty)          → successful synthesis
+        # - `nil`                         → no contribution
+        # - `[:error, message_string]`    → parse failed, surface info diagnostic per ADR-32 WD6
+        # - `[:ok, source, [message, …]]` → synthesis succeeded, but an annotation was parsed and NOT
+        #                                   honoured; surface info diagnostics per ADR-32 WD12
         def call(source_file_path)
           return nil unless RBS_INLINE_AVAILABLE
           return nil unless File.file?(source_file_path)
@@ -83,7 +85,8 @@ module Rigor
           rendered = ::RBS::Inline::Writer.write(uses, decls, rbs_decls)
           return nil if rendered.nil? || rendered.strip.empty?
 
-          rendered
+          notices = unhonoured_annotations(result)
+          notices.empty? ? rendered : [:ok, rendered, notices]
         rescue ::StandardError => e
           # WD6 fail-soft — surface a structured error tuple so the engine's `Environment.for_project` can
           # emit a `source-rbs-synthesis-failed` info diagnostic naming the file + the upstream error
@@ -113,6 +116,33 @@ module Rigor
                                          .any? { |parsed| parsed.each_annotation.any? }
         end
 
+        # ADR-32 WD12 — annotations upstream's parser ACCEPTS and its writer then contributes nothing from.
+        # These are invisible without a report: synthesis succeeds, and the annotation comment is even echoed
+        # into the generated RBS, so the omission shows up neither in the output nor at runtime.
+        #
+        # The one case today is `module-self`, where the two inline-RBS dialects disagree on spelling. rbs's
+        # own `docs/inline.md` documents `# @rbs module-self: Foo`; the rbs-inline gem's grammar is
+        # `# @rbs module-self Foo`, without the colon. Handed the colon form the gem still builds a
+        # `ModuleSelf` annotation but extracts no types from it, so an empty `self_types` on a parsed
+        # annotation is a precise signature for "the author asked for a constraint we did not apply".
+        # Measured both ways in `docs/notes/20260730-inline-rbs-parser-grammar-diff.md`.
+        #
+        # Deliberately narrow. A construct the gem's parser REJECTS already routes through WD6's error path,
+        # and one it never recognised at all is upstream's grammar to define (WD3) — guessing at those would
+        # make this a lint on comment prose, which is exactly the false-positive cost ADR-5 ranks first.
+        def unhonoured_annotations(prism_result)
+          ::RBS::Inline::AnnotationParser.parse(prism_result.comments).flat_map do |parsed|
+            parsed.each_annotation.filter_map do |annotation|
+              next unless annotation.is_a?(::RBS::Inline::AST::Annotations::ModuleSelf)
+              next unless annotation.self_types.empty?
+
+              "`@rbs module-self` contributed no self-type constraint. Rigor reads the " \
+                "`# @rbs module-self Foo` spelling; `# @rbs module-self: Foo` (the spelling in rbs's own " \
+                "inline documentation) is not honoured here."
+            end
+          end.uniq
+        end
+
         # Rewrite every RDoc directive comment to its spaced spelling (`#:nodoc:` -> `# :nodoc:`) so
         # upstream's annotation grammar never sees it, and re-parse. Two reasons this happens here rather
         # than in {#annotated?}: the directive must not gate a file in, AND it must not reach the synthesis,

data/sig/rigor/cache.rbs

@@ -14,6 +14,12 @@ module Rigor
     # PRODUCER_ID constant and a private `self.compute(loader)`.
     class RbsCacheProducer
       def self.fetch: (loader: untyped, store: untyped) -> untyped
+
+      # The generation cap this producer declares to `Cache::Store#evict!`
+      # (issue #151). `rigor sig-gen` infers the literal `2` from the base
+      # body; the contract is the wider `Integer`, since a subclass may
+      # override it.
+      def self.generation_cap: () -> Integer
     end
   end
 end

data/sig/rigor/inference/void_origin.rbs

@@ -0,0 +1,21 @@
+module Rigor
+  module Inference
+    # `VoidOrigin = Data.define(:class_name, :method_name, :kind)`. Declared as a `::Data` subclass because that
+    # is the shape the runtime actually builds. `sig-gen` reads this form since #227 and generates the same
+    # structure; the member types are hand-narrowed from the `untyped` only `--params=observed` could improve on.
+    class VoidOrigin < ::Data
+      attr_reader class_name: String
+      attr_reader method_name: Symbol
+      attr_reader kind: Symbol
+
+      def self.new: (class_name: String, method_name: Symbol, kind: Symbol) -> instance
+                  | (String class_name, Symbol method_name, Symbol kind) -> instance
+
+      def self.[]: (class_name: String, method_name: Symbol, kind: Symbol) -> instance
+                 | (String class_name, Symbol method_name, Symbol kind) -> instance
+
+      # A human-facing `Class#method` / `Class.method` label for the diagnostic message.
+      def label: () -> String
+    end
+  end
+end

data/sig/rigor/plugin/base.rbs

@@ -14,7 +14,7 @@ class Rigor::Plugin::Base
   # the no-arg `manifest` reads the cached value back.
   def self.manifest: (**untyped fields) -> Rigor::Plugin::Manifest
 
-  def self.producer: (untyped id, ?watch: untyped, ?serialize: untyped, ?deserialize: untyped) { (untyped params) -> untyped } -> Symbol
+  def self.producer: (untyped id, ?watch: untyped, ?serialize: untyped, ?deserialize: untyped, ?generation_cap: untyped) { (untyped params) -> untyped } -> Symbol
   def self.producers: () -> Hash[Symbol, untyped]
 
   def self.node_rule: (untyped node_type) { (*untyped) -> untyped } -> untyped
@@ -23,11 +23,12 @@ class Rigor::Plugin::Base
   def self.node_file_context: () { (untyped root, untyped scope) -> untyped } -> untyped
   def self.node_file_context_block: () -> untyped
 
-  def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
+  def self.dynamic_return: (?receivers: (Array[String] | ^() -> Array[String])?, ?methods: (Array[untyped] | ^() -> Array[untyped])?, ?file_methods: (^(untyped path) -> Array[untyped])?) { (untyped call_node, untyped scope) -> untyped } -> nil
   def self.dynamic_returns: () -> Array[untyped]
 
   def self.narrowing_facts: (methods: Array[untyped]) { (untyped call_node, untyped scope) -> untyped } -> nil
-  # Deprecating alias for `narrowing_facts` (ADR-80); removed in 0.3.0.
+  # The engine-facing reader for the declared `narrowing_facts` rules. Named
+  # `type_specifiers` before ADR-80; that spelling was removed in 0.3.0.
   def self.narrowing_facts_rules: () -> Array[untyped]
 
   def self.suggest: (untyped name, untyped candidates) -> String?

data/sig/rigor/scope.rbs

@@ -12,6 +12,9 @@ module Rigor
     attr_reader local_origins: Hash[Symbol, Symbol]
     attr_reader ivar_origins: Hash[Symbol, Symbol]
     attr_reader void_origins: Hash[untyped, Inference::VoidOrigin]
+    attr_reader optimistic_origins: Hash[untyped, Symbol]
+    attr_reader optimistic_locals: Hash[Symbol, Symbol]
+    attr_reader optimistic_ivars: Hash[Symbol, Symbol]
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
@@ -39,6 +42,7 @@ module Rigor
     def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
     def run_generation: () -> Object?
     def record_dynamic_origin: (untyped node, Symbol cause) -> Scope
+    def record_optimistic_origin: (untyped node, Symbol cause) -> Scope
 
     def record_void_origin: (untyped node, Inference::VoidOrigin origin) -> Scope
 
@@ -93,9 +97,13 @@ module Rigor
     def global: (String | Symbol name) -> Type::t?
     def local_origin: (String | Symbol name) -> Symbol?
     def ivar_origin: (String | Symbol name) -> Symbol?
+    def optimistic_local: (String | Symbol name) -> Symbol?
+    def optimistic_ivar: (String | Symbol name) -> Symbol?
     def with_local: (String | Symbol name, Type::t type) -> Scope
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
     def with_local_origin: (String | Symbol name, Symbol? cause) -> Scope
+    def with_optimistic_local: (String | Symbol name, Symbol? cause) -> Scope
+    def with_optimistic_ivar: (String | Symbol name, Symbol? cause) -> Scope
     def with_ivar_origin: (String | Symbol name, Symbol? cause) -> Scope
     def with_cvar: (String | Symbol name, Type::t type) -> Scope
     def with_global: (String | Symbol name, Type::t type) -> Scope

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Rigor contributors
 bindir: exe
 cert_chain: []
-date: 1980-01-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -290,6 +290,7 @@ files:
 - data/core_overlay/numeric.rbs
 - data/core_overlay/pathname.rbs
 - data/core_overlay/psych.rbs
+- data/core_overlay/resolv.rbs
 - data/core_overlay/string_scanner.rbs
 - data/gem_overlay/activesupport/core_ext.rbs
 - data/vendored_gem_sigs/ast/ast.rbs
@@ -306,6 +307,7 @@ files:
 - data/vendored_gem_sigs/nokogiri/nokogiri_html5.rbs
 - data/vendored_gem_sigs/pg/pg.rbs
 - data/vendored_gem_sigs/prism/prism_supplement.rbs
+- data/vendored_gem_sigs/racc/racc.rbs
 - data/vendored_gem_sigs/redis/errors.rbs
 - data/vendored_gem_sigs/redis/future.rbs
 - data/vendored_gem_sigs/redis/redis.rbs
@@ -428,6 +430,7 @@ files:
 - lib/rigor/analysis/run_cache_probe.rb
 - lib/rigor/analysis/run_stats.rb
 - lib/rigor/analysis/runner.rb
+- lib/rigor/analysis/runner/buffer_pool_dispatcher.rb
 - lib/rigor/analysis/runner/diagnostic_aggregator.rb
 - lib/rigor/analysis/runner/pool_coordinator.rb
 - lib/rigor/analysis/runner/project_pre_passes.rb
@@ -444,6 +447,7 @@ files:
 - lib/rigor/builtins/regex_refinement.rb
 - lib/rigor/builtins/static_return_refinements.rb
 - lib/rigor/cache/descriptor.rb
+- lib/rigor/cache/engine_source.rb
 - lib/rigor/cache/file_digest.rb
 - lib/rigor/cache/incremental_snapshot.rb
 - lib/rigor/cache/rbs_cache_producer.rb
@@ -460,6 +464,7 @@ files:
 - lib/rigor/cli/annotate_command.rb
 - lib/rigor/cli/baseline_command.rb
 - lib/rigor/cli/check_command.rb
+- lib/rigor/cli/check_invocation.rb
 - lib/rigor/cli/check_runner_factory.rb
 - lib/rigor/cli/command.rb
 - lib/rigor/cli/coverage_command.rb
@@ -476,6 +481,7 @@ files:
 - lib/rigor/cli/fused_protection_report.rb
 - lib/rigor/cli/lsp_command.rb
 - lib/rigor/cli/mcp_command.rb
+- lib/rigor/cli/mutation_fork_scan.rb
 - lib/rigor/cli/mutation_protection_renderer.rb
 - lib/rigor/cli/mutation_protection_report.rb
 - lib/rigor/cli/options.rb
@@ -491,6 +497,7 @@ files:
 - lib/rigor/cli/show_bleedingedge_command.rb
 - lib/rigor/cli/sig_gen_command.rb
 - lib/rigor/cli/skill_command.rb
+- lib/rigor/cli/skill_deep_probe.rb
 - lib/rigor/cli/skill_describe.rb
 - lib/rigor/cli/trace_command.rb
 - lib/rigor/cli/trace_renderer.rb
@@ -597,6 +604,7 @@ files:
 - lib/rigor/inference/multi_target_binder.rb
 - lib/rigor/inference/mutation_widening.rb
 - lib/rigor/inference/narrowing.rb
+- lib/rigor/inference/optimistic_origin.rb
 - lib/rigor/inference/origin_lookup.rb
 - lib/rigor/inference/parameter_inference_collector.rb
 - lib/rigor/inference/precision_scanner.rb
@@ -604,6 +612,7 @@ files:
 - lib/rigor/inference/project_patched_scanner.rb
 - lib/rigor/inference/protection_scanner.rb
 - lib/rigor/inference/rbs_type_translator.rb
+- lib/rigor/inference/receiver_alias.rb
 - lib/rigor/inference/scope_indexer.rb
 - lib/rigor/inference/statement_evaluator.rb
 - lib/rigor/inference/struct_fold_safety.rb
@@ -622,8 +631,10 @@ files:
 - lib/rigor/language_server/folding_range_provider.rb
 - lib/rigor/language_server/hover_provider.rb
 - lib/rigor/language_server/hover_renderer.rb
+- lib/rigor/language_server/incremental_sync.rb
 - lib/rigor/language_server/loop.rb
 - lib/rigor/language_server/project_context.rb
+- lib/rigor/language_server/publish_batcher.rb
 - lib/rigor/language_server/selection_range_provider.rb
 - lib/rigor/language_server/server.rb
 - lib/rigor/language_server/signature_help_provider.rb
@@ -658,7 +669,12 @@ files:
 - lib/rigor/plugin/source_rbs_synthesis_reporter.rb
 - lib/rigor/plugin/trust_policy.rb
 - lib/rigor/plugin/type_node_resolver.rb
+- lib/rigor/protection/closure_kill_oracle.rb
+- lib/rigor/protection/dependency_closure.rb
 - lib/rigor/protection/diagnostic_oracle.rb
+- lib/rigor/protection/discovery_seed.rb
+- lib/rigor/protection/kill_signature.rb
+- lib/rigor/protection/mutation_cache.rb
 - lib/rigor/protection/mutation_scanner.rb
 - lib/rigor/protection/mutator.rb
 - lib/rigor/protection/test_suite_oracle.rb
@@ -674,6 +690,7 @@ files:
 - lib/rigor/sig_gen/classification.rb
 - lib/rigor/sig_gen/generator.rb
 - lib/rigor/sig_gen/layout_index.rb
+- lib/rigor/sig_gen/meta_class_shape.rb
 - lib/rigor/sig_gen/method_candidate.rb
 - lib/rigor/sig_gen/observation_collector.rb
 - lib/rigor/sig_gen/observed_call.rb
@@ -773,6 +790,7 @@ files:
 - plugins/rigor-devise/lib/rigor/plugin/devise.rb
 - plugins/rigor-dry-schema/lib/rigor-dry-schema.rb
 - plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema.rb
+- plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema/result_shape.rb
 - plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema/schema_scanner.rb
 - plugins/rigor-dry-struct/lib/rigor-dry-struct.rb
 - plugins/rigor-dry-struct/lib/rigor/plugin/dry_struct.rb
@@ -782,6 +800,7 @@ files:
 - plugins/rigor-dry-validation/lib/rigor-dry-validation.rb
 - plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb
 - plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation/contract_scanner.rb
+- plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation/params_shape.rb
 - plugins/rigor-dry-validation/sig/dry_validation.rbs
 - plugins/rigor-factorybot/lib/rigor-factorybot.rb
 - plugins/rigor-factorybot/lib/rigor/plugin/factorybot.rb
@@ -876,6 +895,7 @@ files:
 - sig/rigor/inference/builtins.rbs
 - sig/rigor/inference/builtins/method_catalog.rbs
 - sig/rigor/inference/builtins/numeric_catalog.rbs
+- sig/rigor/inference/void_origin.rbs
 - sig/rigor/plugin.rbs
 - sig/rigor/plugin/access_denied_error.rbs
 - sig/rigor/plugin/base.rbs
@@ -987,7 +1007,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Inference-first static analysis for Ruby.
 test_files: []