haveapi 0.30.2 → 0.31.1

data/benchmarks/performance_compare.rb

@@ -8,6 +8,8 @@ module HaveAPI
 end
 require 'digest'
 require 'json'
+require 'open3'
+require 'rbconfig'
 
 module HaveAPI
   module Performance
@@ -18,6 +20,7 @@ module HaveAPI
     MAX_ITERATIONS = 100_000
     REQUEST_LIMIT_SECONDS = 30.0
     SETUP_LIMIT_SECONDS = 120.0
+    BENCHMARK_INPUTS = %w[servers/ruby/benchmarks/Gemfile servers/ruby/benchmarks/Gemfile.lock servers/ruby/benchmarks/shell.nix].freeze
 
     def self.complex_cases(profile)
       sizes = profile == 'weekly' ? [32] : [16]
@@ -30,6 +33,34 @@ module HaveAPI
     RUNTIME_POLICY = { 'rack_env' => 'test', 'locale' => 'C.UTF-8', 'timezone' => 'UTC', 'yjit' => false, 'rjit' => false }.freeze
     class ContractError < StandardError; end
 
+    def self.gemspec(root, path)
+      script = <<~RUBY
+        require 'json'
+        spec = Gem::Specification.load(File.basename(ARGV.fetch(0)))
+        abort 'Cannot load gemspec' unless spec
+        puts JSON.generate(name: spec.name, version: spec.version.to_s, ruby: spec.required_ruby_version.to_s,
+                           dependencies: spec.dependencies.map { |d| [d.name, d.type.to_s, d.requirement.to_s] }.sort)
+      RUBY
+      environment = (ENV.keys.grep(/\ABUNDLE/) + %w[RUBYOPT RUBYLIB RUBYGEMS_GEMDEPS]).to_h { |key| [key, nil] }
+      output, errors, status = Open3.capture3(environment, RbConfig.ruby, '-e', script, path, chdir: File.dirname(File.join(root, path)))
+      raise ContractError, "Cannot load source gemspec #{path}: #{errors.strip}" unless status.success?
+
+      specification = JSON.parse(output)
+      unless Gem::Requirement.new(specification.fetch('ruby')).satisfied_by?(Gem::Version.new(RUBY_VERSION))
+        raise ContractError, "Benchmark Ruby does not satisfy #{path}"
+      end
+
+      specification.fetch('dependencies').each do |name, type, requirement|
+        next unless type == 'runtime'
+        next if %w[haveapi haveapi-client haveapi-rust-client].include?(name)
+
+        unless Gem::Requirement.new(requirement.split(',').map(&:strip)).satisfied_by?(Gem::Specification.find_by_name(name).version)
+          raise ContractError, "Benchmark dependencies do not satisfy #{name} #{requirement}"
+        end
+      end
+      specification
+    end
+
     # One reviewed maintenance mapping, not a general cherry-pick certificate.
     # Both live entry points verify Git; replay verifies the retained raw delta.
     module Release
@@ -166,7 +197,10 @@ module HaveAPI
         receipt = inputs.fetch('release_versions')
         raise ContractError, 'Incomplete release input graph' unless receipt.fetch('contents').keys.sort == paths(profile).sort
         raise ContractError, 'Release input normalization mismatch' unless receipt == capture(receipt.fetch('contents'))
-        raise ContractError, 'Release normalized graph mismatch' unless inputs.fetch('manifests') == receipt.fetch('normalized_sha256')
+
+        expected = receipt.fetch('normalized_sha256')
+        expected = expected.except('flake.nix', 'flake.lock') if inputs.has_key?('benchmark')
+        raise ContractError, 'Release normalized graph mismatch' unless inputs.fetch('manifests') == expected
 
         receipt.fetch('raw_sha256').each do |path, digest|
           raise ContractError, 'Release input escaped verified source' unless source.fetch('files_sha256').fetch(path) == digest
@@ -175,7 +209,7 @@ module HaveAPI
       end
 
       def self.graph(inputs)
-        inputs.except('release_versions', 'json_preparation')
+        inputs.except('release_versions', 'source_versions', 'json_preparation', 'contributor_flakes')
       end
 
       def self.html(body, own)
@@ -204,6 +238,103 @@ module HaveAPI
       end
     end
 
+    # Ordinary source ancestry needs no historical maintenance certificate.
+    # Only synchronized package metadata is omitted from input equality.
+    module SourceVersions
+      PLACEHOLDER = 'OWN.VERSION'.freeze
+      COMPONENTS = Release::VERSIONS
+      SPECS = COMPONENTS.to_h { |path, name| ["#{path.split('/lib/').first}/#{name}.gemspec", name] }.freeze
+      PATHS = (['VERSION'] + COMPONENTS.keys + SPECS.keys).freeze
+
+      def self.capture(contents)
+        raise ContractError, 'Incomplete own source metadata' unless contents.keys.sort == PATHS.sort
+
+        own = contents.fetch('VERSION').delete_suffix("\n")
+        unless own.match?(/\A(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\z/) && contents['VERSION'] == "#{own}\n"
+          raise ContractError, 'Invalid own source VERSION'
+        end
+
+        normalized = contents.merge('VERSION' => "#{PLACEHOLDER}\n")
+        COMPONENTS.each do |path, name|
+          text = contents.fetch(path)
+          declaration = /^(\s*VERSION = )'#{Regexp.escape(own)}'(?=\.freeze$)/
+          unless text.scan(/^\s*VERSION\s*=/).length == 1 && text.scan(declaration).length == 1
+            raise ContractError, "Unsynchronized own version: #{name}"
+          end
+
+          normalized[path] = text.sub(declaration, "\\1'#{PLACEHOLDER}'")
+        end
+        SPECS.each do |path, name|
+          text = contents.fetch(path)
+          constant = { 'haveapi' => 'HaveAPI', 'haveapi-client' => 'HaveAPI::Client', 'haveapi-rust-client' => 'HaveAPI::RustClient' }.fetch(name)
+          unless text.scan(/\.name\s*=/).length == 1 && text.scan(/\.name\s*= '#{Regexp.escape(name)}'$/).length == 1 &&
+                 text.scan(/\.version\s*=/).length == 1 && text.scan(/\.version\s*= #{Regexp.escape(constant)}::VERSION$/).length == 1
+            raise ContractError, 'Mismatched own package identity'
+          end
+
+          dependencies = text.scan(/\.add_(?:runtime_|development_)?dependency\s+['"]haveapi-client['"]/)
+          requirement = /(?<=\.add_dependency )'haveapi-client', '~> #{Regexp.escape(own)}'(?=$)/
+          if name == 'haveapi-client'
+            raise ContractError, 'Unexpected own client dependency' unless dependencies.empty?
+          else
+            unless dependencies.length == 1 && text.scan(requirement).length == 1
+              raise ContractError, 'Unsynchronized own client constraint'
+            end
+
+            normalized[path] = text.sub(requirement, "'haveapi-client', '~> #{PLACEHOLDER}'")
+          end
+        end
+        { 'contents' => contents, 'own_version' => own,
+          'raw_sha256' => contents.transform_values { |text| Digest::SHA256.hexdigest(text) },
+          'normalized_sha256' => normalized.transform_values { |text| Digest::SHA256.hexdigest(text) } }
+      end
+
+      def self.gemspec(root, path, receipt)
+        spec = Performance.gemspec(root, path)
+        own = receipt.fetch('own_version')
+        unless spec.fetch('name') == SPECS.fetch(path) && spec.fetch('version') == own
+          raise ContractError, 'Evaluated own package identity mismatch'
+        end
+
+        dependencies = spec.fetch('dependencies').select { |name, _type, _requirement| name == 'haveapi-client' }
+        expected = SPECS.fetch(path) == 'haveapi-client' ? [] : [['haveapi-client', 'runtime', "~> #{own}"]]
+        raise ContractError, 'Evaluated own client constraint mismatch' unless dependencies == expected
+
+        spec.merge('version' => PLACEHOLDER, 'dependencies' => spec.fetch('dependencies').map do |name, type, requirement|
+          [name, type, name == 'haveapi-client' ? "~> #{PLACEHOLDER}" : requirement]
+        end)
+      end
+
+      def self.validate_inputs(inputs, source)
+        receipt = inputs.fetch('source_versions')
+        raise ContractError, 'Own source metadata normalization mismatch' unless receipt == capture(receipt.fetch('contents'))
+
+        receipt.fetch('raw_sha256').each do |path, digest|
+          unless source.fetch('files_sha256').fetch(path) == digest && inputs.fetch('manifests').fetch(path) == receipt.fetch('normalized_sha256').fetch(path)
+            raise ContractError, 'Own source metadata escaped verified source'
+          end
+        end
+      end
+    end
+
+    def self.validate_input_receipts(inputs, source, profile:, lineage:)
+      if lineage
+        raise ContractError, 'Conflicting own-version receipts' if inputs.has_key?('source_versions')
+
+        Release.validate_inputs(inputs, source, profile)
+      else
+        raise ContractError, 'Unproven own-version normalization' if inputs.has_key?('release_versions')
+
+        Release.validate_json_preparation(inputs, source)
+        SourceVersions.validate_inputs(inputs, source) if inputs.has_key?('source_versions')
+        inputs.fetch('manifests').each do |path, digest|
+          next if Release::JSON_GEMFILES.include?(path) || (inputs.has_key?('source_versions') && SourceVersions::PATHS.include?(path))
+
+          raise ContractError, 'Dependency manifest escaped source' unless source.fetch('files_sha256').fetch(path) == digest
+        end
+      end
+    end
+
     def self.validate_source_pair(profile:, baseline_sha:, candidate_sha:)
       raise ContractError, 'Baseline and candidate must differ' if baseline_sha == candidate_sha
       return unless profile == 'weekly' && baseline_sha != REFERENCE
@@ -211,6 +342,19 @@ module HaveAPI
       raise ContractError, 'Weekly baseline must be the fixed reference'
     end
 
+    def self.push_pair!(selection, baseline:, candidate:)
+      return false unless selection['push_pair']
+
+      expected = { 'event_name' => 'push', 'before' => baseline, 'after' => candidate }
+      unless selection['event_name'] == 'push' && selection['profile'] == 'quick' && selection['push_pair'] == expected &&
+             selection['baseline_sha'] == baseline && selection['candidate_sha'] == candidate && baseline != candidate &&
+             [baseline, candidate].all? { |sha| sha.is_a?(String) && sha.match?(/\A[0-9a-f]{40}\z/) && sha != '0' * 40 }
+        raise ContractError, 'Invalid quick push event pair'
+      end
+
+      true
+    end
+
     # Canonicalization ignores map order only. Arrays and scalar types retain
     # their meaning; duplicate JSON or symbol/string-normalized keys fail closed.
     module Identity
@@ -270,6 +414,9 @@ module HaveAPI
     end
 
     class Comparator
+      POLICY = 'per-revision-response-stability-v1'.freeze
+      SOURCE_SHA256 = Digest::SHA256.file(__FILE__).hexdigest.freeze
+
       def initialize(samples, budgets, budget_sha256:)
         @samples = samples
         @budgets = budgets
@@ -357,13 +504,33 @@ module HaveAPI
             raise ContractError, 'Loaded runtime not in verified source tree' unless selected.fetch('files_sha256').fetch(path) == sha256
           end
           inputs = observation.fetch('inputs')
-          if lineage
-            Release.validate_inputs(inputs, selected, @samples.fetch('profile'))
-          elsif inputs.has_key?('release_versions')
-            raise ContractError, 'Unproven own-version normalization'
-          else
-            Release.validate_json_preparation(inputs, selected)
+          if inputs.has_key?('benchmark')
+            tool = inputs.fetch('benchmark')
+            raise ContractError, 'Incomplete benchmark inputs' unless tool.keys.sort == BENCHMARK_INPUTS.sort
+
+            tool.each do |path, input|
+              unless Digest::SHA256.hexdigest(input.fetch('content')) == input.fetch('sha256') &&
+                     @samples.fetch('inputs').fetch('benchmark').fetch(path) == input
+                raise ContractError, 'Benchmark input digest mismatch'
+              end
+            end
+            unless inputs.fetch('locks') == { 'servers/ruby/benchmarks/Gemfile.lock' => tool.fetch('servers/ruby/benchmarks/Gemfile.lock').fetch('sha256') }
+              raise ContractError, 'Benchmark lock identity mismatch'
+            end
+
+            inputs.fetch('contributor_flakes').each do |path, input|
+              unless %w[flake.nix flake.lock].include?(path) && Digest::SHA256.hexdigest(input.fetch('content')) == selected.fetch('files_sha256').fetch(path)
+                raise ContractError, 'Contributor flake escaped source'
+              end
+            end
+            unless inputs.fetch('contributor_flakes').keys.sort == %w[flake.lock flake.nix]
+              raise ContractError, 'Missing contributor flake provenance'
+            end
+
+          elsif inputs.has_key?('contributor_flakes')
+            raise ContractError, 'Contributor flake separation without benchmark inputs'
           end
+          Performance.validate_input_receipts(inputs, selected, profile: @samples.fetch('profile'), lineage:)
           unless observation.fetch('environment') == @samples['environment'] && Release.graph(inputs) == @samples.fetch('inputs') &&
                  observation.fetch('fixture_sha256') == @samples['fixture_sha256']
             raise ContractError, 'Worker provenance mismatch'
@@ -474,14 +641,28 @@ module HaveAPI
         end
       end
 
+      def output_counts(outputs, digest = 'canonical_sha256')
+        outputs.each_with_object(Hash.new(0)) do |output, counts|
+          identity = JSON.generate(output.values_at('http_status', 'envelope_status', digest))
+          counts[identity] += output.fetch('count')
+        end
+      end
+
       def same_outputs(left, right)
-        summaries = [left, right].map do |outputs|
-          outputs.each_with_object(Hash.new(0)) do |output, counts|
-            identity = JSON.generate(output.values_at('http_status', 'envelope_status', 'canonical_sha256'))
-            counts[identity] += output.fetch('count')
-          end
+        output_counts(left) == output_counts(right)
+      end
+
+      def response_changes(pairs)
+        outputs = %w[baseline candidate].to_h do |role|
+          [role, pairs.flat_map { |pair| pair.fetch(role).fetch('outputs') }]
         end
-        summaries.first == summaries.last
+        bytes = outputs.transform_values do |examples|
+          examples.sum { |output| output.fetch('body_bytes') * output.fetch('count') }.to_f / examples.sum { |output| output.fetch('count') }
+        end
+        delta = bytes.fetch('candidate') - bytes.fetch('baseline')
+        { 'raw_changed' => output_counts(outputs.fetch('baseline'), 'body_sha256') != output_counts(outputs.fetch('candidate'), 'body_sha256'),
+          'canonical_changed' => !same_outputs(outputs.fetch('baseline'), outputs.fetch('candidate')),
+          'bytes_per_request' => bytes.merge('delta' => delta, 'delta_percent' => 100.0 * delta / bytes.fetch('baseline')) }
       end
 
       def compare_case(item, budget)
@@ -499,7 +680,8 @@ module HaveAPI
           raise ContractError, 'Uncalibrated allocation ceiling' unless reference > 0 && ceiling == (reference * 1.25).ceil + 32
         end
 
-        canonical_outputs = canonical_counters = nil
+        outputs_by_source = {}
+        canonical_counters = nil
         (self_pairs + pairs).each_with_index do |pair, index|
           expected_order = if index < self_pairs.length
                              %w[baseline baseline]
@@ -530,8 +712,10 @@ module HaveAPI
               raise ContractError, 'Worker workload order mismatch'
             end
 
-            canonical_outputs ||= sample.fetch('outputs')
-            raise ContractError, 'Response identity differs between operations/revisions' unless same_outputs(canonical_outputs, sample['outputs'])
+            outputs_by_source[actual_sha] ||= sample.fetch('outputs')
+            unless same_outputs(outputs_by_source.fetch(actual_sha), sample.fetch('outputs'))
+              raise ContractError, "Response identity differs within revision #{actual_sha}"
+            end
           end
         end
         classifications = %w[wall_seconds cpu_seconds].to_h do |metric|
@@ -566,9 +750,10 @@ module HaveAPI
                            'pass'
                          end
         item.slice('id', 'dimensions', 'iterations')
-            .merge('classification' => classification, 'timing' => classifications,
+            .merge('classification' => classification, 'timing' => classifications, 'responses' => response_changes(pairs),
                    'correctness' => { 'status' => 'pass', 'validated_samples' => 2 * (self_pairs.length + pairs.length),
-                                      'operations_per_sample' => iterations, 'distinct_responses' => canonical_outputs.length },
+                                      'operations_per_sample' => iterations, 'distinct_responses' => outputs_by_source.fetch(@samples.fetch('baseline_sha')).length,
+                                      'distinct_responses_by_source' => outputs_by_source.transform_values(&:length) },
                    'pilot' => item.fetch('pilot', {}).slice('selected_iterations', 'warmup_iterations', 'target_seconds',
                                                             'baseline_batch_seconds', 'adequate_signal', 'capped', 'calibration_adjusted'),
                    'allocations' => { 'baseline_median' => base_allocations, 'candidate_median' => candidate_allocations,

data/benchmarks/shell.nix

@@ -0,0 +1,21 @@
+let
+  pkgs = import (builtins.fetchTree {
+    type = "github";
+    owner = "NixOS";
+    repo = "nixpkgs";
+    rev = "02c087f3fe673c9e317f206a627cb6b910336dbe";
+    narHash = "sha256-IoNisKcGbUjdd45qCqywGMCYmZ5EnkxezvLII0FWwNA=";
+  }) { };
+in
+pkgs.mkShell {
+  name = "haveapi-benchmarks";
+  packages = with pkgs; [ ruby_3_4 git gnumake pkg-config openssl libffi ];
+  LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath [ pkgs.stdenv.cc.cc.lib ];
+  shellHook = ''
+    for name in ''${!BUNDLE@}; do unset "$name"; done
+    unset RUBYOPT RUBYLIB RUBYGEMS_GEMDEPS
+    export GEM_HOME="''${HAVEAPI_BENCHMARK_GEM_HOME:-${toString ./.}/.gems}"
+    export GEM_PATH="$GEM_HOME:${pkgs.ruby_3_4}/lib/ruby/gems/3.4.0"
+    export PATH="$GEM_HOME/bin:$PATH"
+  '';
+}

data/benchmarks/spec/client_examples_spec.rb

@@ -0,0 +1,216 @@
+# Run unbundled in the locked benchmark shell; optional generators are required.
+# One shared mounted fixture excludes setup from the per-render measurements.
+# rubocop:disable RSpec/InstanceVariable, RSpec/LeakyLocalVariable
+require_relative '../performance_compare'
+root = File.expand_path('../../../..', __dir__)
+%w[servers/ruby clients/ruby clients/go clients/rust clients/typescript].each do |component|
+  $:.unshift(File.join(root, component, 'lib'))
+end
+require 'haveapi'
+require 'rack/mock'
+require 'base64'
+require 'cgi'
+require_relative '../../test_support/all_client_performance_fixture'
+
+RSpec.configure { |config| config.fail_if_no_examples = true }
+
+RSpec.describe HaveAPI::ClientExample, '.render' do
+  # Each mode has its own registry entry. New entries need reviewed expectations
+  # and a real supported profile here, rather than silently missing measurement.
+  profiles = {
+    '0' => nil, '2' => nil, '3' => nil, '5' => nil, '6' => nil,
+    'javascript-callback' => nil, 'javascript-async' => nil,
+    'typescript-callback' => nil, 'typescript-async' => nil,
+    'python-sync' => nil, 'python-async' => nil,
+    'go' => :go, 'rust-async' => :rust, 'rust-blocking' => :rust,
+    'typescript-generated' => :typescript
+  }.freeze
+  lanes = %i[init basic token oauth2 public protected failure].freeze
+  let(:matrix) { profiles }
+
+  before(:all) do
+    @server = HaveAPI::AllClientPerformanceFixture.build(resources: 2)
+    @profiles = @server.documentation_client_profiles(1)
+    @description = description(@server, 'admin')
+    @large_description = Marshal.load(Marshal.dump(@description))
+    unrelated = @large_description.fetch(:resources).fetch('resource1')
+    unrelated[:resources] = 128.times.to_h { |i| ["unrelated#{i}", Marshal.load(Marshal.dump(@description[:resources]['resource1']))] }
+    @measurements = []
+  end
+
+  after(:all) do
+    RSpec.configuration.reporter.message("ALL_CLIENT_PERFORMANCE #{JSON.generate(registry: profiles.keys.sort, lanes:, measurements: @measurements)}")
+  end
+
+  def headers(user)
+    { 'HTTP_HOST' => 'example.test', 'HTTP_ACCEPT_LANGUAGE' => 'en',
+      'HTTP_AUTHORIZATION' => "Basic #{Base64.strict_encode64("#{user}:fixture-only")}" }
+  end
+
+  def description(server, user)
+    server.describe_version(HaveAPI::Context.new(server, version: 1,
+                                                         user: HaveAPI::DocumentationPerformanceFixture::User.new(user), params: {}))
+  end
+
+  def context(description, profile, action_name: 'protected', sample_index: 0, resource_name: 'resource0')
+    resource = description.fetch(:resources).fetch(resource_name)
+    action = resource.fetch(:actions).fetch(action_name)
+    HaveAPI::ClientExample::Context.new(version: 1, host: 'example.test',
+                                        base_url: 'http://example.test/benchmark/api/',
+                                        version_url: 'http://example.test/benchmark/api/v1/',
+                                        description:, profile:, resource_path: [resource_name.to_s],
+                                        resource:, action_name:, action:, sample: action.fetch(:examples).fetch(sample_index))
+  end
+
+  def render(client, lane, ctx)
+    if %i[basic token oauth2].include?(lane)
+      client.render(:auth, context: ctx, auth_method: lane, auth_description: ctx.description.fetch(:authentication).fetch(lane))
+    else
+      client.render(lane == :init ? :init : :example, context: ctx)
+    end
+  end
+
+  def expect_result(result, id, lane)
+    expect(result).to be_a(Hash), "#{id}/#{lane} returned no panel"
+    if id == 'typescript-generated' && lane == :oauth2
+      expect(result[:status]).to eq(:limitation)
+      expect(result[:reason]).to be_a(String)
+      expect(result[:reason]).not_to be_empty
+    else
+      expect(result[:status]).to eq(:code), "#{id}/#{lane}: #{result.inspect}"
+      expect(result[:code]).to be_a(String)
+      expect(result[:code]).not_to be_empty
+      if %w[0 3].include?(id) && lane == :oauth2
+        expect(result[:code]).to include('OAuth2 is not supported')
+      end
+    end
+  end
+
+  def allocations(count: 8, &block)
+    2.times(&block)
+    Array.new(3) do
+      before = GC.stat(:total_allocated_objects)
+      count.times(&block)
+      (GC.stat(:total_allocated_objects) - before) / count.to_f
+    end.min
+  end
+
+  def calls(&block)
+    count = 0
+    trace = TracePoint.new(:call) { count += 1 }
+    trace.enable(&block)
+    count
+  ensure
+    trace&.disable
+  end
+
+  it 'requires exactly the reviewed registry and all real profiles' do
+    ids = described_class.clients.map(&:id)
+    expect(ids.sort).to eq(profiles.keys.sort)
+    expect(ids.uniq).to eq(ids)
+    expect(@profiles.keys.sort).to eq(%i[go rust typescript])
+    expect(@description.fetch(:authentication).keys.sort).to eq(%i[basic oauth2 token])
+  end
+
+  profiles.each do |id, language|
+    lanes.each do |lane|
+      it "bounds #{id}/#{lane} work and allocations with unrelated descendants" do
+        client = described_class.clients.find { |item| item.id == id }
+        expect(client).not_to be_nil
+        profile = language && @profiles.fetch(language)
+        options = { action_name: lane == :public ? 'public' : 'protected', sample_index: lane == :failure ? 1 : 0 }
+        small = context(@description, profile, **options)
+        large = context(@large_description, profile, **options)
+        expect(client.available?(small)).to be(true)
+        expect(client.available?(large)).to be(true)
+        before = Marshal.dump([small.description, large.description])
+        expected = render(client, lane, small)
+        expect_result(expected, id, lane)
+        expect(render(client, lane, large)).to eq(expected)
+        small_calls = calls { render(client, lane, small) }
+        large_calls = calls { render(client, lane, large) }
+        small_allocations = allocations { render(client, lane, small) }
+        large_allocations = allocations { render(client, lane, large) }
+        @measurements << { id:, lane:, allocations: [small_allocations, large_allocations], calls: [small_calls, large_calls] }
+        # Selected action/provider/sample is unchanged. Allow fixed VM/lookup
+        # slack, while recursive walks of the 128 unrelated subtrees must fail.
+        expect(large_calls).to be <= small_calls + 32
+        expect(large_allocations).to be <= small_allocations + 32
+        expect(Marshal.dump([small.description, large.description])).to eq(before)
+      end
+    end
+  end
+
+  def expect_panel(body, anchor, result)
+    panel = body.match(%r{<div id="#{Regexp.escape(anchor)}">\s*(.*?)</div>}m)
+    expect(panel).not_to be_nil, "Missing #{anchor}"
+    text = result.fetch(result[:status] == :code ? :code : :reason)
+    expect(panel[1]).to include(CGI.escapeHTML(text))
+    expect(panel[1]).to include(result[:status] == :code ? '<pre><code' : 'client-limitation')
+  end
+
+  def expect_complete_page(server, user, resources)
+    desc = description(server, user)
+    response = Rack::MockRequest.new(server.app).get('/benchmark/api/v1/', **headers(user))
+    expect(response.status).to eq(200)
+    expect(response['content-type']).to start_with('text/html')
+    expect(response.body).to include('PUBLIC_SAMPLE')
+    %w[ADMIN_ONLY_ACTION ADMIN_ONLY_DEFAULT ADMIN_ONLY_REQUEST ADMIN_ONLY_RESPONSE ADMIN_ONLY_ACTION_SAMPLE admin_field admin_only].each do |marker|
+      expect(response.body.include?(marker)).to eq(user == 'admin'), marker
+    end
+    example_count = 0
+    HaveAPI::ClientExample.clients.each do |client|
+      language = matrix.fetch(client.id)
+      profile = language && server.documentation_client_profiles(1).fetch(language)
+      ctx = context(desc, profile)
+      expect(client.available?(ctx)).to be(true)
+      expect_panel(response.body, "init-#{client.id}", render(client, :init, ctx))
+      desc.fetch(:authentication).each_key do |method|
+        result = render(client, method, ctx)
+        expect_result(result, client.id, method)
+        expect_panel(response.body, "auth-#{method}-#{client.id}", result)
+      end
+      resources.times do |index|
+        resource_name = "resource#{index}"
+        desc.fetch(:resources).fetch(resource_name).fetch(:actions).each do |action_name, action|
+          action.fetch(:examples).each_index do |sample_index|
+            selected = context(desc, profile, action_name: action_name.to_s, sample_index:, resource_name:)
+            result = client.render(:example, context: selected)
+            expect_result(result, client.id, :example)
+            expect_panel(response.body, "example-#{resource_name}-#{action_name}-#{sample_index}-#{client.id}", result)
+            example_count += 1
+          end
+        end
+      end
+    end
+    expected_samples = (resources * 2 * (user == 'admin' ? 3 : 2)) + (user == 'admin' ? 1 : 0)
+    expect(example_count).to eq(expected_samples * matrix.length)
+    response
+  end
+
+  it 'renders every real panel and isolates admin/member/admin pages through the same adapters' do
+    first = expect_complete_page(@server, 'admin', 2)
+    expect_complete_page(@server, 'member', 2)
+    last = expect_complete_page(@server, 'admin', 2)
+    expect(last.body).to eq(first.body)
+  end
+
+  it 'bounds complete all-profile page allocations by linear output growth' do
+    measurements = [2, 4, 8].map do |resources|
+      server = HaveAPI::AllClientPerformanceFixture.build(resources:)
+      response = expect_complete_page(server, 'admin', resources)
+      request = Rack::MockRequest.new(server.app)
+      allocated = allocations(count: 1) { request.get('/benchmark/api/v1/', **headers('admin')) }
+      { resources:, bytes: response.body.bytesize, allocations: allocated }
+    end
+    @measurements << { pages: measurements }
+    small, medium, large = measurements
+    expect(large[:bytes]).to be > medium[:bytes]
+    expect(medium[:bytes]).to be > small[:bytes]
+    expect(medium[:allocations]).to be > small[:allocations]
+    # Doubling the added resources doubles actual panels/output. A 2.5x
+    # incremental allowance covers bookkeeping; quadratic copying approaches 4x.
+    expect(large[:allocations] - medium[:allocations]).to be <= 2.5 * (medium[:allocations] - small[:allocations])
+  end
+end
+# rubocop:enable RSpec/InstanceVariable, RSpec/LeakyLocalVariable