serialbench 0.2.0 → 0.3.1

data/site/src/components/FeaturesTable.astro

@@ -1,97 +0,0 @@
----
-import type { Payload } from '../lib/dashboard';
-import { channelColor } from '../lib/channels';
-
-interface Props {
-  payload: Payload;
-}
-
-const { payload } = Astro.props;
-
-const FEATURE_LABELS: Record<string, string> = {
-  streaming: 'Streaming (SAX)',
-  stax: 'StAX (pull)',
-  xpath: 'XPath',
-  namespaces: 'Namespaces',
-  validation: 'Validation',
-  pretty_print: 'Pretty print',
-  symbol_keys: 'Symbol keys',
-  custom_types: 'Custom types',
-  comments: 'Comments',
-  arrays_of_tables: 'Arrays of tables',
-  inline_tables: 'Inline tables',
-  multiline_strings: 'Multiline strings',
-};
-
-const FEATURE_ORDER = Object.keys(FEATURE_LABELS);
-
-const libraries = payload.libraries ?? [];
-const formats = [...new Set(libraries.map((l) => l.format))].sort();
-
-function columnsFor(group: typeof libraries): string[] {
-  const keys = new Set<string>();
-  for (const lib of group) for (const key of Object.keys(lib.features)) keys.add(key);
-  return FEATURE_ORDER.filter((k) => keys.has(k));
-}
----
-
-<section aria-label="Feature comparison" class="mt-12">
-  <div class="mb-3">
-    <p class="font-mono text-[10px] uppercase tracking-[0.14em] text-inkmute">Feature comparison — what each API offers, beyond speed</p>
-    <p class="font-mono text-[11px] text-inkmute mt-1">
-      Capabilities declared by the adapters · all libraries benchmark DOM-style parsing; a StAX column appears when a binding exposes a pull API.
-    </p>
-  </div>
-
-  {
-    formats.map((format) => {
-      const group = libraries.filter((l) => l.format === format);
-      const cols = columnsFor(group);
-      return (
-        <div class="mb-6">
-          <h3 class="font-mono text-[11px] uppercase tracking-[0.14em] text-inkdim mb-2">{format}</h3>
-          <div class="overflow-x-auto border border-line bg-panel">
-            <table class="w-full border-collapse">
-              <thead>
-                <tr>
-                  <th class="text-left font-mono text-[10px] uppercase tracking-[0.14em] text-inkmute font-normal px-3 py-2 border-b border-line">Library</th>
-                  <th class="text-left font-mono text-[10px] uppercase tracking-[0.14em] text-inkmute font-normal px-3 py-2 border-b border-line">Version</th>
-                  {cols.map((c) => (
-                    <th class="text-center font-mono text-[10px] uppercase tracking-wider text-inkmute font-normal px-3 py-2 border-b border-line whitespace-nowrap">
-                      {FEATURE_LABELS[c] ?? c}
-                    </th>
-                  ))}
-                </tr>
-              </thead>
-              <tbody>
-                {group.map((lib) => (
-                  <tr>
-                    <td class="px-3 py-1.5 border-b border-line/50 font-mono text-[12px] whitespace-nowrap">
-                      <a
-                        class="flex items-center gap-2 hover:text-phosphor transition-colors"
-                        href={`${import.meta.env.BASE_URL}library/${lib.name}/`}
-                      >
-                        <span class="h-2 w-2 rounded-full" style={`background: ${channelColor(lib.name)}`} />
-                        {lib.name}
-                      </a>
-                    </td>
-                    <td class="px-3 py-1.5 border-b border-line/50 font-mono text-[12px] text-inkmute">{lib.version}</td>
-                    {cols.map((c) => (
-                      <td class="px-3 py-1.5 border-b border-line/50 text-center">
-                        {lib.features[c] ? (
-                          <span class="inline-block h-2 w-2 rounded-full" style={`background: ${channelColor(lib.name)}`} title={FEATURE_LABELS[c] ?? c} />
-                        ) : (
-                          <span class="inline-block h-2 w-2 rounded-full border border-line" title="not supported" />
-                        )}
-                      </td>
-                    ))}
-                  </tr>
-                ))}
-              </tbody>
-            </table>
-          </div>
-        </div>
-      );
-    })
-  }
-</section>

data/site/src/components/MemoryPanel.vue

@@ -1,44 +0,0 @@
-<script setup lang="ts">
-import type { MemoryRow } from '../lib/dashboard';
-import { formatMemory } from '../lib/dashboard';
-import { channelColor } from '../lib/channels';
-
-const props = defineProps<{ rows: MemoryRow[]; size: string }>();
-
-const maxAllocated = () => Math.max(...props.rows.map((r) => r.allocated), 0.0001);
-</script>
-
-<template>
-  <figure class="border border-line bg-panel p-4">
-    <figcaption class="mb-4">
-      <p class="font-mono text-[10px] uppercase tracking-[0.14em] text-inkmute">Memory — {{ size }} input, lower is better</p>
-      <p class="font-mono text-[11px] text-inkmute mt-1">
-        Solid: allocated during operation · outline: retained afterwards
-      </p>
-    </figcaption>
-
-    <ul class="space-y-2.5" role="list">
-      <li v-for="row in rows" :key="row.serializer" class="grid grid-cols-[minmax(6rem,8rem)_1fr_minmax(6rem,7rem)] gap-x-3 items-center">
-        <span class="flex items-center gap-2 font-mono text-[13px] truncate min-w-0" :style="{ color: channelColor(row.serializer) }">
-          <span class="h-2 w-2 shrink-0 rounded-full" :style="{ background: channelColor(row.serializer) }" />
-          {{ row.serializer }}
-        </span>
-
-        <span class="relative h-5 graticule rounded-sm">
-          <span
-            class="absolute inset-y-[2px] left-0 rounded-[2px]"
-            :style="{ width: `${(row.allocated / maxAllocated()) * 100}%`, background: channelColor(row.serializer), opacity: 0.4 }"
-          />
-          <span
-            class="absolute inset-y-[2px] left-0 rounded-[2px] border"
-            :style="{ width: `${(row.retained / maxAllocated()) * 100}%`, borderColor: channelColor(row.serializer) }"
-          />
-        </span>
-
-        <span class="text-right font-mono text-[12px] tabular text-inkdim">
-          {{ formatMemory(row.allocated) }}
-        </span>
-      </li>
-    </ul>
-  </figure>
-</template>

data/site/src/components/OpsChart.vue

@@ -1,135 +0,0 @@
-<script setup lang="ts">
-import { onBeforeUnmount, onMounted, ref, watch } from 'vue';
-import {
-  BarController,
-  BarElement,
-  CategoryScale,
-  Chart,
-  Legend,
-  LinearScale,
-  LogarithmicScale,
-  Tooltip,
-} from 'chart.js';
-import type { Payload } from '../lib/dashboard';
-
-Chart.register(BarController, BarElement, CategoryScale, LinearScale, LogarithmicScale, Tooltip, Legend);
-
-const props = defineProps<{
-  payload: Payload;
-  op: string;
-  format: string;
-  sizes: string[];
-  envKey: string;
-  serializers: string[];
-}>();
-
-const canvas = ref<HTMLCanvasElement | null>(null);
-let chart: Chart | null = null;
-
-function cssVar(name: string): string {
-  return getComputedStyle(document.documentElement).getPropertyValue(name).trim();
-}
-
-function ipsAt(serializer: string, size: string): number {
-  const metric = props.payload.combined_results[props.op]?.[size]?.[props.format]?.[serializer]?.[props.envKey] as
-    | { iterations_per_second: number }
-    | undefined;
-  return metric?.iterations_per_second ?? 0;
-}
-
-function orderedSerializers(): string[] {
-  const anchor = props.sizes[props.sizes.length - 1] ?? 'small';
-  return [...props.serializers].sort((a, b) => ipsAt(b, anchor) - ipsAt(a, anchor));
-}
-
-function build() {
-  if (!canvas.value) return;
-  chart?.destroy();
-
-  const grid = cssVar('--line');
-  const inkMute = cssVar('--ink-mute');
-  const phosphor = cssVar('--phosphor');
-  const mono = "'IBM Plex Mono', monospace";
-
-  const sizeShades: Record<string, number> = { small: 0.35, medium: 0.6, large: 1 };
-
-  chart = new Chart(canvas.value, {
-    type: 'bar',
-    data: {
-      labels: orderedSerializers(),
-      datasets: props.sizes.map((size) => ({
-        label: size,
-        data: orderedSerializers().map((s) => ipsAt(s, size)),
-        backgroundColor: props.sizes.map((s) => hexAlpha(phosphor, sizeShades[s] ?? 0.6)),
-      })),
-    },
-    options: {
-      indexAxis: 'y' as const,
-      responsive: true,
-      maintainAspectRatio: false,
-      animation: { duration: window.matchMedia('(prefers-reduced-motion: reduce)').matches ? 0 : 400 },
-      scales: {
-        x: {
-          type: 'logarithmic',
-          grid: { color: grid },
-          border: { color: grid },
-          ticks: { color: inkMute, font: { family: mono, size: 10 } },
-        },
-        y: {
-          grid: { display: false },
-          border: { color: grid },
-          ticks: { color: inkMute, font: { family: mono, size: 11 } },
-        },
-      },
-      plugins: {
-        legend: {
-          labels: { color: inkMute, font: { family: mono, size: 10 }, boxWidth: 10, boxHeight: 10 },
-        },
-        tooltip: {
-          callbacks: {
-            label: (ctx) => {
-              const ips = ctx.parsed.x as number;
-              return `${ctx.dataset.label}: ${ips < 10 ? ips.toFixed(2) : ips.toFixed(0)} ips (${(1000 / ips).toFixed(1)} ms/op)`;
-            },
-          },
-        },
-      },
-    },
-  });
-}
-
-function hexAlpha(hex: string, alpha: number): string {
-  const clean = hex.replace('#', '');
-  const r = parseInt(clean.slice(0, 2), 16);
-  const g = parseInt(clean.slice(2, 4), 16);
-  const b = parseInt(clean.slice(4, 6), 16);
-  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
-}
-
-let themeObserver: MutationObserver | null = null;
-
-onMounted(() => {
-  build();
-  themeObserver = new MutationObserver(build);
-  themeObserver.observe(document.documentElement, { attributes: true, attributeFilter: ['data-theme'] });
-});
-
-onBeforeUnmount(() => {
-  themeObserver?.disconnect();
-  chart?.destroy();
-});
-
-watch(() => [props.op, props.format, props.envKey, props.serializers.join(','), props.sizes.join(',')], build);
-</script>
-
-<template>
-  <figure class="border border-line bg-panel p-4">
-    <figcaption class="mb-3">
-      <p class="font-mono text-[10px] uppercase tracking-[0.14em] text-inkmute">Consistency across input sizes — log scale</p>
-      <p class="font-mono text-[11px] text-inkmute mt-1">A library that wins at every size is a safe default; one that wins only at {{ sizes[sizes.length - 1] }} fits that workload.</p>
-    </figcaption>
-    <div class="h-72">
-      <canvas ref="canvas" role="img" aria-label="Bar chart comparing serializers across input sizes"></canvas>
-    </div>
-  </figure>
-</template>

data/site/src/config.ts

@@ -1,18 +0,0 @@
-// Site identity and navigation — the single place to change branding,
-// base path usage, or links. Base path itself lives in astro.config.mjs
-// (`site` + `base`); every internal link must be built from
-// import.meta.env.BASE_URL, never a literal "/".
-export const BASE = import.meta.env.BASE_URL;
-
-export const SITE = {
-  name: 'Serialbench',
-  tagline: 'ruby serialization · measurement console',
-  repoUrl: 'https://github.com/metanorma/serialbench',
-  footer: 'serialbench · automated weekly runs · metanorma',
-  disclaimer: 'microbenchmarks indicate, they do not decide',
-};
-
-export const NAV = [
-  { label: 'Dashboard', href: BASE },
-  { label: 'Methodology', href: `${BASE}methodology/` },
-];

data/site/src/layouts/Layout.astro

@@ -1,85 +0,0 @@
----
-import '@fontsource/ibm-plex-sans/400.css';
-import '@fontsource/ibm-plex-sans/500.css';
-import '@fontsource/ibm-plex-sans/600.css';
-import '@fontsource/ibm-plex-mono/400.css';
-import '@fontsource/ibm-plex-mono/500.css';
-import '../styles/global.css';
-import { SITE, NAV, BASE } from '../config';
-
-interface Props {
-  title: string;
-  description?: string;
-}
-
-const { title, description = 'Cross-platform benchmarks of Ruby serialization libraries — XML, JSON, YAML, TOML.' } = Astro.props;
----
-
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>{title}</title>
-    <meta name="description" content={description} />
-    <link rel="icon" type="image/svg+xml" href={`${BASE}favicon.svg`} />
-    <script is:inline>
-      const stored = localStorage.getItem('serialbench-theme');
-      const theme = stored ?? 'dark';
-      document.documentElement.dataset.theme = theme;
-    </script>
-  </head>
-  <body class="min-h-screen flex flex-col">
-    <header class="border-b border-line">
-      <div class="mx-auto max-w-6xl px-4 sm:px-6 min-h-14 py-2 flex flex-wrap items-center justify-between gap-x-4 gap-y-1">
-        <a href={BASE} class="flex items-center gap-3 group">
-          <span class="font-mono text-[11px] uppercase tracking-[0.14em] border border-line px-2 py-1 text-inkdim group-hover:border-phosphor group-hover:text-phosphor transition-colors">
-            {SITE.name}
-          </span>
-          <span class="hidden md:inline font-mono text-[11px] uppercase tracking-[0.14em] text-inkmute">
-            {SITE.tagline}
-          </span>
-        </a>
-        <nav class="flex items-center gap-0.5 sm:gap-1 font-mono text-[11px] uppercase tracking-[0.14em]">
-          <a href={NAV[0].href} class="px-2 py-1 text-inkdim hover:text-phosphor transition-colors">{NAV[0].label}</a>
-          <a href={NAV[1].href} class="px-2 py-1 text-inkdim hover:text-phosphor transition-colors">{NAV[1].label}</a>
-          <button
-            id="theme-toggle"
-            type="button"
-            class="px-2 py-1 text-inkdim hover:text-phosphor transition-colors"
-            aria-label="Toggle light and dark theme"
-          >
-            <span data-theme-label>Light</span>
-          </button>
-        </nav>
-      </div>
-    </header>
-
-    <main class="flex-1 mx-auto w-full max-w-6xl px-4 sm:px-6 py-8">
-      <slot />
-    </main>
-
-    <footer class="border-t border-line">
-      <div class="mx-auto max-w-6xl px-4 sm:px-6 py-6 flex flex-wrap items-center justify-between gap-3 font-mono text-[11px] uppercase tracking-[0.14em] text-inkmute">
-        <span>{SITE.footer}</span>
-        <span>{SITE.disclaimer}</span>
-      </div>
-    </footer>
-
-    <script is:inline>
-      const button = document.getElementById('theme-toggle');
-      const label = button?.querySelector('[data-theme-label]');
-      const sync = () => {
-        if (!label) return;
-        label.textContent = document.documentElement.dataset.theme === 'light' ? 'Dark' : 'Light';
-      };
-      sync();
-      button?.addEventListener('click', () => {
-        const next = document.documentElement.dataset.theme === 'light' ? 'dark' : 'light';
-        document.documentElement.dataset.theme = next;
-        localStorage.setItem('serialbench-theme', next);
-        sync();
-      });
-    </script>
-  </body>
-</html>

data/site/src/lib/channels.ts

@@ -1,24 +0,0 @@
-// Channel assignment: every serializer keeps one color everywhere on the site
-// (bars, chart strokes, availability dots), like scope channels on a bench
-// instrument. Single source of truth — components import from here.
-export const CHANNELS: Record<string, string> = {
-  leptris: '#5fd4e8',
-  nokogiri: '#f5a623',
-  ox: '#e85d9e',
-  oga: '#9b8cff',
-  rexml: '#77879e',
-  'libxml-ruby': '#d97b4a',
-  oj: '#6ee7a0',
-  json: '#b8c4d0',
-  rapidjson: '#7be0d3',
-  yajl: '#e8c56a',
-  psych: '#c9a0dc',
-  syck: '#8c7ae0',
-  'toml-rb': '#e88b6a',
-  tomlib: '#6ab0e8',
-  tomlrb: '#d4e87b',
-};
-
-export function channelColor(serializer: string): string {
-  return CHANNELS[serializer] ?? '#8fa3bf';
-}

data/site/src/lib/dashboard.ts

@@ -1,269 +0,0 @@
-// Typed access to the dashboard payload produced by the Ruby CLI
-// (`serialbench resultset export-data` — same shape the old Liquid site
-// consumed): combined_results[op][size][format][serializer][envKey].
-
-export interface PerfMetric {
-  iterations_per_second: number;
-  time_per_iteration: number;
-}
-
-export interface MemoryMetric {
-  allocated_memory: number;
-  retained_memory: number;
-}
-
-export interface Environment {
-  ruby_version: string;
-  ruby_platform?: string;
-  os: string;
-  arch: string;
-  timestamp: string;
-  source_file?: string;
-}
-
-export interface Payload {
-  combined_results: Record<string, Record<string, Record<string, Record<string, Record<string, PerfMetric | MemoryMetric>>>>>;
-  environments: Record<string, Environment>;
-  metadata: {
-    resultset_name?: string;
-    resultset_description?: string;
-    total_runs?: number;
-    generated_at: string;
-  };
-  libraries?: LibraryInfo[];
-}
-
-export const OPERATIONS = ['parsing', 'generation', 'streaming'] as const;
-export type Operation = (typeof OPERATIONS)[number];
-
-export const OPERATION_LABELS: Record<Operation, string> = {
-  parsing: 'Parse',
-  generation: 'Generate',
-  streaming: 'Stream',
-};
-
-export type Size = 'small' | 'medium' | 'large';
-
-export interface LeaderRow {
-  serializer: string;
-  ips: number;
-  msPerIteration: number;
-  ratioToRef: number | null;
-}
-
-function metricsFor(payload: Payload, op: string, size: string, format: string): Record<string, Record<string, PerfMetric>> {
-  const byFormat = payload.combined_results[op]?.[size]?.[format] ?? {};
-  return byFormat as Record<string, Record<string, PerfMetric>>;
-}
-
-const FORMAT_ORDER = ['xml', 'json', 'yaml', 'toml'];
-
-export function availableFormats(payload: Payload): string[] {
-  const formats = new Set<string>();
-  for (const sizes of Object.values(payload.combined_results.parsing ?? {})) {
-    for (const format of Object.keys(sizes)) formats.add(format);
-  }
-  return [...formats].sort((a, b) => {
-    const ia = FORMAT_ORDER.indexOf(a);
-    const ib = FORMAT_ORDER.indexOf(b);
-    return (ia === -1 ? FORMAT_ORDER.length : ia) - (ib === -1 ? FORMAT_ORDER.length : ib);
-  });
-}
-
-export function availableOperations(payload: Payload, format: string): Operation[] {
-  return OPERATIONS.filter((op) => {
-    const sizes = payload.combined_results[op];
-    if (!sizes) return false;
-    return Object.values(sizes).some((byFormat) => format in byFormat);
-  });
-}
-
-export function availableSizes(payload: Payload, op: string, format: string): string[] {
-  const sizes = payload.combined_results[op];
-  if (!sizes) return [];
-  return Object.keys(sizes).filter((size) => {
-    const byFormat = sizes[size];
-    return byFormat != null && format in byFormat && Object.keys(byFormat[format]).length > 0;
-  });
-}
-
-export function environmentList(payload: Payload): { key: string; env: Environment }[] {
-  return Object.entries(payload.environments)
-    .map(([key, env]) => ({ key, env }))
-    .sort((a, b) => b.env.timestamp.localeCompare(a.env.timestamp));
-}
-
-// Env keys are runner-shaped ("macos-26-intel-ruby-3.4") when produced by CI,
-// or "macos-arm64-ruby-3.4" (os-arch) for docker/local/legacy results.
-export function environmentLabel(key: string, env: Environment): string {
-  const arch = env.arch === 'x86_64' ? 'x64' : env.arch;
-  const runner = key.replace(/-ruby-[^-]*$/, '');
-  const m = runner.match(/^(ubuntu|macos|windows)-(\d+(?:\.\d+)?)(?:-(arm|intel|large))?$/);
-  if (m) {
-    const osName = m[1].replace('ubuntu', 'Ubuntu').replace('windows', 'Windows').replace('macos', 'macOS');
-    const variant = m[3] === 'intel' ? ' Intel' : '';
-    return `${osName} ${m[2]}${variant} · ${arch} · Ruby ${env.ruby_version}`;
-  }
-  const osName = env.os.replace('ubuntu', 'Ubuntu').replace('windows', 'Windows').replace('macos', 'macOS');
-  return `${osName} · ${arch} · Ruby ${env.ruby_version}`;
-}
-
-// Short runner label for table headers: "macos-26-intel-ruby-3.4" → "macOS 26 Intel"
-export function runnerShortLabel(key: string, env: Environment): string {
-  const runner = key.replace(/-ruby-[^-]*$/, '');
-  const m = runner.match(/^(ubuntu|macos|windows)-(\d+(?:\.\d+)?)(?:-(arm|intel|large))?$/);
-  if (m) {
-    const osName = m[1].replace('ubuntu', 'Ubuntu').replace('windows', 'Windows').replace('macos', 'macOS');
-    return `${osName} ${m[2]}${m[3] === 'intel' ? ' Intel' : ''}`;
-  }
-  return runner || env.os;
-}
-
-export function serializersFor(payload: Payload, format: string): string[] {
-  const serializers = new Set<string>();
-  for (const sizes of Object.values(payload.combined_results.parsing ?? {})) {
-    if (format in sizes) Object.keys(sizes[format]).forEach((s) => serializers.add(s));
-  }
-  for (const sizes of Object.values(payload.combined_results.generation ?? {})) {
-    if (format in sizes) Object.keys(sizes[format]).forEach((s) => serializers.add(s));
-  }
-  return [...serializers].sort();
-}
-
-/** Ranking at one operation/size/env; ratios computed against `reference`. */
-export function leaderboard(payload: Payload, op: string, size: string, format: string, envKey: string, reference: string | null): LeaderRow[] {
-  const bySerializer = metricsFor(payload, op, size, format);
-  const rows: LeaderRow[] = [];
-  for (const [serializer, byEnv] of Object.entries(bySerializer)) {
-    const metric = byEnv[envKey];
-    if (!metric || metric.iterations_per_second == null) continue;
-    rows.push({
-      serializer,
-      ips: metric.iterations_per_second,
-      msPerIteration: metric.time_per_iteration * 1000,
-      ratioToRef: null,
-    });
-  }
-  rows.sort((a, b) => b.ips - a.ips);
-  const ref = rows.find((r) => r.serializer === reference) ?? rows[0];
-  if (ref) {
-    for (const row of rows) row.ratioToRef = row.ips > 0 ? ref.ips / row.ips : null;
-  }
-  return rows;
-}
-
-export interface MemoryRow {
-  serializer: string;
-  allocated: number;
-  retained: number;
-}
-
-export function memoryRows(payload: Payload, size: string, format: string, envKey: string): MemoryRow[] {
-  const bySerializer = metricsFor(payload, 'memory', size, format);
-  const rows: MemoryRow[] = [];
-  for (const [serializer, byEnv] of Object.entries(bySerializer)) {
-    const metric = byEnv[envKey] as MemoryMetric | undefined;
-    if (!metric || metric.allocated_memory == null) continue;
-    rows.push({ serializer, allocated: metric.allocated_memory, retained: metric.retained_memory });
-  }
-  return rows.sort((a, b) => a.allocated - b.allocated);
-}
-
-/** serializer × env coverage — "will it run on my stack", derived from the data itself. */
-export function availability(payload: Payload): { serializers: string[]; envKeys: string[]; cells: Map<string, Set<string>> } {
-  const serializers = new Set<string>();
-  const cells = new Map<string, Set<string>>();
-  for (const [op, sizes] of Object.entries(payload.combined_results)) {
-    if (op === 'memory') continue;
-    for (const byFormat of Object.values(sizes)) {
-      for (const bySerializer of Object.values(byFormat)) {
-        for (const [serializer, byEnv] of Object.entries(bySerializer)) {
-          serializers.add(serializer);
-          if (!cells.has(serializer)) cells.set(serializer, new Set());
-          for (const envKey of Object.keys(byEnv)) cells.get(serializer)!.add(envKey);
-        }
-      }
-    }
-  }
-  const envKeys = Object.keys(payload.environments);
-  return { serializers: [...serializers].sort(), envKeys, cells };
-}
-
-export function formatIps(ips: number): string {
-  if (ips >= 1000) return `${(ips / 1000).toFixed(ips >= 10000 ? 0 : 1)}k`;
-  if (ips >= 100) return ips.toFixed(0);
-  if (ips >= 10) return ips.toFixed(1);
-  return ips.toFixed(2);
-}
-
-export function formatMemory(mb: number): string {
-  if (mb >= 1000) return `${(mb / 1000).toFixed(2)} GB`;
-  if (mb >= 1) return `${mb.toFixed(1)} MB`;
-  return `${(mb * 1024).toFixed(0)} KB`;
-}
-
-export function primaryEnvKey(payload: Payload): string {
-  return environmentList(payload)[0]?.key ?? '';
-}
-
-export interface LibraryStat {
-  op: string;
-  size: string;
-  ips: number;
-  rank: number;
-  fieldSize: number;
-  bestSerializer: string;
-  ratioToBest: number | null;
-}
-
-/** All measured stats for one serializer on the primary environment. */
-export function libraryStats(payload: Payload, serializer: string, envKey: string): LibraryStat[] {
-  const stats: LibraryStat[] = [];
-  for (const [op, sizes] of Object.entries(payload.combined_results)) {
-    if (op === 'memory') continue;
-    for (const [size, formats] of Object.entries(sizes)) {
-      for (const bySerializer of Object.values(formats)) {
-        if (!(serializer in bySerializer)) continue;
-        const metric = bySerializer[serializer][envKey] as PerfMetric | undefined;
-        if (!metric || metric.iterations_per_second == null) continue;
-        const best = Object.entries(bySerializer)
-          .map(([name, byEnv]) => ({ name, ips: (byEnv[envKey] as PerfMetric | undefined)?.iterations_per_second ?? 0 }))
-          .sort((a, b) => b.ips - a.ips);
-        const ips = metric.iterations_per_second;
-        stats.push({
-          op,
-          size,
-          ips,
-          rank: best.findIndex((b) => b.name === serializer) + 1,
-          fieldSize: best.length,
-          bestSerializer: best[0].name,
-          ratioToBest: best[0].ips > 0 ? best[0].ips / ips : null,
-        });
-      }
-    }
-  }
-  return stats;
-}
-
-/** Formats a serializer participated in. */
-export function formatsForSerializer(payload: Payload, serializer: string): string[] {
-  const formats = new Set<string>();
-  for (const sizes of Object.values(payload.combined_results.parsing ?? {})) {
-    for (const [format, bySerializer] of Object.entries(sizes)) {
-      if (serializer in bySerializer) formats.add(format);
-    }
-  }
-  for (const sizes of Object.values(payload.combined_results.generation ?? {})) {
-    for (const [format, bySerializer] of Object.entries(sizes)) {
-      if (serializer in bySerializer) formats.add(format);
-    }
-  }
-  return [...formats].sort();
-}
-
-export interface LibraryInfo {
-  name: string;
-  format: string;
-  version: string;
-  features: Record<string, boolean>;
-}