rigortype 0.1.8 → 0.1.9

data/lib/rigor/analysis/check_rules.rb

@@ -355,6 +355,15 @@ module Rigor
           class_name = concrete_class_name(receiver_type)
           return nil if class_name.nil?
 
+          # ADR-26 — a plugin may declare a class "open": one
+          # known to respond beyond its RBS-declared method
+          # surface (e.g. `ActiveRecord::Relation`, which
+          # delegates an unbounded set of user-defined scopes to
+          # its model). Flagging an undefined method on a class
+          # with an open dynamic surface is unsound, so the rule
+          # skips it.
+          return nil if open_receiver?(class_name, scope)
+
           # Slice 7 phase 12 — suppress when the user has
           # declared the method in source (instance `def`,
           # `def self.foo`, or recognised `define_method`).
@@ -424,6 +433,17 @@ module Rigor
           nil
         end
 
+        # ADR-26 — whether `class_name` is declared "open" by a
+        # loaded plugin (manifest `open_receivers:`). An open
+        # class responds beyond its RBS surface, so the
+        # `call.undefined-method` rule must not fire for it.
+        def open_receiver?(class_name, scope)
+          registry = scope.environment&.plugin_registry
+          return false if registry.nil?
+
+          registry.open_receiver?(class_name)
+        end
+
         def definition_available?(receiver_type, class_name, scope)
           if receiver_type.is_a?(Type::Singleton)
             !Rigor::Reflection.singleton_definition(class_name, scope: scope).nil?

data/lib/rigor/cli/annotate_command.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "optionparser"
+require "prism"
+
+require_relative "../configuration"
+require_relative "../environment"
+require_relative "../scope"
+require_relative "../inference/scope_indexer"
+require_relative "prism_colorizer"
+
+module Rigor
+  class CLI
+    # Executes `rigor annotate FILE`.
+    #
+    # For every source line the command finds the expression the
+    # line evaluates to — the last statement that ends on the line
+    # (so `1; 2; 3` reports `3`), or, for a line that no statement
+    # closes, the widest expression ending there (so the `if nil`
+    # header reports its condition). It infers that expression's
+    # type and appends a `#=> dump_type: <type>` comment.
+    #
+    # The annotated source is re-parsed with Prism — a sanity gate,
+    # since the appended text is always a comment — and printed to
+    # stdout with IRB-style syntax highlighting via
+    # {PrismColorizer}.
+    class AnnotateCommand
+      USAGE = "Usage: rigor annotate [options] FILE"
+
+      # Appended ` #=> dump_type: <type>` suffix. Matched and
+      # stripped before re-annotating so re-running is idempotent.
+      ANNOTATION_PATTERN = /\s*#=>\s*dump_type:.*\z/
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        file = @argv.shift
+        if file.nil?
+          @err.puts(USAGE)
+          return CLI::EXIT_USAGE
+        end
+        unless File.file?(file)
+          @err.puts("annotate: file not found: #{file}")
+          return 1
+        end
+
+        execute(file, options)
+      end
+
+      private
+
+      def parse_options
+        # Default: colour a tty, unless `NO_COLOR` opts out. An
+        # explicit `--color` / `--no-color` overrides both.
+        options = { config: nil, color: @out.tty? && !no_color_env? }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          opts.on("--[no-]color",
+                  "Force or disable ANSI colour (default: auto-detect a tty; honours NO_COLOR)") do |value|
+            options[:color] = value
+          end
+        end
+        parser.parse!(@argv)
+
+        options
+      end
+
+      # https://no-color.org — colour output is suppressed by
+      # default when `NO_COLOR` is present and not an empty string,
+      # regardless of its value.
+      def no_color_env?
+        value = ENV.fetch("NO_COLOR", nil)
+        !value.nil? && !value.empty?
+      end
+
+      def execute(file, options)
+        configuration = Configuration.load(options.fetch(:config))
+        source = File.read(file)
+        parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
+        return 1 if parse_errors?(parse_result, file)
+
+        scope_index = Inference::ScopeIndexer.index(
+          parse_result.value, default_scope: base_scope(configuration)
+        )
+        line_types = LineTypeCollector.new(scope_index).collect(parse_result.value)
+
+        @out.puts(render(annotate(source, line_types), color: options.fetch(:color)))
+        0
+      end
+
+      def base_scope(configuration)
+        Scope.empty(
+          environment: Environment.for_project(
+            libraries: configuration.libraries,
+            signature_paths: configuration.signature_paths
+          )
+        )
+      end
+
+      def parse_errors?(parse_result, file)
+        return false if parse_result.success?
+
+        parse_result.errors.each do |error|
+          @err.puts("#{file}:#{error.location.start_line}: #{error.message}")
+        end
+        true
+      end
+
+      # Appends ` #=> dump_type: <type>` to every line a type was
+      # inferred for, aligning the comment column.
+      def annotate(source, line_types)
+        lines = source.lines
+        column = annotation_column(lines, line_types)
+
+        lines.each_with_index.map do |line, index|
+          type = line_types[index + 1]
+          eol = line.end_with?("\n") ? "\n" : ""
+          code = line.chomp.sub(ANNOTATION_PATTERN, "")
+          next "#{code}#{eol}" if type.nil?
+
+          "#{code.ljust(column)}  #=> dump_type: #{type.describe(:short)}#{eol}"
+        end.join
+      end
+
+      def annotation_column(lines, line_types)
+        widths = lines.each_index.filter_map do |index|
+          next unless line_types.key?(index + 1)
+
+          lines[index].chomp.sub(ANNOTATION_PATTERN, "").length
+        end
+        widths.max || 0
+      end
+
+      def render(annotated, color:)
+        return annotated unless color
+        return annotated unless Prism.parse(annotated).success?
+
+        PrismColorizer.colorize(annotated)
+      end
+    end
+
+    # Walks a parsed program and resolves, per source line, the
+    # type of the expression the line evaluates to. Used only by
+    # {AnnotateCommand}.
+    class LineTypeCollector
+      def initialize(scope_index)
+        @scope_index = scope_index
+      end
+
+      # @param program [Prism::ProgramNode]
+      # @return [Hash{Integer => Rigor::Type}] 1-indexed line => type.
+      def collect(program)
+        by_line = {}
+        each_statement(program) do |statement|
+          type = type_of(statement)
+          by_line[statement.location.end_line] = type unless type.nil?
+        end
+        fill_uncovered_lines(program, by_line)
+        by_line
+      end
+
+      private
+
+      # Yields each statement node (a child of any `StatementsNode`
+      # anywhere in the tree) in source order, so a later statement
+      # ending on a line overwrites an earlier one — `1; 2; 3`
+      # resolves to `3`.
+      def each_statement(node, &)
+        return if node.nil?
+
+        node.body.each(&) if node.is_a?(Prism::StatementsNode)
+        node.compact_child_nodes.each { |child| each_statement(child, &) }
+      end
+
+      # For a line no statement closes (the `if` / block header
+      # lines), fall back to the widest expression ending there.
+      def fill_uncovered_lines(program, by_line)
+        widest_per_line(program).each do |line, node|
+          next if by_line.key?(line)
+
+          type = type_of(node)
+          by_line[line] = type unless type.nil?
+        end
+      end
+
+      def widest_per_line(program)
+        widest = {}
+        walk(program) do |node|
+          next if node.is_a?(Prism::ProgramNode) || node.is_a?(Prism::StatementsNode)
+
+          line = node.location.end_line
+          current = widest[line]
+          widest[line] = node if current.nil? || span(node) > span(current)
+        end
+        widest
+      end
+
+      def span(node)
+        node.location.end_offset - node.location.start_offset
+      end
+
+      def walk(node, &block)
+        return if node.nil?
+
+        block.call(node)
+        node.compact_child_nodes.each { |child| walk(child, &block) }
+      end
+
+      def type_of(node)
+        @scope_index[node].type_of(node)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/cli/baseline_command.rb

@@ -9,22 +9,22 @@ require_relative "../configuration"
 
 module Rigor
   class CLI
-    # ADR-22 Slice 1 — `rigor baseline {generate}` subcommands.
-    # Backed by `Rigor::Analysis::Baseline`. Future slices
-    # extend the subcommand surface with `dump`, `drift`,
-    # `prune`, `regenerate`.
-    #
-    # Initial subcommand: `generate`.
+    # ADR-22 — `rigor baseline {generate,regenerate,dump,drift,
+    # prune}` subcommands, backed by `Rigor::Analysis::Baseline`.
     #
     #   rigor baseline generate              # default: rule-ID rows
     #   rigor baseline generate --match-mode message
     #   rigor baseline generate --force      # overwrite existing
     #   rigor baseline generate --output=PATH
+    #   rigor baseline regenerate            # slice 5: unconditional rewrite
+    #   rigor baseline dump
+    #   rigor baseline drift
+    #   rigor baseline prune
     class BaselineCommand # rubocop:disable Metrics/ClassLength
       EXIT_USAGE = 64
       DEFAULT_BASELINE_PATH = ".rigor-baseline.yml"
 
-      SUBCOMMANDS = %w[generate dump drift prune].freeze
+      SUBCOMMANDS = %w[generate regenerate dump drift prune].freeze
 
       def initialize(argv:, out: $stdout, err: $stderr)
         @argv = argv
@@ -39,6 +39,7 @@ module Rigor
           @out.puts(help)
           0
         when "generate" then run_generate
+        when "regenerate" then run_regenerate
         when "dump" then run_dump
         when "drift" then run_drift
         when "prune" then run_prune
@@ -59,21 +60,36 @@ module Rigor
         path = options.fetch(:output)
 
         if File.exist?(path) && !options.fetch(:force)
-          @err.puts("rigor: #{path} already exists. Re-run with --force to overwrite.")
+          @err.puts("rigor: #{path} already exists. Re-run with --force to " \
+                    "overwrite, or use `rigor baseline regenerate`.")
           return EXIT_USAGE
         end
 
+        write_baseline(options, verb: "wrote baseline to")
+      end
+
+      # ADR-22 slice 5 — `regenerate` is `generate --force`: the
+      # end-of-quality-improvement-session refresh after landing
+      # baseline-reducing fixes. It rewrites the file
+      # unconditionally (no existence guard, no `--force` flag),
+      # so `rigor baseline regenerate` reads cleanly as "make the
+      # baseline match reality again".
+      def run_regenerate
+        options = parse_generate_options(subcommand: "regenerate")
+        write_baseline(options, verb: "regenerated baseline")
+      end
+
+      def write_baseline(options, verb:)
+        path = options.fetch(:output)
         configuration = Configuration.load(options.fetch(:config))
         diagnostics = collect_diagnostics(configuration, options)
 
         baseline = Analysis::Baseline.from_diagnostics(diagnostics, match_mode: options.fetch(:match_mode))
         File.write(path, baseline.to_yaml)
 
-        bucket_count = baseline.size
-        diagnostic_count = diagnostics.size
         @err.puts(
-          "rigor: wrote baseline to #{path} " \
-          "(#{bucket_count} bucket(s) covering #{diagnostic_count} diagnostic(s); " \
+          "rigor: #{verb} #{path} " \
+          "(#{baseline.size} bucket(s) covering #{diagnostics.size} diagnostic(s); " \
           "match-mode: #{options.fetch(:match_mode)})"
         )
         if configuration.baseline_path.nil?
@@ -85,7 +101,7 @@ module Rigor
         0
       end
 
-      def parse_generate_options
+      def parse_generate_options(subcommand: "generate")
         options = {
           config: nil,
           output: DEFAULT_BASELINE_PATH,
@@ -93,7 +109,7 @@ module Rigor
           force: false
         }
         parser = OptionParser.new do |opts|
-          opts.banner = "Usage: rigor baseline generate [options]"
+          opts.banner = "Usage: rigor baseline #{subcommand} [options]"
           opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
           opts.on("--output=PATH", "Write baseline to PATH (default: #{DEFAULT_BASELINE_PATH})") do |v|
             options[:output] = v
@@ -102,7 +118,10 @@ module Rigor
                   "Row form: rule (default) or message") do |v|
             options[:match_mode] = v
           end
-          opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+          # `regenerate` always overwrites — no `--force` to offer.
+          if subcommand == "generate"
+            opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+          end
         end
         parser.parse!(@argv)
         options
@@ -290,7 +309,7 @@ module Rigor
         case status
         when :over then "## Over threshold (#{count}) — bucket exceeded; check the regular diagnostic output."
         when :cleared then "## Cleared (#{count}) — `rigor baseline prune` can drop these."
-        when :reducible then "## Reducible (#{count}) — tightening opportunity; consider `regenerate` (slice 5)."
+        when :reducible then "## Reducible (#{count}) — tightening opportunity; run `rigor baseline regenerate`."
         when :within then "## Within threshold (#{count})"
         end
       end
@@ -365,6 +384,7 @@ module Rigor
 
           Subcommands:
             generate    Write a fresh baseline file from a `rigor check` run.
+            regenerate  Rewrite the baseline unconditionally (post-fix refresh).
             dump        Print the contents of an existing baseline.
             drift       Compare baseline vs current diagnostics (reduction / regression hints).
             prune       Drop cleared buckets (`actual == 0`) from the baseline.

data/lib/rigor/cli/prism_colorizer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  class CLI
+    # Re-lexes Ruby source with Prism and wraps each token in an
+    # ANSI colour escape, producing IRB-style syntax highlighting.
+    #
+    # Rigor ships no runtime dependencies (ADR-0), so the `irb`
+    # gem's `IRB::Color` is not available; this module reproduces
+    # the same effect from Prism's own token stream. `rigor
+    # annotate` re-parses its annotated output through here before
+    # printing.
+    module PrismColorizer
+      module_function
+
+      RESET = "\e[0m"
+
+      # token category => ANSI SGR parameters.
+      CATEGORY_SGR = {
+        comment: "90",      # bright black (faint grey)
+        keyword: "33",      # yellow
+        literal_kw: "36",   # cyan   — nil / true / false / self
+        number: "34",       # blue
+        string: "32",       # green
+        symbol: "36",       # cyan
+        constant: "1;34",   # bold blue
+        variable: "34",     # blue   — @ivar / @@cvar / $gvar
+        default: nil
+      }.freeze
+
+      LITERAL_KEYWORDS = %i[
+        KEYWORD_NIL KEYWORD_TRUE KEYWORD_FALSE KEYWORD_SELF
+        KEYWORD___FILE__ KEYWORD___LINE__ KEYWORD___ENCODING__
+      ].freeze
+
+      VARIABLE_TOKENS = %i[INSTANCE_VARIABLE CLASS_VARIABLE GLOBAL_VARIABLE].freeze
+
+      # @param source [String] Ruby source.
+      # @return [String] the source with ANSI colour escapes, or
+      #   the input unchanged when lexing surfaces an error.
+      def colorize(source)
+        result = Prism.lex(source)
+        return source unless result.errors.empty?
+
+        render(source, result.value)
+      end
+
+      def render(source, lexed)
+        out = +""
+        offset = 0
+        previous_type = nil
+        lexed.each do |entry|
+          token = entry.first
+          location = token.location
+          out << source[offset...location.start_offset]
+          break if token.type == :EOF
+
+          text = source[location.start_offset...location.end_offset]
+          out << paint(text, effective_category(token.type, previous_type))
+          offset = location.end_offset
+          previous_type = token.type
+        end
+        out << (source[offset..] || "")
+        out
+      end
+
+      # The token after a `SYMBOL_BEGIN` (`:`) carries the symbol
+      # name — and Prism lexes `:then` / `:class` etc. as a
+      # keyword token — so it is painted with the symbol colour
+      # regardless of its own token type.
+      def effective_category(token_type, previous_type)
+        return :symbol if previous_type == :SYMBOL_BEGIN
+
+        category(token_type)
+      end
+
+      def paint(text, category)
+        sgr = CATEGORY_SGR.fetch(category)
+        return text if sgr.nil? || text.empty?
+
+        # Keep a trailing newline outside the colour span so the
+        # reset sits on the token's own line (comments include it).
+        trailing = text[/\s*\z/] || ""
+        body = trailing.empty? ? text : text[0...-trailing.length]
+        return text if body.empty?
+
+        "\e[#{sgr}m#{body}#{RESET}#{trailing}"
+      end
+
+      def category(token_type)
+        name = token_type.to_s
+        return :comment if token_type == :COMMENT
+        return :literal_kw if LITERAL_KEYWORDS.include?(token_type)
+        return :keyword if name.start_with?("KEYWORD_")
+        return :number if number_token?(name)
+        return :string if name.start_with?("STRING_", "HEREDOC_") || token_type == :STRING_CONTENT
+        return :symbol if name.start_with?("SYMBOL_")
+        return :constant if token_type == :CONSTANT
+        return :variable if VARIABLE_TOKENS.include?(token_type)
+
+        :default
+      end
+
+      def number_token?(name)
+        name.start_with?("INTEGER", "FLOAT", "RATIONAL", "IMAGINARY")
+      end
+    end
+  end
+end

data/lib/rigor/cli.rb

@@ -21,6 +21,7 @@ module Rigor
     HANDLERS = {
       "check" => :run_check,
       "init" => :run_init,
+      "annotate" => :run_annotate,
       "type-of" => :run_type_of,
       "type-scan" => :run_type_scan,
       "explain" => :run_explain,
@@ -88,13 +89,56 @@ module Rigor
         configuration: configuration, options: options,
         buffer: buffer, cache_root: cache_root
       )
-      result = runner.run(@argv.empty? ? configuration.paths : @argv)
-      result = apply_baseline_filter(result, configuration, options)
+      raw_result = runner.run(@argv.empty? ? configuration.paths : @argv)
+      result = apply_baseline_filter(raw_result, configuration, options)
 
       write_result(result, options.fetch(:format))
       write_run_stats(result.stats) if result.stats
       write_cache_stats(cache_root, runner.cache_store) if options.fetch(:cache_stats)
-      result.success? ? 0 : 1
+
+      exit_code = result.success? ? 0 : 1
+      exit_code = 1 if baseline_strict_violation?(raw_result.diagnostics, configuration, options)
+      exit_code
+    end
+
+    # ADR-22 slice 5 — the `--baseline-strict` CI gate. When the
+    # flag is set, ANY baseline drift fails the run — not only
+    # excess drift (a bucket over threshold, which already fails
+    # via the surfaced diagnostics) but also DEFICIT drift
+    # (`actual < count`: the baseline has grown looser than the
+    # code and should be regenerated). A no-op, with a stderr
+    # note, when no baseline is active — the flag never
+    # implicitly loads a baseline the config did not name (WD2).
+    def baseline_strict_violation?(raw_diagnostics, configuration, options)
+      return false unless options.fetch(:baseline_strict)
+
+      path = resolve_baseline_path(configuration, options)
+      if path.nil?
+        @err.puts("rigor: --baseline-strict given but no baseline is active; nothing to gate.")
+        return false
+      end
+
+      baseline = Analysis::Baseline.load(path)
+      return false if baseline.nil? || baseline.empty?
+
+      drifted = baseline.audit(raw_diagnostics).reject { |row| row.status == :within }
+      return false if drifted.empty?
+
+      report_strict_drift(drifted, path)
+      true
+    rescue Analysis::Baseline::LoadError => e
+      @err.puts("rigor: baseline load failed: #{e.message} (--baseline-strict gate skipped)")
+      false
+    end
+
+    def report_strict_drift(rows, path)
+      @err.puts("rigor: --baseline-strict — #{rows.size} bucket(s) drifted from #{path}:")
+      rows.sort_by { |r| [r.bucket.file, r.bucket.rule] }.each do |row|
+        delta = row.delta.positive? ? "+#{row.delta}" : row.delta.to_s
+        @err.puts("  #{row.bucket.file}  [#{row.bucket.rule}]  " \
+                  "#{row.bucket.count} → #{row.actual_count}  (Δ#{delta}, #{row.status})")
+      end
+      @err.puts("rigor: run `rigor baseline regenerate` to refresh the baseline.")
     end
 
     # ADR-22 — apply the baseline filter as the LAST step of
@@ -234,7 +278,10 @@ module Rigor
         # to `.rigor.yml`'s `baseline:` key"; a String overrides
         # the config; `false` (from `--no-baseline`) suppresses
         # any baseline that the config might name.
-        baseline: :unset
+        baseline: :unset,
+        # ADR-22 slice 5 — `--baseline-strict` CI gate: fail the
+        # run on any baseline drift, in either direction.
+        baseline_strict: false
       }
       parser = OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
         opts.banner = "Usage: rigor check [options] [paths]"
@@ -268,6 +315,10 @@ module Rigor
                 "ADR-22: ignore any configured baseline for this run") do
           options[:baseline] = false
         end
+        opts.on("--baseline-strict",
+                "ADR-22: fail the run on any baseline drift (CI gate)") do
+          options[:baseline_strict] = true
+        end
       end
       parser.parse!(@argv)
       options
@@ -423,6 +474,12 @@ module Rigor
       YAML
     end
 
+    def run_annotate
+      require_relative "cli/annotate_command"
+
+      AnnotateCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_type_of
       require_relative "cli/type_of_command"
 
@@ -506,6 +563,7 @@ module Rigor
         Commands:
           check      Analyze Ruby source files
           init       Create a starter .rigor.yml
+          annotate   Print FILE with each line's last-expression type
           type-of    Print the inferred type at FILE:LINE:COL
           type-scan  Report Scope#type_of coverage across PATHs
           explain    Print the description of one or all CheckRules

data/lib/rigor/environment.rb

@@ -252,7 +252,15 @@ module Rigor
           project_root: root,
           auto_detect: rbs_collection_auto_detect
         ).map(&:to_s)
-        loader_signature_paths = resolved_paths + gem_sig_paths + collection_paths
+        # ADR-25 — RBS signature directories contributed by loaded
+        # plugins via their manifest `signature_paths:`. Resolved
+        # to absolute dirs by `Plugin::Base#signature_paths`;
+        # additive, ranked below the user's explicit
+        # `signature_paths:` and above the opportunistic bundle /
+        # collection discovery. A duplicate-declaration conflict
+        # degrades through the same O7 failure-memo path.
+        plugin_sig_paths = plugin_registry ? plugin_registry.signature_paths.map(&:to_s) : []
+        loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths + collection_paths
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         loader = RbsLoader.new(
           libraries: merged_libraries,

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -57,7 +57,8 @@ module Rigor
           return nil unless klass
 
           bucket_key = kind == :singleton ? "singleton_methods" : "instance_methods"
-          klass.dig(bucket_key, selector.to_s)
+          klass.dig(bucket_key, selector.to_s) ||
+            resolve_alias_entry(klass, selector, bucket_key)
         end
 
         def reset!
@@ -66,6 +67,21 @@ module Rigor
 
         private
 
+        def resolve_alias_entry(klass, selector, bucket_key)
+          return nil unless bucket_key == "instance_methods"
+
+          aliases = klass["aliases"]
+          return nil unless aliases
+
+          alias_entry = aliases[selector.to_s]
+          return nil unless alias_entry
+
+          target = alias_entry["old"]
+          return nil unless target
+
+          klass.dig(bucket_key, target)
+        end
+
         def blocked?(class_name, selector)
           # Bang-suffixed selectors are mutating by Ruby convention
           # (`upcase!`, `concat`, etc. are listed explicitly below;

data/lib/rigor/inference/builtins/time_catalog.rb

@@ -55,7 +55,16 @@ module Rigor
             # as `time_localtime`: `time_modify(time)` then a
             # `time_set_vtm` write and `TZMODE_SET_UTC`. Both
             # selectors share the cfunc, so both must be blocked.
-            :gmtime, :utc
+            :gmtime, :utc,
+            # `getlocal` is not a mutator — it returns a fresh Time —
+            # but the fresh Time is pinned to the *analysis machine's*
+            # timezone. Folding it through a `Constant[Time]` carrier
+            # (which only ever holds a UTC literal from `Time.utc`)
+            # would bake a host-dependent wall clock / `utc_offset`
+            # into the inferred type. Blocked so the fold stays
+            # machine-independent; the RBS tier answers `Nominal[Time]`.
+            # `getutc` / `getgm` stay foldable — their result is UTC.
+            :getlocal
           ]
         }
       )