rigortype 0.1.9 → 0.1.10

data/lib/rigor/plugin/base.rb

@@ -351,11 +351,6 @@ module Rigor
       # descriptor from (1) the plugin's PluginEntry template
       # and (2) the IoBoundary's accumulated FileEntry rows.
       def build_plugin_cache_descriptor
-        plugin_entry = Cache::Descriptor::PluginEntry.new(
-          id: manifest.id,
-          version: manifest.version,
-          config_hash: digest_config(config)
-        )
         boundary_descriptor = io_boundary.cache_descriptor
         Cache::Descriptor.new(
           plugins: [plugin_entry],
@@ -363,6 +358,34 @@ module Rigor
         )
       end
 
+      public
+
+      # ADR-32 WD5 — the `Cache::Descriptor::PluginEntry`
+      # template carrying this plugin's id, version, and a
+      # SHA-256 digest of its (canonicalised) config hash.
+      # Callers outside the plugin (e.g. `Environment.for_project`
+      # caching per-file synthesizer output) compose this entry
+      # into their own cache descriptor so a config change to
+      # the plugin (e.g. flipping `require_magic_comment:`)
+      # invalidates the dependent cache.
+      def plugin_entry
+        # Built fresh on each call rather than memoised so a
+        # plugin subclass that freezes itself in `initialize`
+        # (e.g. `Rigor::Plugin::RbsInline` per ADR-32) doesn't
+        # trip a FrozenError on first read. The construction
+        # cost is a single `Data.define`-backed value-object
+        # build; the cache key derivation downstream is the
+        # expensive step, and it's already memoised inside
+        # `Cache::Store`.
+        Cache::Descriptor::PluginEntry.new(
+          id: manifest.id,
+          version: manifest.version,
+          config_hash: digest_config(config)
+        )
+      end
+
+      private
+
       # ADR-7 § "Slice 6" follow-up — composes the auto-built
       # cache descriptor with an optional plugin-author-supplied
       # extension. Extra `GemEntry` / `FileEntry` / `ConfigEntry`

data/lib/rigor/plugin/manifest.rb

@@ -43,14 +43,15 @@ module Rigor
       attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes,
                   :owns_receivers, :open_receivers, :type_node_resolvers, :block_as_methods,
                   :heredoc_templates, :trait_registries, :external_files, :hkt_registrations,
-                  :hkt_definitions, :signature_paths, :protocol_contracts
+                  :hkt_definitions, :signature_paths, :protocol_contracts, :source_rbs_synthesizer
 
       def initialize( # rubocop:disable Metrics/ParameterLists
         id:, version:,
         description: nil, protocols: [], config_schema: {},
         produces: [], consumes: [], owns_receivers: [], open_receivers: [], type_node_resolvers: [],
         block_as_methods: [], heredoc_templates: [], trait_registries: [], external_files: [],
-        hkt_registrations: [], hkt_definitions: [], signature_paths: [], protocol_contracts: []
+        hkt_registrations: [], hkt_definitions: [], signature_paths: [], protocol_contracts: [],
+        source_rbs_synthesizer: nil
       )
         validate_id!(id)
         validate_version!(version)
@@ -68,10 +69,12 @@ module Rigor
         validate_hkt_definitions!(hkt_definitions)
         validate_signature_paths!(signature_paths)
         validate_protocol_contracts!(protocol_contracts)
+        validate_source_rbs_synthesizer!(source_rbs_synthesizer)
 
         assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
                       open_receivers, type_node_resolvers, block_as_methods, heredoc_templates, trait_registries,
-                      external_files, hkt_registrations, hkt_definitions, signature_paths, protocol_contracts)
+                      external_files, hkt_registrations, hkt_definitions, signature_paths, protocol_contracts,
+                      source_rbs_synthesizer)
         freeze
       end
 
@@ -80,7 +83,8 @@ module Rigor
       # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
       def assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
                         open_receivers, type_node_resolvers, block_as_methods, heredoc_templates, trait_registries,
-                        external_files, hkt_registrations, hkt_definitions, signature_paths, protocol_contracts)
+                        external_files, hkt_registrations, hkt_definitions, signature_paths, protocol_contracts,
+                        source_rbs_synthesizer)
         @id = id.dup.freeze
         @version = version.dup.freeze
         @description = description.nil? ? nil : description.to_s.dup.freeze
@@ -99,6 +103,7 @@ module Rigor
         @hkt_definitions = hkt_definitions.dup.freeze
         @signature_paths = signature_paths.map { |p| p.to_s.dup.freeze }.freeze
         @protocol_contracts = protocol_contracts.dup.freeze
+        @source_rbs_synthesizer = source_rbs_synthesizer
       end
       # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize
 
@@ -146,7 +151,8 @@ module Rigor
           "hkt_registrations" => hkt_registrations.map(&:to_h),
           "hkt_definitions" => hkt_definitions.map { |d| { "uri" => d.uri, "params" => d.params } },
           "signature_paths" => signature_paths,
-          "protocol_contracts" => protocol_contracts.map(&:to_h)
+          "protocol_contracts" => protocol_contracts.map(&:to_h),
+          "source_rbs_synthesizer" => source_rbs_synthesizer&.class&.name
         }
       end
 
@@ -389,6 +395,28 @@ module Rigor
               "Rigor::Plugin::ProtocolContract instances, got #{entries.inspect}"
       end
 
+      # ADR-32 WD4 — `source_rbs_synthesizer:` declares a callable
+      # the engine invokes once per analysed Ruby source file at
+      # env-build time. The callable receives a source file path
+      # (String) and returns either an RBS source String to merge
+      # into the analysis environment or `nil` (no contribution
+      # for this file). Distinct from `signature_paths:` (static,
+      # bundled RBS): the synthesizer derives RBS from project
+      # source on each run.
+      #
+      # The value is held as-given (no dup / freeze) because a
+      # callable instance is opaque to the manifest; the plugin
+      # author is responsible for thread-/Ractor-safety of any
+      # captured state (per ADR-15).
+      def validate_source_rbs_synthesizer!(synthesizer)
+        return if synthesizer.nil?
+        return if synthesizer.respond_to?(:call)
+
+        raise ArgumentError,
+              "plugin manifest source_rbs_synthesizer must respond to :call, " \
+              "got #{synthesizer.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

@@ -160,6 +160,27 @@ module Rigor
         protocol_contracts.select { |contract| path_matches_glob?(contract.path_glob, path_s) }
       end
 
+      # ADR-32 WD4 + WD5 — flat ordered list of
+      # `[plugin, callable]` pairs for every loaded plugin that
+      # declares a `source_rbs_synthesizer:` in its manifest. The
+      # engine invokes each callable once per analysed Ruby source
+      # file at env-build time; non-nil return strings are merged
+      # into the RBS environment as virtual signature sources.
+      # The full plugin instance is carried alongside the
+      # callable so the engine's cache layer (WD5) can compose
+      # `plugin.plugin_entry` into its per-file descriptor — a
+      # config change to the plugin (e.g. flipping
+      # `require_magic_comment:`) invalidates the dependent
+      # synthesizer cache without any plugin-side bookkeeping.
+      def source_rbs_synthesizers
+        plugins.filter_map do |plugin|
+          synthesizer = plugin.manifest.source_rbs_synthesizer
+          next nil if synthesizer.nil?
+
+          [plugin, synthesizer]
+        end
+      end
+
       FNMATCH_FLAGS = File::FNM_PATHNAME | File::FNM_EXTGLOB
       private_constant :FNMATCH_FLAGS
 

data/lib/rigor/plugin/source_rbs_synthesis_reporter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # ADR-32 WD6 — per-run accumulator for failures encountered by
+    # a plugin's `Manifest#source_rbs_synthesizer` callable. The
+    # synthesizer returns `[:error, message]` on parse failure
+    # (per its contract); `Environment.for_project` routes the
+    # tuple through `#record` here. `Analysis::Runner` queries
+    # `#entries` after analysis and emits one
+    # `source-rbs-synthesis-failed` `:info` diagnostic per
+    # entry so the user sees which files contributed nothing
+    # and why.
+    #
+    # Empty by default. The Runner only emits diagnostics when
+    # at least one entry is recorded — projects without
+    # synthesizer-emitting plugins pay zero cost.
+    #
+    # Thread-/Ractor-safety: this reporter is per-`WorkerSession`
+    # in pool mode, so concurrent writes from one Ractor's
+    # `collect_virtual_rbs` loop are serialised by the worker
+    # body itself. The sequential path shares a single reporter
+    # across the run; entries are appended one at a time during
+    # env build (before any per-file analysis runs), so no
+    # locking is needed.
+    class SourceRbsSynthesisReporter
+      Entry = Data.define(:plugin_id, :path, :message)
+
+      def initialize
+        @entries = []
+      end
+
+      def record(plugin_id:, path:, message:)
+        @entries << Entry.new(
+          plugin_id: plugin_id.to_s.dup.freeze,
+          path: path.to_s.dup.freeze,
+          message: message.to_s.dup.freeze
+        )
+        nil
+      end
+
+      def entries
+        @entries.dup.freeze
+      end
+
+      def empty?
+        @entries.empty?
+      end
+    end
+  end
+end

data/lib/rigor/sig_gen/generator.rb

@@ -7,6 +7,7 @@ require_relative "../environment"
 require_relative "../scope"
 require_relative "../reflection"
 require_relative "../type"
+require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/rbs_type_translator"
 
@@ -118,7 +119,8 @@ module Rigor
         candidates_from_defs = defs.filter_map do |def_node, class_name, kind|
           classify_def(path, def_node, class_name, kind, scope_index)
         end
-        candidates_from_defs + collect_attr_candidates(parse_result.value, path, scope_index)
+        obs_ivar_map = build_observed_ivar_map(parse_result.value)
+        candidates_from_defs + collect_attr_candidates(parse_result.value, path, scope_index, obs_ivar_map)
       end
 
       # Walks the AST collecting `(def_node, class_name, kind)`
@@ -501,73 +503,11 @@ module Rigor
       # `V | nil` via `return nil unless ...`). The walk
       # excludes nested `DefNode` / lambda / block scopes
       # whose returns belong to different methods.
+      # Delegates to {Rigor::Inference::DefReturnTyper} — the same
+      # body-typing + explicit-return-union the `rigor annotate`
+      # def-line annotator uses.
       def infer_return_type(def_node, scope_index)
-        body = def_node.body
-        return nil if body.nil?
-
-        last = body_last_expression(body)
-        return nil if last.nil?
-
-        inner_scope = scope_index[last] || scope_index[body] || scope_index[def_node]
-        return nil if inner_scope.nil?
-
-        last_type = inner_scope.type_of(last)
-        union_with_explicit_returns(body, last_type, scope_index)
-      rescue StandardError
-        nil
-      end
-
-      def body_last_expression(body)
-        case body
-        when Prism::StatementsNode then body.body.last
-        when Prism::BeginNode then body_last_expression(body.statements)
-        else body
-        end
-      end
-
-      def union_with_explicit_returns(body, last_type, scope_index)
-        return_types = []
-        collect_return_types(body, scope_index, return_types)
-        return last_type if return_types.empty?
-
-        Type::Combinator.union(last_type, *return_types)
-      end
-
-      RETURN_BARRIER_NODES = [Prism::DefNode, Prism::LambdaNode, Prism::BlockNode].freeze
-      private_constant :RETURN_BARRIER_NODES
-
-      def collect_return_types(node, scope_index, out)
-        return unless node.is_a?(Prism::Node)
-        return if RETURN_BARRIER_NODES.any? { |klass| node.is_a?(klass) }
-
-        type_return_node(node, scope_index, out) if node.is_a?(Prism::ReturnNode)
-        node.compact_child_nodes.each { |c| collect_return_types(c, scope_index, out) }
-      end
-
-      def type_return_node(return_node, scope_index, out)
-        args = return_node.arguments&.arguments || []
-        if args.empty?
-          out << Type::Combinator.constant_of(nil)
-          return
-        end
-
-        scope = scope_index[return_node] || scope_index[args.first]
-        return if scope.nil?
-
-        # `return a, b` packs into a Tuple at runtime; the MVP
-        # only handles the single-value form. Multi-arg returns
-        # contribute no type to keep the implementation
-        # focused.
-        return unless args.size == 1
-
-        type = safe_return_type_of(scope, args.first)
-        out << type unless type.nil?
-      end
-
-      def safe_return_type_of(scope, node)
-        scope.type_of(node)
-      rescue StandardError
-        nil
+        Inference::DefReturnTyper.call(def_node, scope_index)
       end
 
       def dynamic_top?(type)
@@ -746,7 +686,7 @@ module Rigor
       def computed_literal_tightening?(inferred, def_node)
         return false unless inferred.is_a?(Type::Constant)
 
-        last = body_last_expression(def_node.body)
+        last = Inference::DefReturnTyper.body_last_expression(def_node.body)
         !direct_literal_node?(last)
       end
 
@@ -898,11 +838,15 @@ module Rigor
 
       # Per-file context the attr_* walker threads through its
       # recursive descent. Keeps parameter lists in check.
-      AttrWalkContext = Struct.new(:path, :scope_index, :out, keyword_init: true)
+      # `obs_ivar_map` carries the observation-derived fallback types
+      # built by {#build_observed_ivar_map}; it is empty when sig-gen
+      # is invoked without `--params=observed`.
+      AttrWalkContext = Struct.new(:path, :scope_index, :obs_ivar_map, :out, keyword_init: true)
       private_constant :AttrWalkContext
 
-      def collect_attr_candidates(root, path, scope_index)
-        ctx = AttrWalkContext.new(path: path, scope_index: scope_index, out: [])
+      def collect_attr_candidates(root, path, scope_index, obs_ivar_map = {})
+        ctx = AttrWalkContext.new(path: path, scope_index: scope_index,
+                                  obs_ivar_map: obs_ivar_map, out: [])
         walk_attr_calls(root, [], false, ctx)
         ctx.out
       end
@@ -941,7 +885,7 @@ module Rigor
         symbol_names = extract_symbol_arguments(call_node)
         return if symbol_names.empty?
 
-        ivar_lookup = ivar_type_lookup(ctx.scope_index, class_name)
+        ivar_lookup = ivar_type_lookup(ctx.scope_index, class_name, ctx.obs_ivar_map)
         symbol_names.each do |attr_name|
           ivar_type = ivar_lookup.call(attr_name)
           ctx.out.concat(build_attr_candidates(call_node.name, class_name, attr_name, ivar_type, ctx))
@@ -961,12 +905,143 @@ module Rigor
       # before any statement evaluation runs, so the lookup
       # works even when attr_* declarations come before the
       # corresponding ivar writes lexically.
-      def ivar_type_lookup(scope_index, class_name)
+      #
+      # When `obs_ivar_map` is non-empty (i.e. `--params=observed`
+      # was used), it acts as a fallback: if the ivar pre-pass
+      # resolved the type to `nil` or `Dynamic[top]` — typically
+      # because `@ivar = param` inside `initialize` typed the param
+      # as `untyped` — the observation-derived type is substituted.
+      # This lets `attr_reader :name` emit a concrete type when
+      # `ClassName.new("alice")` call sites are visible to the
+      # observation scan.
+      def ivar_type_lookup(scope_index, class_name, obs_ivar_map = {})
         any_scope = scope_index.each_value.first
         return ->(_) {} if any_scope.nil?
 
-        ivars = any_scope.class_ivars_for(class_name)
-        ->(attr_name) { ivars[:"@#{attr_name}"] }
+        ivars     = any_scope.class_ivars_for(class_name)
+        obs_ivars = obs_ivar_map[class_name] || {}
+        lambda do |attr_name|
+          type = ivars[:"@#{attr_name}"]
+          type.nil? || dynamic_top?(type) ? obs_ivars[attr_name] : type
+        end
+      end
+
+      # Build a { class_name => { attr_name_sym => Type } } map that
+      # records observation-derived types for ivars assigned directly
+      # from `def initialize` parameters. Only populated when
+      # `@observations` is non-empty (i.e. `--params=observed` was
+      # supplied). Matches the pattern `@ivar_name = param_name` where
+      # `param_name` is a required / optional positional or keyword
+      # parameter of `initialize`.
+      def build_observed_ivar_map(root)
+        return {} if @observations.empty?
+
+        result = {}
+        collect_init_ivar_obs(root, [], result)
+        result
+      end
+
+      def collect_init_ivar_obs(node, prefix, result)
+        return unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          name = qualified_constant_path(node.constant_path)
+          if name
+            collect_init_ivar_obs(node.body, prefix + [name], result) if node.body
+            return
+          end
+        when Prism::DefNode
+          if node.name == :initialize && !prefix.empty?
+            class_name = prefix.join("::")
+            map = ivar_obs_from_initialize(class_name, node)
+            result[class_name] = (result[class_name] || {}).merge(map) unless map.empty?
+          end
+          return
+        end
+
+        node.compact_child_nodes.each { |c| collect_init_ivar_obs(c, prefix, result) }
+      end
+
+      # Derive { attr_name_sym => Type } for a single `def initialize`
+      # by matching `@ivar = param_name` assignments against the
+      # available `[class_name, :initialize]` observations.
+      def ivar_obs_from_initialize(class_name, def_node)
+        obs_list = @observations[[class_name, :initialize]]
+        return {} if obs_list.nil? || obs_list.empty?
+        return {} if def_node.body.nil? || def_node.parameters.nil?
+
+        param_index = build_init_param_index(def_node.parameters)
+        return {} if param_index.empty?
+
+        ivar_to_param = {}
+        scan_ivar_param_assignments(def_node.body, param_index.keys.to_set, ivar_to_param)
+        build_ivar_obs_type_map(ivar_to_param, param_index, obs_list)
+      end
+
+      # Map `{ ivar_name => param_name }` → `{ attr_name_sym => Type }`
+      # by looking up each param's observation types and unioning them.
+      def build_ivar_obs_type_map(ivar_to_param, param_index, obs_list)
+        ivar_to_param.filter_map do |ivar_name, param_name|
+          types = collect_param_obs_types(obs_list, param_name, param_index[param_name])
+          next if types.empty?
+
+          attr_name = ivar_name.to_s.delete_prefix("@").to_sym
+          [attr_name, types.reduce { |acc, t| Type::Combinator.union(acc, t) }]
+        end.to_h
+      end
+
+      # Collect observed argument types for a single parameter across all
+      # call-site observations. Returns an array of Type objects (may be empty).
+      def collect_param_obs_types(obs_list, param_name, param_info)
+        case param_info[:kind]
+        when :positional then obs_list.filter_map { |obs| obs.positional[param_info[:index]] }
+        when :keyword    then obs_list.filter_map { |obs| obs.keyword[param_name] }
+        else []
+        end
+      end
+
+      # Map param_name_sym → { kind: :positional, index: N } or
+      # { kind: :keyword } for required / optional positionals and
+      # required / optional keywords of a ParametersNode.
+      def build_init_param_index(parameters)
+        index  = {}
+        offset = 0
+
+        (parameters.requireds || []).each_with_index do |p, i|
+          index[p.name] = { kind: :positional, index: offset + i } if p.respond_to?(:name)
+        end
+        offset += parameters.requireds&.size || 0
+
+        (parameters.optionals || []).each_with_index do |p, i|
+          index[p.name] = { kind: :positional, index: offset + i } if p.respond_to?(:name)
+        end
+
+        (parameters.keywords || []).each do |kw|
+          index[kw.name] = { kind: :keyword } if kw.respond_to?(:name)
+        end
+
+        index
+      end
+
+      # Walk a def body for direct `@ivar = local_var` assignments
+      # where `local_var` is one of the listed parameter names.
+      # Records ivar_name (Symbol with `@` prefix) → param_name.
+      # Does not recurse into nested defs / classes / modules.
+      def scan_ivar_param_assignments(node, param_names, result)
+        return unless node.is_a?(Prism::Node)
+
+        if node.is_a?(Prism::InstanceVariableWriteNode) &&
+           node.value.is_a?(Prism::LocalVariableReadNode) &&
+           param_names.include?(node.value.name)
+          result[node.name] ||= node.value.name
+        end
+
+        return if node.is_a?(Prism::DefNode) ||
+                  node.is_a?(Prism::ClassNode) ||
+                  node.is_a?(Prism::ModuleNode)
+
+        node.compact_child_nodes.each { |c| scan_ivar_param_assignments(c, param_names, result) }
       end
 
       def build_attr_candidates(call_name, class_name, attr_name, ivar_type, ctx)

data/lib/rigor/type/combinator.rb

@@ -256,6 +256,63 @@ module Rigor
           refined.base.class_name == "String"
       end
 
+      # Returns true when `type` is statically known to be a
+      # non-empty String — i.e. its value can never be `""`.
+      # Used at String binary-operator dispatch sites to propagate
+      # the non-empty guarantee through `+` and `*`.
+      #
+      # - `Constant[s]` where `s != ""` — a concrete non-empty literal.
+      # - `Difference[Nominal[String], Constant[""]]` — the canonical
+      #   `non-empty-string` carrier.
+      # - `Intersection[…]` — any member suffices (set-theoretic subset).
+      # - `Union[…]` — all members must qualify (the join may include "").
+      def non_empty_string_compatible?(type)
+        case type
+        when Constant then type.value.is_a?(String) && !type.value.empty?
+        when Difference then non_empty_string_difference?(type)
+        when Intersection then type.members.any? { |m| non_empty_string_compatible?(m) }
+        when Union then !type.members.empty? && type.members.all? { |m| non_empty_string_compatible?(m) }
+        else false
+        end
+      end
+
+      def non_empty_string_difference?(diff)
+        return false unless diff.base.is_a?(Nominal) && diff.base.class_name == "String"
+        return false unless diff.removed.is_a?(Constant)
+
+        diff.removed.value == ""
+      end
+
+      # Returns true when `type` is statically known to be a
+      # non-zero Integer — i.e. its value can never be `0`.
+      # Used at Integer arithmetic dispatch sites to propagate
+      # the non-zero guarantee through `*` and identity methods.
+      #
+      # - `Constant[n]` where `n != 0` — a concrete non-zero literal.
+      # - `Difference[Nominal[Integer], Constant[0]]` — the canonical
+      #   `non-zero-int` carrier.
+      # - `IntegerRange` that does not cover 0 — both `positive-int`
+      #   ([1,+∞)) and `negative-int` ([-∞,-1]) qualify.
+      # - `Intersection[…]` — any member suffices.
+      # - `Union[…]` — all members must qualify.
+      def non_zero_int_compatible?(type)
+        case type
+        when Constant then type.value.is_a?(Integer) && !type.value.zero?
+        when Difference then non_zero_int_difference?(type)
+        when IntegerRange then !type.covers?(0)
+        when Intersection then type.members.any? { |m| non_zero_int_compatible?(m) }
+        when Union then !type.members.empty? && type.members.all? { |m| non_zero_int_compatible?(m) }
+        else false
+        end
+      end
+
+      def non_zero_int_difference?(diff)
+        return false unless diff.base.is_a?(Nominal) && diff.base.class_name == "Integer"
+        return false unless diff.removed.is_a?(Constant)
+
+        diff.removed.value.zero?
+      end
+
       # Normalised intersection. Flattens nested Intersections,
       # drops `Top` members, collapses to `Bot` if any member is
       # `Bot`, deduplicates structurally-equal members, sorts the

data/lib/rigor/version.rb

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

data/sig/rigor/analysis/baseline.rbs

@@ -0,0 +1,39 @@
+module Rigor
+  module Analysis
+    # ADR-22 Slice 1 — per-project baseline filter.
+    # See lib/rigor/analysis/baseline.rb for the full contract.
+    class Baseline
+      class LoadError < ::StandardError
+      end
+
+      # Load a baseline file from disk.
+      # Returns `nil` when `path` is nil (no baseline configured).
+      # Raises {LoadError} on malformed or unsupported content.
+      def self.load: (::String? path) -> Baseline?
+
+      # Build a baseline from a current run's diagnostic stream.
+      def self.from_diagnostics: (untyped diagnostics, ?match_mode: :rule | :message) -> Baseline
+
+      attr_reader buckets: untyped
+
+      def initialize: (untyped buckets) -> void
+
+      # Apply the baseline filter. Returns [surfaced_diagnostics, silenced_count].
+      def filter: (untyped diagnostics) -> [untyped, ::Integer]
+
+      # Report bucket-level drift for each recorded baseline bucket.
+      def audit: (untyped diagnostics) -> untyped
+
+      # Return a new Baseline with the given buckets removed.
+      def without: (untyped buckets_to_drop) -> Baseline
+
+      # Serialise to a YAML string.
+      def to_yaml: () -> ::String
+
+      # Number of recorded buckets.
+      def size: () -> ::Integer
+
+      def empty?: () -> bool
+    end
+  end
+end

data/sig/rigor/environment.rbs

@@ -15,11 +15,12 @@ module Rigor
     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?, ?bundler_bundle_path: String?, ?bundler_auto_detect: bool, ?synthetic_method_index: untyped?, ?project_patched_methods: 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?, ?source_rbs_synthesis_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?, ?synthetic_method_index: untyped?, ?project_patched_methods: 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?, ?source_rbs_synthesis_reporter: untyped?, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> void
     def rbs_extended_reporter: () -> untyped?
     def boundary_cross_reporter: () -> untyped?
+    def source_rbs_synthesis_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?

data/sig/rigor/type.rbs

@@ -266,6 +266,10 @@ module Rigor
       def self?.non_numeric_string: () -> Refined
       def self?.literal_string_carrier?: (Type::t refined) -> bool
       def self?.literal_string_compatible?: (Type::t type) -> bool
+      def self?.non_empty_string_compatible?: (Type::t type) -> bool
+      def self?.non_empty_string_difference?: (Type::t diff) -> bool
+      def self?.non_zero_int_compatible?: (Type::t type) -> bool
+      def self?.non_zero_int_difference?: (Type::t diff) -> bool
       def self?.intersection: (*Type::t members) -> Type::t
       def self?.non_empty_lowercase_string: () -> Type::t
       def self?.non_empty_uppercase_string: () -> Type::t

data/sig/rigor.rbs

@@ -12,6 +12,8 @@ module Rigor
     attr_reader baseline_path: String?
 
     def self.load: (?String path) -> Configuration
+    def self.discover: () -> String?
+    def self.load_with_includes: (String path, ?visited: Set[String]) -> Hash[String, untyped]
     def initialize: (?Hash[String, untyped] data) -> void
     def to_h: () -> Hash[String, untyped]
   end