rigortype 0.4.7 → 0.4.8

data/lib/rigor/cli.rb

@@ -33,8 +33,11 @@ module Rigor
     # actionable": `SystemStackError` from an ancestry walk that never terminates, `NoMemoryError` from a
     # runaway allocation. Neither is a `StandardError`, so every rescue between here and the raise site
     # declines them by design — the whole point of those rescues is to convert a per-file or per-plugin
-    # failure into a diagnostic, and a process running out of stack is not per-file. Left uncaught they
-    # abort with Ruby's own ~40-frame dump, which is non-zero (so a CI gate does catch it) but says
+    # failure into a diagnostic. Since #2455 the per-file phases (`Runner#analyze_file_body`, the worker session,
+    # the discovery loops) do contain a `SystemStackError` raised from Ruby code, as that file's own crash row;
+    # what still reaches here is one raised from C (`Prism.parse` of a source nested near Prism's cap, which has
+    # no backtrace and leaves no stack to recover on), one outside a per-file phase, and `NoMemoryError`. Left
+    # uncaught they abort with Ruby's own ~40-frame dump, which is non-zero (so a CI gate does catch it) but says
     # neither that Rigor is at fault nor that the report on disk is empty. `Interrupt`, `SignalException`
     # and `SystemExit` stay out: those are the user's answer, not a failure.
     FATAL_ERRORS = [SystemStackError, NoMemoryError].freeze

data/lib/rigor/config_audit.rb

@@ -3,7 +3,10 @@
 require "did_you_mean"
 
 require_relative "config_path"
+require_relative "environment/bundle_sig_discovery"
+require_relative "environment/rbs_collection_discovery"
 require_relative "flow_contribution/conflict"
+require_relative "library_probe"
 require_relative "signature_path_audit"
 # ADR-87 WD4 — only the pure rule-id table (`ALL_RULES` / `RULE_FAMILIES`) is needed, so require the light
 # `rule_ids.rb` rather than the engine-pulling `check_rules.rb`; keeps `config_audit` (loaded by every check)
@@ -37,8 +40,8 @@ module Rigor
   module ConfigAudit
     # One config-level finding. `kind` discriminates the source key (`:unknown_key`, `:signature_path`,
     # `:bundled_plugin_signature_path`, `:library`, `:disabled_rule`, `:severity_override`,
-    # `:bundler_bundle_path`, `:bundler_lockfile`, `:rbs_collection_lockfile`); `fields` carries the kind-specific
-    # structured data merged into {#to_h} for JSON consumers.
+    # `:bundler_bundle_path`, `:bundler_lockfile`, `:rbs_collection_lockfile`, `:rbs_collection_library`); `fields`
+    # carries the kind-specific structured data merged into {#to_h} for JSON consumers.
     Warning = Data.define(:kind, :message, :fields) do
       def to_h
         { "kind" => kind.to_s, "message" => message }.merge(fields)
@@ -51,7 +54,7 @@ module Rigor
       unknown_key_warnings(configuration) +
         signature_path_warnings(configuration) +
         bundled_plugin_signature_path_warnings(configuration) +
-        library_warnings(configuration) +
+        library_warnings(configuration, project_root) +
         rule_token_warnings(configuration) +
         explicit_path_warnings(configuration, project_root)
     end
@@ -129,21 +132,32 @@ module Rigor
       end
     end
 
-    # `libraries:` entries RBS does not recognise. Uses the same
-    # `RBS::EnvironmentLoader#has_library?` guard the loader filters through
-    # ({Environment::RbsLoader} `build_env_for`), so a flagged name is exactly one the loader
-    # skipped. Fails soft: if RBS itself raises, no warning rather than a crash.
-    def self.library_warnings(configuration)
-      configured = Array(configuration.libraries)
-      return [] if configured.empty?
-
-      loader = ::RBS::EnvironmentLoader.new
-      configured.reject { |lib| loader.has_library?(library: lib.to_s, version: nil) }.map do |lib|
-        Warning.new(
-          kind: :library,
-          message: "libraries: #{lib.to_s.inspect} is not an available RBS library (no signatures loaded from it)",
-          fields: { "name" => lib.to_s }
-        )
+    # `libraries:` entries RBS does not recognise, and — issue #2946 — `source: { type: stdlib }` entries of
+    # the run's `rbs_collection.lock.yaml`, which load as libraries too ({Environment::BaseLibraries.resolve}). Uses the
+    # same `RBS::EnvironmentLoader#has_library?` answer the loader filters through
+    # ({Environment::RbsLoader} `library_loader`), so a flagged name is one the loader skipped. A
+    # {Environment::RequiredFeatures::VENDORED_DIRS} name (`prime`) under `libraries:` is not audited: the
+    # configuration turns it into a vendored feature token the loader never asks `has_library?` about. A
+    # lockfile entry of that name is not a token, so it is still audited. The `rbs` CLI warns on the same
+    # lockfile entry (`Collection::Sources::Stdlib#manifest_of`).
+    # Fails soft: if RBS itself raises, no warning rather than a crash.
+    def self.library_warnings(configuration, project_root = Dir.pwd)
+      lock = { lockfile_path: configuration.rbs_collection_lockfile, project_root: project_root,
+               auto_detect: configuration.rbs_collection_auto_detect }
+      lockfile = Environment::RbsCollectionDiscovery.stdlib_library_names(**lock)
+      # Issue #2971 — a `libraries:` name the collection lockfile provides loads from the collection, not as an
+      # RBS library, so it is not an unknown library.
+      provided = Environment::RbsCollectionDiscovery.collection_gem_names(**lock)
+      named = (LibraryProbe.auditable(configuration.libraries) - provided).map { |lib| [:library, "libraries:", lib] } +
+              lockfile.map { |name| [:rbs_collection_library, "rbs_collection.lock.yaml: stdlib entry", name] }
+      return [] if named.empty?
+
+      unavailable = LibraryProbe.predicate.then { |has| named.reject { |_, _, lib| has.call(lib) } }
+      # Issue #2987 — nor is a name whose own `sig/` the bundle loaded; read only once a name is unavailable.
+      bundled = unavailable.empty? ? [] : Environment::BundleSigDiscovery.loaded_names(configuration, project_root)
+      unavailable.reject { |kind, _, lib| kind == :library && bundled.include?(lib) }.map do |kind, source, lib|
+        Warning.new(kind: kind, fields: { "name" => lib },
+                    message: "#{source} #{lib.inspect} is not an available RBS library (no signatures loaded from it)")
       end
     rescue StandardError
       []

data/lib/rigor/configuration/severity_profile.rb

@@ -86,6 +86,7 @@ module Rigor
           # a config edit the author may deliberately not want.
           "effect.annotations-unchecked" => :info,
           "static.value-use.void" => :off,
+          "plugin.api-surface" => :off,
           # Opt-in author assertion: you only see it if you wrote a
           # `conforms-to` directive, so it stays a :warning even in
           # lenient — it is never unsolicited noise.
@@ -131,6 +132,7 @@ module Rigor
           "suppression.empty" => :warning,
           "suppression.unknown-marker" => :warning,
           "static.value-use.void" => :off,
+          "plugin.api-surface" => :off,
           "effect.envelope-exceeded" => :warning,
           "effect.liskov-widened" => :warning,
           "effect.unknown-label" => :info,
@@ -173,6 +175,7 @@ module Rigor
           "suppression.unknown-marker" => :warning,
           # `:off` even under strict: the gate is `bleeding_edge:`, not the profile (ADR-50 WD1 / ADR-100).
           "static.value-use.void" => :off,
+          "plugin.api-surface" => :off,
           "effect.envelope-exceeded" => :error,
           "effect.liskov-widened" => :error,
           "effect.unknown-label" => :warning,
@@ -234,11 +237,17 @@ module Rigor
 
       private_class_method :row_override
 
+      # Rule ids a dot-free family key does not reach. `plugin.api-surface` is the one built-in id under `plugin.`,
+      # the prefix of plugin rows, so a `plugin` key must not turn the bleeding-edge rule on (#2822); `disable:
+      # [plugin]` does not reach it either. A key naming the id itself still does, in either direction.
+      FAMILY_FALLBACK_EXEMPT = ["plugin.api-surface"].freeze
+
       # A family name has no `.` in it, so only a dot-free key can match one. `resolve` runs for every
       # diagnostic in a run's stream, and most configurations carry no such key (usually no overrides at all),
       # so the split below is skipped for them rather than allocating a name that nothing can match.
       def family_override(rule, overrides)
         return nil unless overrides.any? { |key, _| !key.to_s.include?(".") }
+        return nil if FAMILY_FALLBACK_EXEMPT.include?(rule)
 
         family = rule.split(".").first
         return nil if family.nil?

data/lib/rigor/configuration.rb

@@ -212,8 +212,8 @@ module Rigor
         # set up with `rbs collection install`, the resulting `rbs_collection.lock.yaml` carries the resolved
         # (gem, version, source) triples and `.gem_rbs_collection/` holds the downloaded `.rbs` files. Rigor
         # parses the lockfile and auto-feeds each gem's `<collection_root>/<name>/<version>/` directory into
-        # `RbsLoader`'s `signature_paths:`. Sources of type `stdlib` are skipped because rigor's bundled
-        # `DEFAULT_LIBRARIES` already covers that surface.
+        # `RbsLoader`'s `signature_paths:`. Sources of type `stdlib` install no directory; issue #2946 — they
+        # load as RBS libraries, appended to `DEFAULT_LIBRARIES + libraries:`, as the `rbs` CLI loads them.
         #
         # `lockfile:` (String, optional): explicit path to `rbs_collection.lock.yaml`. Resolved relative to
         # the project root when relative.
@@ -361,7 +361,8 @@ module Rigor
     # [PHPStan](https://phpstan.org/config-reference#paths).
     def self.load(path = nil)
       resolved = path || discover
-      if resolved.nil? || !File.exist?(resolved)
+      loaded = resolved && File.exist?(resolved) ? resolved : nil
+      if loaded.nil?
         data = DEFAULTS
         effects_key_present = false
         target_ruby_key_present = false
@@ -370,13 +371,14 @@ module Rigor
         # `DEFAULTS` itself carries an `"effects" => false` entry: once merged, "the file never wrote
         # `effects:`" and "the file wrote `effects: false`" collapse to the same value and become
         # indistinguishable to {#initialize}. This is the only place that distinction still exists.
-        raw = load_with_includes(resolved)
+        raw = load_with_includes(loaded)
         effects_key_present = raw.key?("effects")
         target_ruby_key_present = raw.key?("target_ruby")
         data = DEFAULTS.merge(raw)
       end
       new(autowire_default_plugins(data), effects_key_present, target_ruby_key_present || false)
-        .with_exclude_base(resolved && File.exist?(resolved) ? File.dirname(resolved) : nil)
+        .with_exclude_base(loaded && File.dirname(loaded))
+        .with_config_path(loaded)
     end
 
     # #1576 — the directory relative `exclude:` patterns are matched against: the directory of the config file in
@@ -385,6 +387,17 @@ module Rigor
       @base_dir || Dir.pwd
     end
 
+    # Issue #2742 — the path config-anchored diagnostics are positioned at: the loaded config file's path
+    # relative to the working directory (the project-root convention {Analysis::Baseline} uses), or
+    # `.rigor.yml` when no file was loaded. A `--config=config/rigor.yml` run names `config/rigor.yml`.
+    def config_display_path
+      return DEFAULT_PATH if @config_path.nil?
+
+      Pathname.new(@config_path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+    rescue ArgumentError
+      @config_path
+    end
+
     # ADR-93 WD2 — the one bundled plugin default-wired without a `plugins:` entry. `rigor-rbs-inline` is the
     # gem; `rbs-inline` is its manifest id (the loader raises on a duplicate id, so both forms count as
     # "already listed").
@@ -675,6 +688,10 @@ module Rigor
     def to_h # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       {
         "target_ruby" => target_ruby,
+        # Issue #2742 — the loaded file's display path is part of the resolved configuration: two files
+        # with identical bodies still anchor their config diagnostics differently, so the run-cache and
+        # incremental fingerprints must tell them apart.
+        "config_path" => config_display_path,
         # A stated `target_ruby` turns on the deprecation rules a defaulted one leaves off (#1692), so the run cache
         # key and the incremental fingerprint must tell the two apart even where the value matches.
         "target_ruby_explicit" => target_ruby_explicit?,
@@ -784,6 +801,16 @@ module Rigor
       copy.freeze
     end
 
+    # Issue #2742 — a sibling Configuration recording which file {Configuration.load} read, so the
+    # diagnostics anchored at "the configuration" name it ({#config_display_path}). `path` is the resolved
+    # config path; nil — no file loaded, or a bare {Configuration.new} — keeps the `.rigor.yml` default.
+    # Same frozen `dup` shape as {#with_exclude_base}.
+    def with_config_path(path)
+      copy = dup
+      copy.instance_variable_set(:@config_path, path && File.absolute_path(path).freeze)
+      copy.freeze
+    end
+
     # #1777 — a sibling Configuration with only `baseline:` unset, every other field (including the
     # explicitness of `target_ruby`) shared with the receiver. `rigor baseline generate` analyses with
     # this so the generating run sees exactly the configuration `rigor check` will, minus the filter it

data/lib/rigor/effects/collector.rb

@@ -2,6 +2,7 @@
 
 require_relative "../type"
 require_relative "../inference/origin_lookup"
+require_relative "../typing_state"
 require_relative "attribution"
 require_relative "envelope_index"
 require_relative "file_collection"
@@ -24,8 +25,26 @@ module Rigor
     # `dynamic_origins` cause the typer already recorded. With no `effects:` block nothing calls
     # {collect_for}, `@active_count` stays zero, and `rigor check` is byte-identical.
     module Collector
-      KEY = :__rigor_effects_collector__
-      private_constant :KEY
+      # ADR-129 WD1 — the installed accumulator is a Frame whose contents are a Resource; only {record_root} touches it
+      # now, and the call-site decisions are the bound Table {CALLS}. The activation count below is a process switch,
+      # outside the typing state (WD5).
+      ACCUMULATOR = TypingState.frame(
+        :effects_collector,
+        contents: :resource, reason: "the accumulator a file's collection installs; each call site records into it",
+        # G1′ witness: `Collector.record_call` reads it during typing, so it is not a never-reads switch.
+        witness: "spec/fixtures/typing_state_witnesses/effects_collector.rb"
+      )
+      private_constant :ACCUMULATOR
+
+      # ADR-129 WD1 — the per-file call-site decisions are a bound Table: each installed accumulator's `calls` is one of
+      # its stores, journaled while a capture is open so a later `type_of` memo can validate the reads and replay the
+      # writes. The root ({record_root}) stays a touch of the accumulator: it is set once per file, before typing.
+      CALLS = TypingState.table(
+        :effects_calls,
+        bound: true,
+        reason: "node => CallRecord per file accumulator; first write wins, and a re-query reads the pinned decision"
+      )
+      private_constant :CALLS
 
       # What one call site decided, as the typer saw it.
       #
@@ -97,17 +116,18 @@ module Rigor
       # site imports must not depend on which process typed the file.
       def collect_for(path, attribution: Attribution.empty, envelopes: EnvelopeIndex.empty,
                       plugin_facts: PluginFacts.empty, unit_key: nil, unit_owner: nil)
-        previous = Thread.current[KEY]
         accumulator = Accumulator.new(path.to_s, attribution: attribution, envelopes: envelopes,
                                                  plugin_facts: plugin_facts, unit_key: unit_key,
                                                  unit_owner: unit_owner)
-        Thread.current[KEY] = accumulator
-        @mutex.synchronize { @active_count += 1 }
-        yield
-        build(accumulator)
-      ensure
-        Thread.current[KEY] = previous
-        @mutex.synchronize { @active_count -= 1 }
+        TypingState.current.with(ACCUMULATOR, accumulator) do
+          @mutex.synchronize { @active_count += 1 }
+          begin
+            yield
+            build(accumulator)
+          ensure
+            @mutex.synchronize { @active_count -= 1 }
+          end
+        end
       end
 
       def active?
@@ -117,8 +137,12 @@ module Rigor
       # The parsed root of the file being analyzed. Recorded by the analysis body once the parse is known
       # to have succeeded, so the scan runs over exactly what the typer saw.
       def record_root(root)
-        accumulator = Thread.current[KEY]
-        accumulator.root = root if accumulator && accumulator.root.nil?
+        state = TypingState.current
+        accumulator = state[ACCUMULATOR]
+        return unless accumulator
+
+        state.touch(ACCUMULATOR)
+        accumulator.root = root if accumulator.root.nil?
       end
 
       # One call site's dispatch decision. `receiver` is the type the typer computed for the receiver and
@@ -127,30 +151,38 @@ module Rigor
       # The `scope.source_path` guard matters: inter-procedural inference re-types a *callee's* body while
       # the caller's file is being analyzed, and those nodes belong to the callee's own file collection.
       def record_call(node, receiver, scope)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[ACCUMULATOR]
         return if accumulator.nil? || accumulator.path != scope.source_path
+
         # First write wins, so a re-query has nothing to add — and asking here rather than inside
         # {Accumulator#record} is what stops it paying for the `Data` and the origin lookup below.
+        calls = accumulator.calls
+        state.log_bound_read(CALLS, calls, node, calls.fetch(node, TypingState::ABSENT)) if state.capturing?
         return if accumulator.recorded?(node)
 
         dynamic = dynamic_receiver?(receiver)
         class_name, kind = descriptor_for(receiver)
-        accumulator.record(
-          node,
-          CallRecord.new(
-            receiver_class: class_name, kind: kind, dynamic: dynamic,
-            cause: dynamic ? Inference::OriginLookup.origin_for(scope, node.receiver)&.to_s : nil,
-            resolved: true
-          )
+        call_record = CallRecord.new(
+          receiver_class: class_name, kind: kind, dynamic: dynamic,
+          cause: dynamic ? Inference::OriginLookup.origin_for(scope, node.receiver)&.to_s : nil,
+          resolved: true
         )
+        accumulator.record(node, call_record)
+        state.log_bound_write(CALLS, calls, node, call_record, TypingState::ABSENT)
       end
 
       # The typer's fallback verdict: no tier resolved this call.
       def record_unresolved(node, source_path)
-        accumulator = Thread.current[KEY]
+        state = TypingState.current
+        accumulator = state[ACCUMULATOR]
         return if accumulator.nil? || accumulator.path != source_path
 
+        calls = accumulator.calls
+        existing = calls.fetch(node, TypingState::ABSENT)
+        state.log_bound_read(CALLS, calls, node, existing)
         accumulator.mark_unresolved(node)
+        state.log_bound_write(CALLS, calls, node, calls[node], existing) unless TypingState::ABSENT.equal?(existing)
       end
 
       # The class a receiver type projects to, as `[class_name, kind]`. A deliberately small mirror of the

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -4,6 +4,7 @@ require "yaml"
 
 require_relative "../config_path"
 require_relative "../rooted_glob"
+require_relative "lockfile_resolver"
 
 module Rigor
   class Environment
@@ -49,6 +50,10 @@ module Rigor
         "bundler", "rubygems"
       ].freeze
 
+      # The two bundle layouts {.discover} walks, relative to the resolved bundle root. Also the listing rows the
+      # run cache records (issue #2987), so a gem gaining or losing `sig/` invalidates it.
+      SIG_GLOBS = %w[ruby/*/gems/*/sig ruby/*/bundler/gems/*/sig].freeze
+
       # @param bundle_path — explicit path to the bundler install root. When `nil`,
       #   falls back to `auto_detect` if `auto_detect:` is true.
       # @param project_root — resolution base for relative `bundle_path:` and the auto-detect search.
@@ -92,45 +97,75 @@ module Rigor
         # all (`Bundler::Source::Path#path` is the user's own `path:` directory, used in place), so there is
         # no bundle-relative location to walk. A `path:`-sourced gem's `sig/` is only reachable by adding it
         # directly to the project's `signature_paths:` — which already works today and needs no discovery.
-        all = (RootedGlob.glob(resolved, "ruby/*/gems/*/sig") +
-               RootedGlob.glob(resolved, "ruby/*/bundler/gems/*/sig")).map { |d| Pathname.new(d) }
-        filtered = all.reject { |sig_dir| skip_gems.include?(gem_name_from_sig_path(sig_dir)) }
-        return filtered if locked_gems.nil? || locked_gems.empty?
+        all = SIG_GLOBS.flat_map { |pattern| RootedGlob.glob(resolved, pattern) }.map { |d| Pathname.new(d) }
+        if locked_gems.nil? || locked_gems.empty?
+          return all.reject { |sig_dir| skip_gems.include?(gem_name_from_sig_path(sig_dir)) }
+        end
 
-        expected_dirs = expected_gem_dirs(locked_gems)
-        filtered.select do |sig_dir|
-          if git_sourced_layout?(sig_dir)
-            # A git install's directory carries no version, so the lockfile filter can only check the gem NAME.
-            # Name alone is not enough: a gem that moved from `git:` to a released version keeps its stale
-            # `bundler/gems/` checkout until `bundle clean`, under a name the lockfile still lists. `locked_gems`
-            # must say this name is CURRENTLY git-sourced, not merely present.
-            locked = locked_gems[gem_name_from_sig_path(sig_dir)]
-            !!locked&.git_source
-          else
-            expected_dirs.include?(sig_dir.parent.basename.to_s)
-          end
+        # Issue #2978 — with a lockfile, a directory's gem name is the locked entry it matches, not a parse of the
+        # directory name, which reads `foo-2fa-1.0` as `foo`.
+        names = locked_dir_names(locked_gems)
+        all.select do |sig_dir|
+          name = locked_name_of(sig_dir, locked_gems, names)
+          name && !skip_gems.include?(name)
+        end
+      end
+
+      # The locked gem name `sig_dir` belongs to, or nil when it matches no locked entry. A git install's directory
+      # carries no version, so only the gem NAME can be checked. Name alone is not enough: a gem that moved from
+      # `git:` to a released version keeps its stale `bundler/gems/` checkout until `bundle clean`, under a name the
+      # lockfile still lists, so `locked_gems` must say this name is CURRENTLY git-sourced, not merely present.
+      #
+      # @param names — {.locked_dir_names} of `locked_gems`.
+      def self.locked_name_of(sig_dir, locked_gems, names)
+        if git_sourced_layout?(sig_dir)
+          name = gem_name_from_sig_path(sig_dir)
+          locked_gems[name]&.git_source ? name : nil
+        else
+          names[sig_dir.parent.basename.to_s]
         end
       end
+      private_class_method :locked_name_of
+
+      # Issue #2971 — the locked gem names `sig_dirs` (a {.discover} result) belong to, keyed the way {.discover}
+      # filters: a rubygems-layout directory by `<name>-<version>[-<platform>]` against the locked variants, a git
+      # layout by a git-sourced locked entry of that name. Unlike {.gem_name_from_sig_path} it never truncates a
+      # name that holds a `-<digit>` (`foo-2fa-1.0` is `foo-2fa`, not `foo`).
+      def self.locked_names_of(sig_dirs, locked_gems)
+        return [] if locked_gems.nil? || locked_gems.empty?
+
+        names = locked_dir_names(locked_gems)
+        sig_dirs.filter_map { |dir| locked_name_of(dir, locked_gems, names) }.uniq
+      end
+
+      # Issue #2987 — the locked gem names whose own `sig/` {.discover} loads for a configuration's bundle and
+      # lockfile: a pure file read ({LockfileResolver}), so the `libraries:` audit can ask without loading `rbs`.
+      def self.loaded_names(configuration, project_root)
+        auto_detect = configuration.bundler_auto_detect
+        locked = LockfileResolver.locked_gems(lockfile_path: configuration.bundler_lockfile,
+                                              project_root: project_root, auto_detect: auto_detect)
+        dirs = discover(bundle_path: configuration.bundler_bundle_path, project_root: project_root,
+                        auto_detect: auto_detect, locked_gems: locked.empty? ? nil : locked)
+        locked_names_of(dirs, locked)
+      end
 
-      # `{name => LockedGem}` → set of canonical bundler gem directory basenames. Pure-Ruby gems install as
+      # `{name => LockedGem}` → `{canonical bundler gem directory basename => name}`. Pure-Ruby gems install as
       # `<name>-<version>`; platform-specific gems install as `<name>-<version>-<platform>` (e.g.
       # `ffi-1.17.4-aarch64-linux-gnu`). Lockfile platform `"ruby"` is the pure-Ruby case; any other value is
       # treated as a platform tag. Every locked variant contributes a directory (#1844): the set only selects
       # among directories that are actually installed, so admitting another platform's name costs nothing,
-      # while dropping the host's would discard its `sig/`.
-      def self.expected_gem_dirs(locked_gems)
-        locked_gems.each_value.with_object(Set.new) do |locked, set|
+      # while dropping the host's would discard its `sig/`. Issue #2978 — the name comes from the lockfile, so a name
+      # holding `-<digit>` is read whole.
+      def self.locked_dir_names(locked_gems)
+        locked_gems.each_value.with_object({}) do |locked, names|
           locked.variants.each do |version, platform|
             base = "#{locked.name}-#{version}"
-            set << if platform == "ruby" || platform.empty?
-                     base
-                   else
-                     "#{base}-#{platform}"
-                   end
+            dir = platform == "ruby" || platform.empty? ? base : "#{base}-#{platform}"
+            names[dir] = locked.name
           end
         end
       end
-      private_class_method :expected_gem_dirs
+      private_class_method :locked_dir_names
 
       # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`, or
       # `<bundle>/ruby/X.Y.Z/bundler/gems/<repo>-<12-hex-revision>/sig` → `<repo>`. The two bundler-install
@@ -145,8 +180,8 @@ module Rigor
       #   different repo name, a monorepo). Strip the fixed-width hex suffix instead; best-effort only, since
       #   the true gem name isn't recoverable from the filesystem without running Bundler.
       #
-      # Public so the O4 Layer 3 slice-3 coverage report (`RbsCoverageReport`) can classify discovered bundle
-      # sigs against locked gem names without re-running discovery.
+      # Only for a directory no lockfile names: with one, {.locked_names_of} reads the name off the locked entry
+      # instead (issue #2978), since a name holding `-<digit>` (`foo-2fa-1.0`) truncates here to `foo`.
       def self.gem_name_from_sig_path(sig_dir)
         gem_dir = sig_dir.parent.basename.to_s
         if git_sourced_layout?(sig_dir)

data/lib/rigor/environment/constant_type_cache_holder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   class Environment
     # Per-key memoization container for {Environment#constant_for_name}. Held by {Environment} so the
@@ -22,6 +24,9 @@ module Rigor
     # reader path. If a future caller introduces a multi-threaded reader against one Environment, the
     # synchronisation belongs at that caller's seam, not here.
     class ConstantTypeCacheHolder
+      TypingState.memo_field(self, :@cache, reason: "keyed on the constant name; a pure function of the name for " \
+                                                    "the environment's lifetime (Environment#constant_for_name)")
+
       def initialize
         @cache = {}
       end

data/lib/rigor/environment/default_libraries.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "rbs_collection_discovery"
+
 module Rigor
   class Environment
     # Stdlib libraries that `Environment.for_project` loads on top of RBS core
@@ -32,5 +34,20 @@ module Rigor
       strscan
       prism rbs
     ].freeze
+
+    # The library list a run loads before its `RequiredFeatures` tokens: {DEFAULT_LIBRARIES}, then the
+    # configured `libraries:`, then — issue #2946 — the `source: { type: stdlib }` entries of the run's
+    # `rbs_collection.lock.yaml` ({RbsCollectionDiscovery.stdlib_library_names}), de-duplicated in that order.
+    # `Environment.for_project` and the boot-slimming probe's `RunCacheKey.libraries_config_entries` both build
+    # it here, so the cache key's `rbs.libraries` slot names the lockfile's libraries on both paths. A module of
+    # its own, not an `Environment` class method, so the plugin-facing `Environment` surface does not grow.
+    module BaseLibraries
+      def self.resolve(libraries, rbs_collection_lockfile:, rbs_collection_auto_detect:, root: Dir.pwd)
+        collection_stdlib = RbsCollectionDiscovery.stdlib_library_names(
+          lockfile_path: rbs_collection_lockfile, project_root: root, auto_detect: rbs_collection_auto_detect
+        )
+        (DEFAULT_LIBRARIES + libraries.map(&:to_s) + collection_stdlib).uniq
+      end
+    end
   end
 end