llm-evals 0.4.0

data/lib/llm/evals/render/reports/pipeline.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tempfile"
+require "uri"
+
+module LLM
+  module Evals
+    module Render
+      module Reports
+        # Writes the canonical JSON snapshot and passes that snapshot to the
+        # selected display. Temporary snapshots are removed after presentation.
+        class Pipeline
+          Result = Data.define(:json_path, :html_path, :css_path, :js_path, :browser_opened)
+
+          # @param providers [Providers::Registry]
+          # @param runtime [Runtime]
+          # @param destination [String]
+          # @param temp_dir [String]
+          # @param project [String]
+          def initialize(providers:, runtime:, destination:, temp_dir:, project:)
+            @providers = providers
+            @runtime = runtime
+            @destination = destination
+            @temp_dir = temp_dir
+            @project = project.to_s.downcase.gsub(/[^a-z0-9]+/, "-").delete_prefix("-").delete_suffix("-")
+          end
+
+          # @param summaries [Array<Experiment::Summary>]
+          # @param metrics [Array<Metric>]
+          # @param weighted_score [WeightedScore, nil]
+          # @param run_options [Hash]
+          # @param autosave [Boolean]
+          # @param display [String]
+          # @param open [Boolean]
+          # @yield [report] display the decoded JSON in the terminal
+          # @return [Result]
+          def call(summaries:, metrics:, weighted_score:, run_options:, autosave:, display:, open:)
+            return Result.new(nil, nil, nil, nil, nil) unless autosave || display != "none"
+
+            stamp = timestamp
+            json_path = autosave ? artifact_path(@destination, stamp, "json") : temporary_json_path
+            write_json(summaries:, metrics:, weighted_score:, run_options:, path: json_path)
+            return Result.new(json_path:, html_path: nil, css_path: nil, js_path: nil, browser_opened: nil) if display == "none"
+
+            report = JSON.decode(File.read(json_path), providers: @providers)
+            assets = case display
+                     when "tui"
+                       yield report if block_given?
+                       [nil, nil, nil, nil]
+                     when "browser"
+                       render_browser(report, open:)
+                     else
+                       [nil, nil, nil, nil]
+                     end
+            html_path, css_path, js_path, browser_opened = assets
+            Result.new(json_path: autosave ? json_path : nil, html_path:, css_path:, js_path:, browser_opened:)
+          ensure
+            FileUtils.rm_f(json_path) if defined?(json_path) && json_path && !autosave
+          end
+
+          # @param summaries [Array<Experiment::Summary>]
+          # @param metrics [Array<Metric>]
+          # @param weighted_score [WeightedScore, nil]
+          # @param run_options [Hash]
+          # @param path [String, nil] nil returns JSON text to the caller
+          # @return [String, nil] JSON text when no path was supplied
+          def write_json(summaries:, metrics:, weighted_score:, run_options:, path:)
+            document = JSON.dump(summaries, metrics:, weighted_score:, run_options:)
+            if path
+              FileUtils.mkdir_p(File.dirname(path))
+              File.write(path, document)
+              nil
+            else
+              document
+            end
+          end
+
+          # @param json [String] serialized run results
+          # @param path [String, nil] nil returns HTML text to the caller
+          # @return [String, nil] HTML text when no path was supplied
+          def write_html(json:, path:)
+            report = JSON.decode(json, providers: @providers)
+            document = HTML.render(report)
+            if path
+              FileUtils.mkdir_p(File.dirname(path))
+              File.write(path, document)
+              nil
+            else
+              document
+            end
+          end
+
+          # Writes an explicitly requested JSON report under the configured
+          # destination, using the same timestamped name as an autosaved result.
+          #
+          # @param summaries [Array<Experiment::Summary>]
+          # @param metrics [Array<Metric>]
+          # @param weighted_score [WeightedScore, nil]
+          # @param run_options [Hash]
+          # @return [String] the saved JSON path
+          def save_json(summaries:, metrics:, weighted_score:, run_options:)
+            path = artifact_path(@destination, timestamp, "json")
+            write_json(summaries:, metrics:, weighted_score:, run_options:, path:)
+            path
+          end
+
+          # The name of a project's report, the same on every run, so the newest
+          # replaces the last. The JSON beside it keeps the timestamp, and
+          # `render` can rebuild any older report from it.
+          #
+          # @param directory [String]
+          # @param extension [String] html, or the css and js that go with it
+          # @return [String]
+          def report_path(directory, extension = "html")
+            File.join(directory, "#{@project}-llm-evals.report.#{extension}")
+          end
+
+          private
+
+          def render_browser(report, open:)
+            FileUtils.mkdir_p(@destination)
+            html_path = report_path(@destination, "html")
+            css_path = report_path(@destination, "css")
+            js_path = report_path(@destination, "js")
+            File.write(css_path, File.read(File.join(HTML::TEMPLATE_DIRECTORY, "html_report.css")))
+            File.write(js_path, File.read(File.join(HTML::TEMPLATE_DIRECTORY, "html_report.js")))
+            html = HTML.render(report,
+              stylesheet_path: File.basename(css_path),
+              script_path:     File.basename(js_path))
+            File.write(html_path, html)
+            browser_opened = @runtime.browse(URI::DEFAULT_PARSER.escape("file://#{html_path}")) if open
+            [html_path, css_path, js_path, browser_opened]
+          end
+
+          def artifact_path(directory, stamp, extension)
+            File.join(directory, "#{@project}.results.#{stamp}.#{extension}")
+          end
+
+          def timestamp = Time.now.strftime("%Y-%m-%d.%H%M%S%6N")
+
+          def temporary_json_path
+            FileUtils.mkdir_p(@temp_dir)
+            file = Tempfile.create(["#{@project}.results.", ".json"], @temp_dir)
+            path = file.path
+            file.close
+            path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm/evals/render/reports/terminal.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module LLM
+  module Evals
+    module Render
+      module Reports
+        # Presents a decoded report in the terminal and optionally writes the
+        # detailed view to a report file.
+        class Terminal
+          # @param invocation [Dry::CLI::UI::Invocation]
+          # @param writing_to [#call] redirects the command's table helpers
+          # @param leaderboard [#call] draws the summary leaderboard
+          def initialize(invocation:, writing_to:, leaderboard:)
+            @invocation = invocation
+            @writing_to = writing_to
+            @leaderboard = leaderboard
+          end
+
+          # @param summaries [Array<Experiment::Summary>]
+          # @param output [String, nil]
+          # @param scores [Boolean]
+          # @param totals_mode [String] overall, variant or both
+          # @yield [summaries] draw the per-case detail
+          # @return [String, nil] report file path
+          def call(summaries:, output:, scores:, totals_mode:, &details)
+            path = @invocation.report_path(output)
+            if path
+              File.open(path, "w") do |file|
+                report = Dry::CLI::UI::Report.new(file)
+                @writing_to.call(report) do
+                  details&.call(summaries)
+                  @leaderboard.call(summaries, scores:, totals_mode:)
+                end
+                report.puts "Closed at #{Time.now.strftime("%Y-%m-%d %H:%M:%S %z")}"
+              end
+            else
+              details&.call(summaries)
+            end
+            @leaderboard.call(summaries, scores:, totals_mode:)
+            path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm/evals/reply.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module LLM
+  module Evals
+    # What an {Adapter} returns for one case. `error` is the model's failure
+    # (it did not answer the question: no JSON, a refusal) and scores 0; a
+    # transport failure is not the model's and is raised instead, so it is
+    # counted as an error of the run rather than a wrong answer.
+    Reply = Data.define(:output, :raw, :usage, :error, :metadata) do
+      def initialize(output: nil, raw: nil, usage: Usage.zero, error: nil, metadata: {})
+        super(output: output, raw: raw, usage: Usage.from(usage), error: error, metadata: metadata)
+      end
+
+      # @return [Boolean] whether the model failed to answer
+      def error? = !error.nil?
+    end
+  end
+end

data/lib/llm/evals/run_result.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module LLM
+  module Evals
+    # One case, run once: what came back and what it scored. `reply` is nil
+    # when the adapter raised, and `error` then holds the message.
+    RunResult = Data.define(:experiment, :case, :reply, :score, :duration, :error) do
+      def initialize(experiment:, case:, reply: nil, score: nil, duration: 0.0, error: nil) = super
+
+      # @return [Boolean] whether the adapter raised rather than answered
+      def failed? = !error.nil?
+    end
+  end
+end

data/lib/llm/evals/runtime.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "dotenv"
+
+module LLM
+  module Evals
+    # One-time process setup: secrets from the suite's env files, a check that
+    # every key and gem the run needs is there, the suite's own hooks, and
+    # the providers' clients.
+    class Runtime
+      attr_reader :env_files, :hooks, :app_name
+
+      # @param env_files [Array<String>] absolute paths; those that exist load
+      # @param hooks [Array<Proc>] the suite's `before_run` blocks
+      # @param app_name [String] what a provider tells its API the caller is
+      def initialize(env_files: [], hooks: [], app_name: "llm-evals")
+        @env_files = env_files
+        @hooks = hooks
+        @app_name = app_name
+      end
+
+      # Loads the env files that exist, without overriding what is already
+      # set, so an exported variable beats the file.
+      #
+      # @return [void]
+      def load_env
+        files = env_files.select { File.exist?(it) }
+        Dotenv.load(*files) unless files.empty?
+      end
+
+      # Fails before anything is called when a key the run needs is neither
+      # exported nor in an env file.
+      #
+      # @param names [Array<String>]
+      # @return [void]
+      # @raise [Error] naming every missing variable
+      def require_env!(names)
+        missing = names.uniq.select { ENV[it].to_s.strip.empty? }
+        return if missing.empty?
+
+        found = env_files.select { File.exist?(it) }
+        where = if found.empty?
+                  env_files.empty? ? "no env files are configured" : "there is no #{env_files.join(" or ")}"
+                else
+                  "checked the environment, then #{found.join(", ")}"
+                end
+        raise Error,
+          "missing #{missing.join(", ")}: export them or add them to an env file (#{where}); " \
+          "an exported blank value wins over the file"
+      end
+
+      # @param providers [Array<Providers::Base>] the providers the run's models use
+      # @param tracker [Class<Tracker>, nil] the remote tracker chosen, whose gems and key are checked too
+      # @return [void]
+      # @raise [Error] when a needed variable or gem is missing
+      def setup!(providers: [], tracker: nil)
+        load_env
+        require_env!(providers.flat_map(&:env_keys))
+        tracker&.requirements!(ENV)
+        hooks.each(&:call) # after load_env: a hook usually re-reads ENV
+        providers.each { it.setup!(app_name: app_name) }
+      end
+
+      # Opens a URL in the desktop browser.
+      #
+      # @param url [String]
+      # @return [Boolean] whether the opener ran
+      def browse(url)
+        opener = RUBY_PLATFORM.include?("darwin") ? "open" : "xdg-open"
+        system(opener, url, out: File::NULL, err: File::NULL) || false
+      end
+    end
+  end
+end

data/lib/llm/evals/schema_validator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module LLM
+  module Evals
+    # Checks a Hash of answers against a field map, for scorers and verifiers
+    # whose expected values are typed and closed. Nothing here is specific to
+    # what the fields mean.
+    #
+    # The map is `{ "name" => { type:, enum:, nullable: } }`; `type` is one of
+    # {TYPES}, `enum` lists the allowed values for enum and multi_enum, and a
+    # nullable field accepts nil (the text never answered it).
+    class SchemaValidator
+      TYPES = %i[boolean integer number string enum multi_enum].freeze
+
+      attr_reader :fields
+
+      # @param fields [Hash{String, Symbol => Hash}]
+      # @raise [ArgumentError] on a type outside {TYPES}, since a typo there would pass everything
+      def initialize(fields)
+        @fields = fields.to_h { |name, spec| [name.to_s, normalize(name, spec)] }.freeze
+      end
+
+      # @return [Array<String>] the field names
+      def names = fields.keys
+
+      # @param values [Hash] String or Symbol keys
+      # @return [Array<String>] every problem found; empty when the values fit the map
+      def problems(values)
+        return ["#{values.inspect} is not a Hash"] unless values.is_a?(Hash)
+
+        actual = values.transform_keys(&:to_s)
+        missing = names - actual.keys
+        extra = actual.keys - names
+        problems = []
+        problems << "missing #{missing.join(", ")}" if missing.any?
+        problems << "unknown fields #{extra.join(", ")}" if extra.any?
+        fields.each do |name, spec|
+          next unless actual.key?(name)
+
+          problem = value_problem(spec, actual[name])
+          problems << "#{name}: #{problem}" if problem
+        end
+        problems
+      end
+
+      # @param values [Hash]
+      # @return [Boolean]
+      def valid?(values) = problems(values).empty?
+
+      # @param spec [Hash] one field's normalized spec
+      # @param value [Object]
+      # @return [String, nil] what is wrong with the value, or nil
+      def value_problem(spec, value)
+        return (spec[:nullable] ? nil : "is null") if value.nil?
+
+        case spec[:type]
+        when :boolean then "#{value.inspect} is not a boolean" unless [true, false].include?(value)
+        when :integer then "#{value.inspect} is not an integer" unless value.is_a?(Integer)
+        when :number then "#{value.inspect} is not a number" unless value.is_a?(Numeric)
+        when :string then "#{value.inspect} is not a string" unless value.is_a?(String)
+        when :enum then "#{value.inspect} is not one of #{spec[:enum].join("|")}" unless spec[:enum].include?(value)
+        when :multi_enum then multi_enum_problem(spec, value)
+        end
+      end
+
+      private
+
+      def multi_enum_problem(spec, value)
+        return "#{value.inspect} is not an array" unless value.is_a?(Array)
+
+        stray = value - spec[:enum]
+        "#{stray.join(", ")} not in #{spec[:enum].join("|")}" if stray.any?
+      end
+
+      def normalize(name, spec)
+        spec = spec.transform_keys(&:to_sym)
+        type = spec.fetch(:type).to_sym
+        raise ArgumentError, "#{name}: unknown type #{type.inspect}, expected one of #{TYPES.join(", ")}" unless TYPES.include?(type)
+
+        { type: type, enum: Array(spec[:enum] || spec[:values]).map(&:to_s), nullable: spec.fetch(:nullable, false) }
+      end
+    end
+  end
+end

data/lib/llm/evals/score.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LLM
+  module Evals
+    # What a {Scorer} says about one reply. `value` is the case's overall
+    # score in 0..1; `metrics` holds one entry per {Metric} the scorer
+    # declares, nil where the case does not apply; `outcomes` and
+    # `diagnostics` are free-form, keyed by field, and only ever displayed.
+    Score = Data.define(:value, :metrics, :outcomes, :diagnostics) do
+      def initialize(value:, metrics: {}, outcomes: {}, diagnostics: {})
+        raise ArgumentError, "score value #{value.inspect} is not within 0..1" unless value.is_a?(Numeric) && (0..1).cover?(value)
+
+        super(value: value.to_f, metrics: metrics.transform_keys(&:to_s), outcomes: outcomes, diagnostics: diagnostics)
+      end
+
+      # The score of a reply the model failed: 0 everywhere, the failure as a diagnostic.
+      #
+      # @param metrics [Array<Metric>]
+      # @param error [String]
+      # @return [Score]
+      def self.failed(metrics, error)
+        new(value: 0.0, metrics: metrics.to_h { [it.name, 0.0] }, diagnostics: { "error" => error })
+      end
+    end
+  end
+end

data/lib/llm/evals/scorer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module LLM
+  module Evals
+    # What a suite implements to score one reply. Pure and deterministic: it
+    # reads the case, the reply and the adapter's context, and calls nothing.
+    #
+    # @abstract Subclass and override {#metrics} and {#call}.
+    class Scorer
+      # The metrics every {Score} this scorer returns carries. The CLI builds
+      # its columns, its glossary and its Braintrust scorers from this list,
+      # so a metric missing here is a metric nobody sees.
+      #
+      # @return [Array<Metric>]
+      def metrics
+        raise NotImplementedError, "#{self.class}#metrics must return an Array of LLM::Evals::Metric"
+      end
+
+      # @return [Metric] the one flagged primary, else the first
+      def primary = metrics.find(&:primary) || metrics.first
+
+      # @param kase [Case]
+      # @param reply [Reply] never one with `error` set; the runner scores those 0 itself
+      # @param context [Hash] what {Adapter#context} returned for the case
+      # @return [Score]
+      def call(kase, reply, context:)
+        raise NotImplementedError, "#{self.class}#call(kase, reply, context:) must return an LLM::Evals::Score"
+      end
+
+      # Offline checks of one case against what the scorer will demand of it,
+      # so a typo in expected.json is caught before it is billed as a model's mistake.
+      #
+      # @param kase [Case]
+      # @param context [Hash] what {Adapter#context} returned for the case
+      # @return [Array<String>] problems; empty when the case is sound
+      def verify(kase, context:) = [] # rubocop:disable Lint/UnusedMethodArgument -- the signature is the contract
+
+      # One short cell describing the case in `llm-evals cases`, e.g. "5/8 answered".
+      #
+      # @param kase [Case]
+      # @return [String, nil] nil for the generic fallback
+      def summary(_kase) = nil
+    end
+  end
+end

data/lib/llm/evals/templates/html_report.css

@@ -0,0 +1,206 @@
+:root {
+  color-scheme: dark;
+  --bg: #0b1014;
+  --panel: #121a20;
+  --panel-raised: #19232b;
+  --text: #e8eef1;
+  --muted: #93a3ad;
+  --line: #2a3942;
+  --blue: #73bfff;
+  --green: #55d79a;
+  --orange: #ffad5c;
+  --red: #ff746d;
+}
+
+* { box-sizing: border-box; }
+
+html { scroll-behavior: smooth; scroll-padding-top: 88px; }
+
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--text);
+  font: 15px/1.55 Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+main {
+  max-width: 1600px;
+  margin: auto;
+  padding: 36px 32px 84px;
+}
+
+.report-header {
+  display: flex;
+  align-items: flex-end;
+  justify-content: space-between;
+  gap: 24px;
+  margin-bottom: 22px;
+  scroll-margin-top: 90px;
+}
+
+.report-header .eyebrow { margin: 0 0 6px; color: var(--green); }
+h1 { margin: 0; font-size: clamp(28px, 4vw, 42px); font-weight: 650; letter-spacing: -.035em; line-height: 1.12; }
+h2 { margin: 0 0 8px; font-size: 21px; font-weight: 620; letter-spacing: -.02em; }
+h3 { margin: 25px 0 10px; font-size: 15px; font-weight: 650; }
+h4 { margin: 14px 0 6px; }
+p { max-width: 78ch; }
+.muted { color: var(--muted); }
+.report-header .muted { margin: 9px 0 0; }
+
+.top-link {
+  flex: none;
+  padding: 8px 12px;
+  border: 1px solid var(--line);
+  border-radius: 7px;
+  color: var(--muted);
+  text-decoration: none;
+}
+.top-link:hover, .top-link:focus-visible { border-color: var(--green); color: var(--text); }
+
+.section-nav {
+  position: sticky;
+  z-index: 5;
+  top: 0;
+  display: flex;
+  gap: 5px;
+  margin: 0 -12px 22px;
+  padding: 9px 12px;
+  overflow-x: auto;
+  border: 1px solid var(--line);
+  border-radius: 9px;
+  background: rgb(11 16 20 / 94%);
+  box-shadow: 0 8px 24px rgb(0 0 0 / 22%);
+  backdrop-filter: blur(12px);
+  scrollbar-width: thin;
+}
+
+.section-nav a {
+  flex: none;
+  padding: 7px 11px;
+  border-radius: 6px;
+  color: var(--muted);
+  font-size: 13px;
+  text-decoration: none;
+  transition: color .15s ease, background-color .15s ease;
+}
+.section-nav a:hover, .section-nav a:focus-visible { background: var(--panel-raised); color: var(--text); outline: none; }
+.section-nav a:focus-visible { box-shadow: 0 0 0 2px var(--blue); }
+
+section,
+.dataset {
+  margin: 16px 0;
+  padding: 20px;
+  border: 1px solid var(--line);
+  border-radius: 11px;
+  background: var(--panel);
+  scroll-margin-top: 82px;
+}
+
+.health {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(155px, 1fr));
+  gap: 10px;
+  padding: 0;
+  border: 0;
+  background: none;
+}
+
+.stat {
+  min-height: 94px;
+  padding: 14px 16px;
+  border: 1px solid var(--line);
+  border-radius: 9px;
+  background: var(--panel);
+}
+.stat b { display: block; font-size: 24px; font-variant-numeric: tabular-nums; letter-spacing: -.025em; }
+.stat span, .eyebrow { color: var(--muted); }
+.stat span { font-size: 12px; }
+
+.notice { padding: 12px 14px; border-left: 3px solid var(--red); background: #ff746d12; }
+.leader {
+  display: grid;
+  gap: 5px;
+  margin: 18px 0;
+  padding: 17px 18px;
+  border: 1px solid #55d79a80;
+  border-radius: 9px;
+  background: #55d79a0d;
+}
+.leader.none { border-color: #ff746d80; background: #ff746d0d; }
+.leader strong { font-size: 21px; }
+.eyebrow { font-size: 11px; letter-spacing: .075em; }
+.provider { color: var(--green); font-weight: 650; }
+.model-id { color: var(--orange); font-weight: 700; }
+.settings { display: block; color: var(--muted); font-size: 12px; }
+
+.track { height: 12px; overflow: hidden; border-radius: 99px; background: var(--line); }
+.track i { display: block; height: 100%; background: linear-gradient(90deg, var(--blue), var(--green)); }
+
+table { width: 100%; min-width: 980px; border-collapse: collapse; font-size: 13px; }
+th, td { padding: 10px 11px; border-top: 1px solid var(--line); text-align: left; vertical-align: top; }
+th { color: var(--muted); font-size: 12px; font-weight: 550; white-space: nowrap; }
+tbody tr:hover { background: rgb(255 255 255 / 2.5%); }
+td { font-variant-numeric: tabular-nums; }
+.sortable th { cursor: pointer; user-select: none; }
+.sortable th::after { color: var(--muted); font-size: 11px; content: " ↕"; }
+.sortable th[aria-sort="ascending"]::after { content: " ↑"; }
+.sortable th[aria-sort="descending"]::after { content: " ↓"; }
+.sortable th:focus-visible { outline: 2px solid var(--blue); outline-offset: -2px; }
+.standings-table th > span { display: block; }
+.standings-settings { color: var(--text); font-weight: 400; }
+.standings-table .standings-bar { min-width: 300px; }
+
+.scroll { max-width: 100%; overflow-x: auto; overscroll-behavior-inline: contain; -webkit-overflow-scrolling: touch; }
+th:first-child, td:first-child { white-space: nowrap; }
+.dataset { overflow: hidden; padding: 0; }
+.dataset[open] { border-color: #3b505a; }
+.dataset > summary, .case > summary {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 15px 18px;
+  list-style: none;
+  cursor: pointer;
+}
+.dataset > summary { align-items: center; background: var(--panel-raised); }
+.dataset > summary::before, .case > summary::before { content: "＋"; color: var(--green); font-size: 13px; }
+.dataset[open] > summary::before, .case[open] > summary::before { content: "−"; }
+.dataset > summary::-webkit-details-marker, .case > summary::-webkit-details-marker { display: none; }
+.dataset > summary strong { margin-right: auto; font-size: 16px; }
+.dataset > summary span, .case > summary span { color: var(--muted); }
+.dataset-content { padding: 0 18px 20px; }
+.dataset-content > h3:first-child { margin-top: 20px; }
+
+.case { overflow: hidden; margin: 8px 0; border: 1px solid var(--line); border-radius: 8px; }
+.case > summary { align-items: center; padding: 10px 12px; }
+.case-content { padding: 0 12px 12px; }
+.case-content pre { max-height: 360px; overflow: auto; padding: 10px; border: 1px solid var(--line); border-radius: 6px; background: var(--bg); white-space: pre-wrap; overflow-wrap: anywhere; }
+pre { font: 12px/1.55 ui-monospace, SFMono-Regular, Menlo, monospace; }
+.case-content details { margin: 8px 0; }
+.case-content details > summary { color: var(--blue); cursor: pointer; }
+
+@media (prefers-reduced-motion: reduce) {
+  html { scroll-behavior: auto; }
+  *, *::before, *::after { transition-duration: .01ms !important; }
+}
+
+@media (max-width: 900px) {
+  main { padding: 26px 20px 60px; }
+}
+
+@media (max-width: 700px) {
+  main { padding: 20px 12px 42px; }
+  .report-header { align-items: flex-start; }
+  .top-link { display: none; }
+  .section-nav { margin-right: -4px; margin-left: -4px; }
+  section { padding: 15px; }
+  .dataset-content { padding: 0 10px 12px; }
+  .health { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .stat { min-height: 80px; padding: 11px; }
+  .stat b { font-size: 20px; }
+  .dataset > summary { align-items: flex-start; flex-wrap: wrap; }
+  .dataset > summary span { flex-basis: 100%; padding-left: 22px; }
+  .case > summary { align-items: flex-start; flex-wrap: wrap; }
+  .case > summary span { flex-basis: 100%; padding-left: 22px; }
+  table { min-width: 900px; }
+}