rigortype 0.2.7 → 0.2.8

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -6,40 +6,27 @@ module Rigor
   class Environment
     # Target-project Bundler awareness (O4, implemented).
     #
-    # Walks a Bundler-installed gem tree (e.g., the project's
-    # `vendor/bundle` or a Docker-mounted bundle root) and
-    # returns the per-gem `sig/` directories to feed into
-    # `RbsLoader`'s `signature_paths:`. Of the ~3% of gems that
-    # ship `sig/` in their gem package today (per the four-project
-    # Mastodon Docker bundle-install measurement on 2026-05-15:
-    # 10 of 343 gems shipped sig — `prism`, `aws-sdk-s3`,
-    # `aws-sdk-kms`, `aws-sdk-core`, `playwright-ruby-client`,
-    # `mutex_m`, `webrick`, `base64`, `stoplight`, `ffi`), this
-    # discovery surfaces the typed contract the gem author
-    # explicitly published.
+    # Walks a Bundler-installed gem tree (e.g., the project's `vendor/bundle` or a Docker-mounted bundle
+    # root) and returns the per-gem `sig/` directories to feed into `RbsLoader`'s `signature_paths:`. Of the
+    # ~3% of gems that ship `sig/` in their gem package today (per the four-project Mastodon Docker
+    # bundle-install measurement on 2026-05-15: 10 of 343 gems shipped sig — `prism`, `aws-sdk-s3`,
+    # `aws-sdk-kms`, `aws-sdk-core`, `playwright-ruby-client`, `mutex_m`, `webrick`, `base64`, `stoplight`,
+    # `ffi`), this discovery surfaces the typed contract the gem author explicitly published.
     #
-    # Conflicts with rigor's bundled stdlib RBS (the prism case
-    # was the motivating example) degrade gracefully via O7's
-    # failure-memo in `RbsLoader#env`: a single warning naming
-    # the offending file is emitted and analysis continues with
-    # `Dynamic[top]` everywhere rather than hanging.
+    # Conflicts with rigor's bundled stdlib RBS (the prism case was the motivating example) degrade
+    # gracefully via O7's failure-memo in `RbsLoader#env`: a single warning naming the offending file is
+    # emitted and analysis continues with `Dynamic[top]` everywhere rather than hanging.
     #
-    # The discovery is intentionally a pure file-system walk —
-    # no `Bundler` API call, no `Gemfile.lock` parse — so rigor
-    # doesn't need the target project's Bundler context.
+    # The discovery is intentionally a pure file-system walk — no `Bundler` API call, no `Gemfile.lock`
+    # parse — so rigor doesn't need the target project's Bundler context.
     module BundleSigDiscovery
-      # Gems already covered by rigor's `DEFAULT_LIBRARIES`
-      # (stdlib RBS) plus the `data/vendored_gem_sigs/` bundle.
-      # Skipping these from bundle discovery prevents
-      # `RBS::DuplicatedDeclarationError` (the prism case was the
-      # motivating example — Ruby 4.0 ships prism's RBS in
-      # stdlib, and the gem also ships its own `sig/`, so loading
-      # both raises on `Prism::BACKEND` etc.).
+      # Gems already covered by rigor's `DEFAULT_LIBRARIES` (stdlib RBS) plus the `data/vendored_gem_sigs/`
+      # bundle. Skipping these from bundle discovery prevents `RBS::DuplicatedDeclarationError` (the prism
+      # case was the motivating example — Ruby 4.0 ships prism's RBS in stdlib, and the gem also ships its
+      # own `sig/`, so loading both raises on `Prism::BACKEND` etc.).
       #
-      # The list is hard-coded for the MVP because it tracks
-      # rigor's bundled coverage 1:1. When a new gem is vendored
-      # under `data/vendored_gem_sigs/` or added to
-      # `DEFAULT_LIBRARIES`, add its name here.
+      # The list is hard-coded for the MVP because it tracks rigor's bundled coverage 1:1. When a new gem is
+      # vendored under `data/vendored_gem_sigs/` or added to `DEFAULT_LIBRARIES`, add its name here.
       SKIPPED_GEMS_BY_DEFAULT = Set[
         # DEFAULT_LIBRARIES (lib/rigor/environment.rb)
         "pathname", "optparse", "json", "yaml", "fileutils",
@@ -58,31 +45,22 @@ module Rigor
         "pg", "mysql2", "nokogiri", "bcrypt", "redis", "idn-ruby"
       ].freeze
 
-      # @param bundle_path [String, Pathname, nil] explicit path
-      #   to the bundler install root. When `nil`, falls back to
-      #   `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for relative
-      #   `bundle_path:` and the auto-detect search.
-      # @param auto_detect [Boolean] when true and `bundle_path:`
-      #   is nil, try `.bundle/config`'s `BUNDLE_PATH:` and
-      #   `vendor/bundle/` under `project_root`.
-      # @param skip_gems [Set<String>] gem names to exclude from
-      #   discovery. Defaults to {SKIPPED_GEMS_BY_DEFAULT}.
-      # @param locked_gems [Hash{String => LockfileResolver::LockedGem}, nil]
-      #   Optional O4-Layer-3 filter. When non-nil and non-empty,
-      #   only `sig/` directories whose gem `(name, version,
-      #   platform)` tuple matches a lockfile entry are returned.
-      #   Bundle entries absent from the lockfile (or at a drifted
-      #   version) are silently dropped — the lockfile is treated
-      #   as the source of truth for "what gems this project
-      #   actually declares". Pass `nil` (the default) to keep
-      #   the pre-Layer-3 behaviour of returning every non-skipped
-      #   `sig/` under the bundle.
-      # @return [Array<Pathname>] every `<gem-dir>/sig` directory
-      #   under the resolved bundle path, minus any whose gem
-      #   name is in `skip_gems` and (when `locked_gems` is
-      #   supplied) minus any whose `(name, version, platform)`
-      #   does not match a lockfile entry.
+      # @param bundle_path [String, Pathname, nil] explicit path to the bundler install root. When `nil`,
+      #   falls back to `auto_detect` if `auto_detect:` is true.
+      # @param project_root [String] resolution base for relative `bundle_path:` and the auto-detect search.
+      # @param auto_detect [Boolean] when true and `bundle_path:` is nil, try `.bundle/config`'s
+      #   `BUNDLE_PATH:` and `vendor/bundle/` under `project_root`.
+      # @param skip_gems [Set<String>] gem names to exclude from discovery. Defaults to
+      #   {SKIPPED_GEMS_BY_DEFAULT}.
+      # @param locked_gems [Hash{String => LockfileResolver::LockedGem}, nil] Optional O4-Layer-3 filter.
+      #   When non-nil and non-empty, only `sig/` directories whose gem `(name, version, platform)` tuple
+      #   matches a lockfile entry are returned. Bundle entries absent from the lockfile (or at a drifted
+      #   version) are silently dropped — the lockfile is treated as the source of truth for "what gems this
+      #   project actually declares". Pass `nil` (the default) to keep the pre-Layer-3 behaviour of
+      #   returning every non-skipped `sig/` under the bundle.
+      # @return [Array<Pathname>] every `<gem-dir>/sig` directory under the resolved bundle path, minus any
+      #   whose gem name is in `skip_gems` and (when `locked_gems` is supplied) minus any whose `(name,
+      #   version, platform)` does not match a lockfile entry.
       def self.discover(bundle_path:, project_root: Dir.pwd, auto_detect: true,
                         skip_gems: SKIPPED_GEMS_BY_DEFAULT, locked_gems: nil, home: nil)
         resolved = resolve_bundle_path(
@@ -93,9 +71,8 @@ module Rigor
         )
         return [] if resolved.nil?
 
-        # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig/` is the
-        # canonical bundler layout. `*` on the ruby version dir
-        # picks up whichever Ruby the bundle was installed for.
+        # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig/` is the canonical bundler layout. `*` on the ruby
+        # version dir picks up whichever Ruby the bundle was installed for.
         all = Dir.glob(resolved.join("ruby", "*", "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?
@@ -104,12 +81,10 @@ module Rigor
         filtered.select { |sig_dir| expected_dirs.include?(sig_dir.parent.basename.to_s) }
       end
 
-      # `{name => LockedGem}` → set of canonical bundler gem
-      # directory basenames. 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.
+      # `{name => LockedGem}` → set of canonical bundler gem directory basenames. 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.
       def self.expected_gem_dirs(locked_gems)
         locked_gems.each_value.with_object(Set.new) do |locked, set|
           base = "#{locked.name}-#{locked.version}"
@@ -122,28 +97,22 @@ module Rigor
       end
       private_class_method :expected_gem_dirs
 
-      # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`.
-      # The gem directory follows the canonical
-      # `<name>-<version>` pattern; we strip everything from the
-      # last hyphen onwards to recover the name. (Platform-tagged
-      # variants like `ffi-1.17.4-aarch64-linux-gnu/` keep their
-      # platform suffix in the version part, so the first hyphen
-      # from the right is still the name boundary.)
+      # `<bundle>/ruby/X.Y.Z/gems/<name>-<ver>/sig` → `<name>`. The gem directory follows the canonical
+      # `<name>-<version>` pattern; we strip everything from the last hyphen onwards to recover the name.
+      # (Platform-tagged variants like `ffi-1.17.4-aarch64-linux-gnu/` keep their platform suffix in the
+      # version part, so the first hyphen from the right is still the name boundary.)
       #
-      # Public so the O4 Layer 3 slice-3 coverage report
-      # (`RbsCoverageReport`) can classify discovered bundle sigs
-      # against locked gem names without re-running discovery.
+      # Public so the O4 Layer 3 slice-3 coverage report (`RbsCoverageReport`) can classify discovered bundle
+      # sigs against locked gem names without re-running discovery.
       def self.gem_name_from_sig_path(sig_dir)
         gem_dir = sig_dir.parent.basename.to_s
-        # Strip `-<version>` and any platform suffix. The version
-        # always starts with a digit, so split at the first
-        # `-` followed by a digit.
+        # Strip `-<version>` and any platform suffix. The version always starts with a digit, so split at
+        # the first `-` followed by a digit.
         gem_dir.sub(/-\d.*\z/, "")
       end
 
-      # Returns `Pathname` resolved bundle path, or `nil` when
-      # neither explicit nor auto-detected. Public for the stats
-      # banner so end users can see what rigor picked up.
+      # Returns `Pathname` resolved bundle path, or `nil` when neither explicit nor auto-detected. Public
+      # for the stats banner so end users can see what rigor picked up.
       def self.resolve_bundle_path(bundle_path:, project_root: Dir.pwd, auto_detect: true, home: nil)
         if bundle_path
           path = Pathname.new(File.expand_path(bundle_path.to_s, project_root))
@@ -158,38 +127,28 @@ module Rigor
         Pathname.new(detected) if detected
       end
 
-      # Auto-detection order — project-local strategies win over the
-      # user-global one, mirroring Bundler's own config precedence:
-      # 1. `<project_root>/.bundle/config` carries `BUNDLE_PATH:`
-      #    set by `bundle config set --local path <dir>`.
-      # 2. `<project_root>/vendor/bundle/` — the conventional
-      #    in-tree install location when a developer ran
+      # Auto-detection order — project-local strategies win over the user-global one, mirroring Bundler's own
+      # config precedence:
+      # 1. `<project_root>/.bundle/config` carries `BUNDLE_PATH:` set by `bundle config set --local path
+      #    <dir>`.
+      # 2. `<project_root>/vendor/bundle/` — the conventional in-tree install location when a developer ran
       #    `bundle install --path vendor/bundle`.
-      # 3. The user-global bundler config `<home>/.bundle/config`
-      #    `BUNDLE_PATH:` (`bundle config set --global path <dir>`),
-      #    resolved relative to the project root and used only when
-      #    it points at an existing directory — the last resort for
-      #    a project with no in-tree bundle. Purely additive: it is
-      #    consulted only when steps 1–2 found nothing, so it never
-      #    changes an already-working detection.
-      # 4. `nil` — let the caller proceed without bundle sig
-      #    discovery (rigor's vendored RBS still loads).
+      # 3. The user-global bundler config `<home>/.bundle/config` `BUNDLE_PATH:` (`bundle config set
+      #    --global path <dir>`), resolved relative to the project root and used only when it points at an
+      #    existing directory — the last resort for a project with no in-tree bundle. Purely additive: it is
+      #    consulted only when steps 1–2 found nothing, so it never changes an already-working detection.
+      # 4. `nil` — let the caller proceed without bundle sig discovery (rigor's vendored RBS still loads).
       #
-      # Note (ADR-27): rigor reads the *project* as data, so
-      # detection is limited to paths recorded in project-local or
-      # user-global Bundler config files. The pure-default install
-      # location — gems in the active Ruby's GEM_HOME with no `path`
-      # configured — is the *project's* Ruby's gem home, which the
-      # isolated analyzer cannot know without running the project's
-      # toolchain. Point rigor at it with `bundler.bundle_path:`, or
-      # supply signatures via `rbs collection install` /
-      # `dependencies.source_inference:`. `BUNDLE_PATH` from rigor's
-      # own environment is deliberately NOT consulted — it describes
-      # rigor's bundle, not the analyzed project's.
+      # Note (ADR-27): rigor reads the *project* as data, so detection is limited to paths recorded in
+      # project-local or user-global Bundler config files. The pure-default install location — gems in the
+      # active Ruby's GEM_HOME with no `path` configured — is the *project's* Ruby's gem home, which the
+      # isolated analyzer cannot know without running the project's toolchain. Point rigor at it with
+      # `bundler.bundle_path:`, or supply signatures via `rbs collection install` /
+      # `dependencies.source_inference:`. `BUNDLE_PATH` from rigor's own environment is deliberately NOT
+      # consulted — it describes rigor's bundle, not the analyzed project's.
       #
-      # `home:` defaults to the invoking user's home directory; it is
-      # a parameter so tests stay hermetic (no read of the real
-      # `~/.bundle/config`).
+      # `home:` defaults to the invoking user's home directory; it is a parameter so tests stay hermetic (no
+      # read of the real `~/.bundle/config`).
       def self.auto_detect(project_root:, home: nil)
         from_config = read_bundle_config_path(File.join(project_root, ".bundle", "config"))
         return File.expand_path(from_config, project_root) if from_config
@@ -200,10 +159,9 @@ module Rigor
         global_bundle_path(project_root: project_root, home: home)
       end
 
-      # Resolves the user-global `BUNDLE_PATH` against the project
-      # root, returning it only when it is an existing directory.
-      # Returns nil when there is no global config, no home, or the
-      # configured path does not exist.
+      # Resolves the user-global `BUNDLE_PATH` against the project root, returning it only when it is an
+      # existing directory. Returns nil when there is no global config, no home, or the configured path does
+      # not exist.
       def self.global_bundle_path(project_root:, home:)
         home ||= default_home
         return nil if home.nil?
@@ -226,17 +184,15 @@ module Rigor
       def self.read_bundle_config_path(config_path)
         return nil unless config_path && File.exist?(config_path)
 
-        # `.bundle/config` is YAML with all-caps env-style keys.
-        # `BUNDLE_PATH:` is the canonical key (Bundler 2.x); the
-        # `--path` flag sets it.
+        # `.bundle/config` is YAML with all-caps env-style keys. `BUNDLE_PATH:` is the canonical key
+        # (Bundler 2.x); the `--path` flag sets it.
         data = YAML.safe_load_file(config_path)
         return nil unless data.is_a?(Hash)
 
         path = data["BUNDLE_PATH"]
         path && !path.to_s.empty? ? path.to_s : nil
       rescue StandardError
-        # Malformed `.bundle/config` should not break analysis;
-        # silently skip auto-detection.
+        # Malformed `.bundle/config` should not break analysis; silently skip auto-detection.
         nil
       end
 

data/lib/rigor/environment/class_registry.rb

@@ -4,14 +4,13 @@ require_relative "../type"
 
 module Rigor
   class Environment
-    # Resolves Ruby Class/Module objects to Rigor::Type::Nominal instances.
-    # The hardcoded list spans the core classes the literal typer (Slice 1)
-    # and the constant-resolution path (Slice 2 strengthening) need.
-    # This is the static fast path for built-ins; `Environment` falls through
-    # to `RbsLoader` for all other names — the two tiers are complementary.
+    # Resolves Ruby Class/Module objects to Rigor::Type::Nominal instances. The hardcoded list spans the core
+    # classes the literal typer (Slice 1) and the constant-resolution path (Slice 2 strengthening) need.
+    # This is the static fast path for built-ins; `Environment` falls through to `RbsLoader` for all other
+    # names — the two tiers are complementary.
     #
-    # See docs/internal-spec/inference-engine.md for the binding contract
-    # (every entry below MUST always be recognised).
+    # See docs/internal-spec/inference-engine.md for the binding contract (every entry below MUST always be
+    # recognised).
     class ClassRegistry
       SLICE_1_BUILT_INS = [
         Integer,
@@ -25,11 +24,10 @@ module Rigor
         BasicObject
       ].freeze
 
-      # Common Ruby core classes that user code routinely names by constant
-      # reference. Adding them to the registry lets `nominal_for_name`
-      # resolve `Array`, `Hash`, etc. without each call site re-listing
-      # them. The static registry is the cheap fast path; `RbsLoader`
-      # extends coverage to all other RBS-declared names (Slice 4, landed).
+      # Common Ruby core classes that user code routinely names by constant reference. Adding them to the
+      # registry lets `nominal_for_name` resolve `Array`, `Hash`, etc. without each call site re-listing
+      # them. The static registry is the cheap fast path; `RbsLoader` extends coverage to all other
+      # RBS-declared names (Slice 4, landed).
       SLICE_2_BUILT_INS = [
         Array,
         Hash,
@@ -68,15 +66,11 @@ module Rigor
 
         private
 
-        # ADR-15 Phase 4b — the default registry MUST be
-        # `Ractor.shareable?` so worker Ractors that consult
-        # `Environment.for_project`'s default `class_registry:`
-        # don't trip `Ractor::IsolationError`. The internal
-        # `@nominals` / `@class_objects` Hashes are populated
-        # via `register`, then `Ractor.make_shareable`
-        # recursively freezes the registry, the two Hashes,
-        # and confirms every entry (Type::Nominal carriers +
-        # core Ruby classes) is itself shareable.
+        # ADR-15 Phase 4b — the default registry MUST be `Ractor.shareable?` so worker Ractors that consult
+        # `Environment.for_project`'s default `class_registry:` don't trip `Ractor::IsolationError`. The
+        # internal `@nominals` / `@class_objects` Hashes are populated via `register`, then
+        # `Ractor.make_shareable` recursively freezes the registry, the two Hashes, and confirms every entry
+        # (Type::Nominal carriers + core Ruby classes) is itself shareable.
         def build_default
           registry = new
           CORE_BUILT_INS.each { |klass| registry.register(klass) }
@@ -112,11 +106,10 @@ module Rigor
         @nominals.fetch(class_object.name)
       end
 
-      # Nil-safe lookup by class name. Accepts Symbol or String. Returns the
-      # registered Rigor::Type::Nominal, or nil when the name is unknown.
-      # Used by ExpressionTyper to resolve Prism::ConstantReadNode and
-      # Prism::ConstantPathNode under the fail-soft policy: unknown names
-      # MUST NOT raise and MUST flow through the engine's tracer.
+      # Nil-safe lookup by class name. Accepts Symbol or String. Returns the registered Rigor::Type::Nominal,
+      # or nil when the name is unknown. Used by ExpressionTyper to resolve Prism::ConstantReadNode and
+      # Prism::ConstantPathNode under the fail-soft policy: unknown names MUST NOT raise and MUST flow
+      # through the engine's tracer.
       def nominal_for_name(name)
         return nil if name.nil?
 

data/lib/rigor/environment/constant_type_cache_holder.rb

@@ -2,32 +2,25 @@
 
 module Rigor
   class Environment
-    # Per-key memoization container for {Environment#constant_for_name}.
-    # Held by {Environment} so the otherwise-frozen instance can cache
-    # constant-resolution results on first access — the sibling of
+    # Per-key memoization container for {Environment#constant_for_name}. Held by {Environment} so the
+    # otherwise-frozen instance can cache constant-resolution results on first access — the sibling of
     # {HktRegistryHolder}, generalised from one slot to a name-keyed map.
     #
-    # Why this exists: `constant_for_name` is a pure function of its
-    # name for a given Environment (both the predefined-constant
-    # refinement table and the RBS loader's constant table are fixed for
-    # the Environment's lifetime), yet it is the hottest non-dispatch
-    # path on a large Rails app. {ExpressionTyper#resolve_constant_name}
-    # peels a lexical-candidate ladder per constant reference, so the
-    # same qualified names recur thousands of times across files — and
-    # each miss runs a `const_get` walk that raises + rescues `NameError`
-    # for every project-defined constant (the common case). Caching the
+    # Why this exists: `constant_for_name` is a pure function of its name for a given Environment (both the
+    # predefined-constant refinement table and the RBS loader's constant table are fixed for the
+    # Environment's lifetime), yet it is the hottest non-dispatch path on a large Rails app.
+    # {ExpressionTyper#resolve_constant_name} peels a lexical-candidate ladder per constant reference, so the
+    # same qualified names recur thousands of times across files — and each miss runs a `const_get` walk
+    # that raises + rescues `NameError` for every project-defined constant (the common case). Caching the
     # result collapses the repeats to a hash lookup.
     #
-    # Caches `nil` results too (a name that resolves to no refined /
-    # RBS constant type stays unresolved for the run), so the
-    # const_get-and-rescue is paid at most once per distinct name.
+    # Caches `nil` results too (a name that resolves to no refined / RBS constant type stays unresolved for
+    # the run), so the const_get-and-rescue is paid at most once per distinct name.
     #
-    # Concurrency: single-threaded use only, the same discipline as
-    # {HktRegistryHolder} — the Ractor pool builds a per-worker
-    # Environment and the LSP single-publish invariant serialises the
-    # shared-Environment reader path. If a future caller introduces a
-    # multi-threaded reader against one Environment, the synchronisation
-    # belongs at that caller's seam, not here.
+    # Concurrency: single-threaded use only, the same discipline as {HktRegistryHolder} — the Ractor pool
+    # builds a per-worker Environment and the LSP single-publish invariant serialises the shared-Environment
+    # 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
       def initialize
         @cache = {}

data/lib/rigor/environment/hkt_registry_holder.rb

@@ -2,19 +2,13 @@
 
 module Rigor
   class Environment
-    # ADR-20 slice 2e — mutable single-slot memoization
-    # container for the per-Environment HKT registry. Held by
-    # {Environment} so the otherwise-frozen instance can
-    # still cache a computed value on first access.
+    # ADR-20 slice 2e — mutable single-slot memoization container for the per-Environment HKT registry. Held
+    # by {Environment} so the otherwise-frozen instance can still cache a computed value on first access.
     #
-    # Concurrent {#fetch} calls from multiple threads against
-    # one Environment are NOT serialised here — the LSP
-    # single-publish-at-a-time discipline and the Ractor
-    # pool's per-worker Environment shape already prevent
-    # cross-thread races. If a future caller introduces a
-    # multi-threaded reader path against a shared
-    # Environment, the synchronisation belongs at that
-    # caller's seam, not here.
+    # Concurrent {#fetch} calls from multiple threads against one Environment are NOT serialised here — the
+    # LSP single-publish-at-a-time discipline and the Ractor pool's per-worker Environment shape already
+    # prevent cross-thread races. If a future caller introduces a multi-threaded reader path against a
+    # shared Environment, the synchronisation belongs at that caller's seam, not here.
     class HktRegistryHolder
       def initialize
         @loaded = false

data/lib/rigor/environment/lockfile_resolver.rb

@@ -4,32 +4,25 @@ module Rigor
   class Environment
     # Gemfile.lock parser for target-project bundler awareness (O4 Layer 3, implemented).
     #
-    # Parses a target project's `Gemfile.lock` via Bundler's
-    # `LockfileParser` and exposes the locked gem set as a frozen
-    # `Hash[String, LockfileResolver::LockedGem]` keyed by gem
-    # name. Used by {Rigor::Environment::BundleSigDiscovery} as a
-    # filter so the discovered `sig/` directories under the
-    # bundler install root are limited to gems the project
-    # actually declares (and at the version it declared them).
+    # Parses a target project's `Gemfile.lock` via Bundler's `LockfileParser` and exposes the locked gem set
+    # as a frozen `Hash[String, LockfileResolver::LockedGem]` keyed by gem name. Used by
+    # {Rigor::Environment::BundleSigDiscovery} as a filter so the discovered `sig/` directories under the
+    # bundler install root are limited to gems the project actually declares (and at the version it declared
+    # them).
     #
-    # The resolver is intentionally read-only. It does NOT load
-    # the project's `Gemfile`, does NOT resolve dependencies,
-    # does NOT touch the network, and does NOT require the
-    # target project's Bundler context. It only reads bytes from
-    # the lockfile.
+    # The resolver is intentionally read-only. It does NOT load the project's `Gemfile`, does NOT resolve
+    # dependencies, does NOT touch the network, and does NOT require the target project's Bundler context. It
+    # only reads bytes from the lockfile.
     #
-    # Failure modes are deliberately quiet: a missing or
-    # malformed lockfile returns an empty map. The auto-detect
-    # path is the configuration default; users who want hard
-    # failures should pass an explicit `bundler.lockfile:` and
-    # check the result via the stats banner.
+    # Failure modes are deliberately quiet: a missing or malformed lockfile returns an empty map. The
+    # auto-detect path is the configuration default; users who want hard failures should pass an explicit
+    # `bundler.lockfile:` and check the result via the stats banner.
     module LockfileResolver
       # Frozen value object for one locked gem entry.
       #
-      # `version` is the resolved version string (e.g. "8.0.1");
-      # `platform` is the lockfile's platform tag, normalised to
-      # `"ruby"` when the lockfile records `ruby` and to the
-      # raw String otherwise (e.g. "aarch64-linux-gnu").
+      # `version` is the resolved version string (e.g. "8.0.1"); `platform` is the lockfile's platform tag,
+      # normalised to `"ruby"` when the lockfile records `ruby` and to the raw String otherwise (e.g.
+      # "aarch64-linux-gnu").
       LockedGem = Data.define(:name, :version, :platform) do
         def initialize(name:, version:, platform:)
           super(
@@ -40,18 +33,15 @@ module Rigor
         end
       end
 
-      # @param lockfile_path [String, Pathname, nil] explicit path
-      #   to the Gemfile.lock. When `nil`, falls back to
-      #   `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for a
-      #   relative `lockfile_path:` and the auto-detect search.
-      # @param auto_detect [Boolean] when true and
-      #   `lockfile_path:` is nil, look for
+      # @param lockfile_path [String, Pathname, nil] explicit path to the Gemfile.lock. When `nil`, falls
+      #   back to `auto_detect` if `auto_detect:` is true.
+      # @param project_root [String] resolution base for a relative `lockfile_path:` and the auto-detect
+      #   search.
+      # @param auto_detect [Boolean] when true and `lockfile_path:` is nil, look for
       #   `<project_root>/Gemfile.lock`.
-      # @return [Hash{String => LockedGem}] frozen map of gem
-      #   name → locked entry. Returns the empty frozen hash
-      #   when no lockfile is resolvable, when the file is
-      #   unreadable, or when Bundler refuses to parse it.
+      # @return [Hash{String => LockedGem}] frozen map of gem name → locked entry. Returns the empty frozen
+      #   hash when no lockfile is resolvable, when the file is unreadable, or when Bundler refuses to parse
+      #   it.
       def self.locked_gems(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
         resolved = resolve_lockfile_path(
           lockfile_path: lockfile_path,
@@ -63,9 +53,8 @@ module Rigor
         parse(resolved)
       end
 
-      # Returns the resolved lockfile path (`Pathname`) or `nil`
-      # when neither explicit nor auto-detect produces one.
-      # Public so the stats banner can show what rigor picked up.
+      # Returns the resolved lockfile path (`Pathname`) or `nil` when neither explicit nor auto-detect
+      # produces one. Public so the stats banner can show what rigor picked up.
       def self.resolve_lockfile_path(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
         if lockfile_path
           path = Pathname.new(File.expand_path(lockfile_path.to_s, project_root))
@@ -83,12 +72,9 @@ module Rigor
       EMPTY = {}.freeze
       private_constant :EMPTY
 
-      # Parses a Gemfile.lock at the given path. Bundler load
-      # errors and malformed lockfile bytes both surface as the
-      # empty frozen hash; analysis must not crash because a
-      # lockfile is malformed. A single warning is emitted to
-      # `$stderr` so the user can see why their lockfile was
-      # ignored.
+      # Parses a Gemfile.lock at the given path. Bundler load errors and malformed lockfile bytes both
+      # surface as the empty frozen hash; analysis must not crash because a lockfile is malformed. A single
+      # warning is emitted to `$stderr` so the user can see why their lockfile was ignored.
       def self.parse(path)
         require "bundler"
       rescue LoadError => e
@@ -103,12 +89,10 @@ module Rigor
         body = File.read(path.to_s)
         parser = Bundler::LockfileParser.new(body)
         locked = parser.specs.each_with_object({}) do |spec, h|
-          # `Bundler::LazySpecification` carries name, version,
-          # platform. Platform is `Gem::Platform` or the symbol
-          # `:ruby`; both stringify cleanly. The upstream
-          # bundler RBS shim (references/rbs/sig/shims/bundler.rbs)
-          # does NOT declare `LazySpecification#platform` so the
-          # call site needs a suppression marker.
+          # `Bundler::LazySpecification` carries name, version, platform. Platform is `Gem::Platform` or the
+          # symbol `:ruby`; both stringify cleanly. The upstream bundler RBS shim
+          # (references/rbs/sig/shims/bundler.rbs) does NOT declare `LazySpecification#platform` so the call
+          # site needs a suppression marker.
           platform = spec.platform.to_s # rigor:disable undefined-method
           h[spec.name.to_s] = LockedGem.new(
             name: spec.name, version: spec.version.to_s, platform: platform