From 8ad65be847712e90b5480fa9e7c67a033f32209c Mon Sep 17 00:00:00 2001
From: Florent Tapponnier <160007691+Flotapponnier@users.noreply.github.com>
Date: Wed, 29 Jul 2026 12:51:33 +0200
Subject: [PATCH] =?UTF-8?q?restore:=20reports=20pages/nav/sitemap=20droppe?=
 =?UTF-8?q?d=20in=20dev=E2=86=90main=20sync?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/app/reports/[category]/[slug]/page.tsx    | 432 ++++++++++++++++++
 src/app/reports/[category]/page.tsx           | 119 +++++
 src/app/reports/[category]/rss.xml/route.ts   |  71 +++
 src/app/reports/page.tsx                      | 146 ++++++
 src/app/reports/rss.xml/route.ts              |  66 +++
 src/components/reports/region-winners.tsx     | 155 +++++++
 src/components/reports/report-card.tsx        | 119 +++++
 src/components/reports/stat-table.tsx         | 167 +++++++
 src/components/site-footer.tsx                |   1 +
 src/components/site-header.tsx                |   5 +
 .../rpc/2026-08-state-of-public-rpc.mdx       | 200 ++++++++
 src/lib/reports/loader.ts                     | 105 +++++
 src/lib/sitemap-builder.ts                    |  34 ++
 13 files changed, 1620 insertions(+)
 create mode 100644 src/app/reports/[category]/[slug]/page.tsx
 create mode 100644 src/app/reports/[category]/page.tsx
 create mode 100644 src/app/reports/[category]/rss.xml/route.ts
 create mode 100644 src/app/reports/page.tsx
 create mode 100644 src/app/reports/rss.xml/route.ts
 create mode 100644 src/components/reports/region-winners.tsx
 create mode 100644 src/components/reports/report-card.tsx
 create mode 100644 src/components/reports/stat-table.tsx
 create mode 100644 src/content/reports/rpc/2026-08-state-of-public-rpc.mdx
 create mode 100644 src/lib/reports/loader.ts

diff --git a/src/app/reports/[category]/[slug]/page.tsx b/src/app/reports/[category]/[slug]/page.tsx
new file mode 100644
index 00000000..e6c21e83
--- /dev/null
+++ b/src/app/reports/[category]/[slug]/page.tsx
@@ -0,0 +1,432 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import Link from "next/link";
+import { MDXRemote } from "next-mdx-remote/rsc";
+import remarkGfm from "remark-gfm";
+import { StatTable } from "@/components/reports/stat-table";
+import { RegionWinners } from "@/components/reports/region-winners";
+import {
+  getAllReports,
+  getReport,
+  REPORT_CATEGORY_META,
+} from "@/lib/reports/loader";
+import { safeJsonLd } from "@/lib/jsonld";
+import { PERSON_ID } from "@/lib/hub-jsonld";
+import { SITE } from "@/data/site";
+
+export const revalidate = 3600;
+
+const SERIF: React.CSSProperties = { fontFamily: "var(--font-serif)" };
+
+type Props = { params: Promise<{ category: string; slug: string }> };
+
+export async function generateStaticParams() {
+  const reports = getAllReports();
+  return reports.map((r) => ({ category: r.categorySlug, slug: r.slug }));
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { category, slug } = await params;
+  const report = getReport(category, slug);
+  if (!report) return {};
+
+  const canonical = `${SITE.url}/reports/${category}/${slug}`;
+  const ogImage = report.ogImage ?? `${SITE.url}/opengraph-image`;
+  const social = `${report.title} · OpenChainBench`;
+
+  return {
+    title: report.title,
+    description: report.summary,
+    alternates: { canonical },
+    openGraph: {
+      title: social,
+      description: report.summary,
+      url: canonical,
+      type: "article",
+      siteName: "OpenChainBench",
+      publishedTime: new Date(report.publishedAt).toISOString(),
+      authors: [report.author],
+      images: [{ url: ogImage, width: 1200, height: 630 }],
+    },
+    twitter: {
+      card: "summary_large_image",
+      title: social,
+      description: report.summary,
+      site: "@OpenChainBench",
+      images: [ogImage],
+    },
+  };
+}
+
+function slugify(text: string): string {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+
+const MDX_COMPONENTS = {
+  StatTable,
+  RegionWinners,
+
+  // Table of contents — pipe-separated section names, auto-generates anchor hrefs
+  TOC: ({ sections }: { sections: string }) => {
+    const items = sections.split("|").map((s) => s.trim());
+    return (
+      <nav className="my-8 border border-ink/20 not-prose">
+        <div className="px-5 py-3 border-b border-ink/10 bg-[var(--color-paper-soft)]">
+          <p className="label-mono text-[10px] uppercase tracking-[0.22em] text-ink">In this report</p>
+        </div>
+        <ol className="divide-y divide-ink/[0.06]">
+          {items.map((label, i) => (
+            <li key={i}>
+              <a
+                href={`#${slugify(label)}`}
+                className="flex items-center gap-4 px-5 py-2.5 text-[13px] text-ink-soft hover:text-ink hover:bg-[var(--color-paper-soft)] transition-colors no-underline"
+              >
+                <span className="label-mono text-[10px] text-ink-faint w-5 shrink-0 tabular-nums">
+                  {String(i + 1).padStart(2, "0")}
+                </span>
+                {label}
+              </a>
+            </li>
+          ))}
+        </ol>
+      </nav>
+    );
+  },
+
+  // Summary box — key findings list at article top
+  Summary: ({ children }: { children: React.ReactNode }) => (
+    <aside className="my-8 border border-ink/20 bg-[var(--color-paper-soft)] [&_ul]:mt-0 [&_ul]:space-y-2 [&_li]:text-[14px] [&_li]:leading-[1.6] [&_li]:text-ink-soft">
+      <div className="px-5 py-3 border-b border-ink/10">
+        <p className="label-mono text-[10px] uppercase tracking-[0.22em] text-ink">Key findings</p>
+      </div>
+      <div className="px-5 py-4">{children}</div>
+    </aside>
+  ),
+
+  // Orange highlighter on key sentences
+  Mark: ({ children }: { children: React.ReactNode }) => (
+    <span
+      className="font-semibold text-ink"
+      style={{ background: "linear-gradient(transparent 55%, rgba(251,146,60,0.32) 55%)" }}
+    >
+      {children}
+    </span>
+  ),
+
+  // Decision Framework card — used explicitly in MDX
+  UseCase: ({ label, children }: { label: string; children: React.ReactNode }) => (
+    <div className="mt-4 border border-rule hover:border-ink/50 transition-colors p-5">
+      <p className="label-mono text-[10px] uppercase tracking-[0.2em] text-ink mb-1">
+        {label}
+      </p>
+      <div className="[&_p]:mt-2 [&_p]:text-[16px] [&_p]:leading-[1.72]">
+        {children}
+      </div>
+    </div>
+  ),
+
+  // Economist-style section header with scroll-target ID for TOC anchors
+  h2: (props: React.HTMLAttributes<HTMLHeadingElement>) => {
+    const text = typeof props.children === "string" ? props.children : "";
+    return (
+      <div id={slugify(text)} className="mt-16 mb-8 border-t-[2px] border-ink pt-5 scroll-mt-6">
+        <h2 className="label-mono text-[10px] uppercase tracking-[0.22em] text-ink">
+          {props.children}
+        </h2>
+      </div>
+    );
+  },
+
+  h3: (props: React.HTMLAttributes<HTMLHeadingElement>) => (
+    <h3
+      className="display mt-10 mb-3 text-xl sm:text-2xl tracking-tight text-ink"
+      {...props}
+    />
+  ),
+
+  p: (props: React.HTMLAttributes<HTMLParagraphElement>) => (
+    <p
+      className="mt-5 text-[17px] leading-[1.8] text-ink-soft"
+      style={SERIF}
+      {...props}
+    />
+  ),
+
+  ul: (props: React.HTMLAttributes<HTMLUListElement>) => (
+    <ul
+      className="mt-5 space-y-2 pl-6 list-disc text-[17px] leading-[1.8] text-ink-soft"
+      style={SERIF}
+      {...props}
+    />
+  ),
+
+  ol: (props: React.HTMLAttributes<HTMLOListElement>) => (
+    <ol
+      className="mt-5 space-y-2 pl-6 list-decimal text-[17px] leading-[1.8] text-ink-soft"
+      style={SERIF}
+      {...props}
+    />
+  ),
+
+  li: (props: React.HTMLAttributes<HTMLLIElement>) => (
+    <li className="pl-1" {...props} />
+  ),
+
+  // Full-bleed pull quote
+  blockquote: (props: React.HTMLAttributes<HTMLElement>) => (
+    <blockquote
+      className="my-10 border-y-2 border-ink py-7 text-center [&_p]:mt-0 [&_p]:text-xl [&_p]:sm:text-2xl [&_p]:leading-snug [&_p]:text-ink [&_p]:italic"
+      style={SERIF}
+      {...props}
+    />
+  ),
+
+  // Inline code — pill style
+  code: (props: React.HTMLAttributes<HTMLElement>) => (
+    <code
+      className="label-mono text-[0.85em] bg-[var(--color-paper-soft)] border border-rule px-1.5 py-0.5"
+      {...props}
+    />
+  ),
+
+  // Terminal window with decorative chrome
+  pre: (props: React.HTMLAttributes<HTMLPreElement>) => (
+    <div className="my-8 border border-rule overflow-hidden">
+      <div className="flex items-center gap-3 px-4 py-2.5 border-b border-rule bg-[var(--color-paper-soft)]">
+        <span className="flex gap-1.5 shrink-0">
+          <span className="w-2.5 h-2.5 rounded-full bg-ink-faint/25" />
+          <span className="w-2.5 h-2.5 rounded-full bg-ink-faint/25" />
+          <span className="w-2.5 h-2.5 rounded-full bg-ink-faint/25" />
+        </span>
+        <span className="label-mono text-[10px] uppercase tracking-[0.18em] text-ink-faint">
+          Terminal
+        </span>
+      </div>
+      <pre
+        className="overflow-x-auto bg-ink text-paper px-5 py-5 text-[13px] label-mono leading-[1.7] [&_code]:bg-transparent [&_code]:border-0 [&_code]:p-0"
+        {...props}
+      />
+    </div>
+  ),
+
+  a: (props: React.AnchorHTMLAttributes<HTMLAnchorElement>) => (
+    <a className="lnk" {...props} />
+  ),
+
+  strong: (props: React.HTMLAttributes<HTMLElement>) => (
+    <strong className="font-semibold text-ink" {...props} />
+  ),
+
+  hr: () => <div className="my-12 h-px bg-rule" />,
+
+  table: (props: React.HTMLAttributes<HTMLTableElement>) => (
+    <div className="my-8 overflow-x-auto">
+      <table className="w-full text-[13px] label-mono border border-rule" {...props} />
+    </div>
+  ),
+
+  thead: (props: React.HTMLAttributes<HTMLTableSectionElement>) => (
+    <thead className="bg-[var(--color-paper-soft)] border-b border-rule" {...props} />
+  ),
+
+  tbody: (props: React.HTMLAttributes<HTMLTableSectionElement>) => (
+    <tbody className="divide-y divide-rule" {...props} />
+  ),
+
+  tr: (props: React.HTMLAttributes<HTMLTableRowElement>) => (
+    <tr className="hover:bg-[var(--color-paper-soft)] transition-colors" {...props} />
+  ),
+
+  th: (props: React.ThHTMLAttributes<HTMLTableCellElement>) => (
+    <th
+      className="px-4 py-2.5 text-left text-[10px] uppercase tracking-[0.18em] text-ink-faint font-normal"
+      {...props}
+    />
+  ),
+
+  td: (props: React.TdHTMLAttributes<HTMLTableCellElement>) => (
+    <td className="px-4 py-2.5 text-ink-soft tabular-nums" {...props} />
+  ),
+};
+
+function reportJsonLd(report: ReturnType<typeof getReport>) {
+  if (!report) return [];
+  const url = `${SITE.url}/reports/${report.categorySlug}/${report.slug}`;
+  const catMeta = REPORT_CATEGORY_META[report.categorySlug];
+
+  return [
+    {
+      "@context": "https://schema.org",
+      "@type": "Article",
+      "@id": `${url}#article`,
+      url,
+      headline: report.title,
+      description: report.summary,
+      datePublished: new Date(report.publishedAt).toISOString(),
+      dateModified: new Date(report.publishedAt).toISOString(),
+      image: report.ogImage ?? `${SITE.url}/opengraph-image`,
+      author: { "@id": PERSON_ID },
+      publisher: { "@id": `${SITE.url}/#org` },
+      inLanguage: "en",
+      license: "https://creativecommons.org/licenses/by/4.0/",
+      isPartOf: { "@id": `${SITE.url}/reports/${report.categorySlug}#series` },
+    },
+    {
+      "@context": "https://schema.org",
+      "@type": "BreadcrumbList",
+      itemListElement: [
+        { "@type": "ListItem", position: 1, name: "Home", item: `${SITE.url}/` },
+        { "@type": "ListItem", position: 2, name: "Reports", item: `${SITE.url}/reports` },
+        {
+          "@type": "ListItem",
+          position: 3,
+          name: catMeta?.label ?? report.categorySlug,
+          item: `${SITE.url}/reports/${report.categorySlug}`,
+        },
+        { "@type": "ListItem", position: 4, name: report.title, item: url },
+      ],
+    },
+  ];
+}
+
+export default async function ReportPage({ params }: Props) {
+  const { category, slug } = await params;
+  const report = getReport(category, slug);
+  if (!report) notFound();
+
+  const catMeta = REPORT_CATEGORY_META[category];
+  const lds = reportJsonLd(report);
+
+  return (
+    <article className="mx-auto max-w-[760px] px-4 sm:px-6 py-8 sm:py-14">
+      {lds.map((ld, i) => (
+        <script
+          key={i}
+          type="application/ld+json"
+          // biome-ignore lint/security/noDangerouslySetInnerHtml: serialized via safeJsonLd
+          dangerouslySetInnerHTML={{ __html: safeJsonLd(ld) }}
+        />
+      ))}
+
+      {/* Breadcrumb */}
+      <nav className="mb-8 flex items-center gap-2 label-mono text-[11px] text-ink-muted">
+        <Link href="/reports" className="hover:text-ink transition-colors">
+          Reports
+        </Link>
+        <span>/</span>
+        <Link
+          href={`/reports/${category}`}
+          className="hover:text-ink transition-colors"
+        >
+          {catMeta?.label ?? category}
+        </Link>
+        <span>/</span>
+        <span className="text-ink truncate max-w-[200px]">{report.period}</span>
+      </nav>
+
+      {/* Hero */}
+      <header>
+        <div className="flex items-center gap-2 mb-5">
+          <span className="label-mono text-[10px] border border-ink px-2 py-0.5 text-ink uppercase tracking-[0.12em]">
+            {catMeta?.label ?? category}
+          </span>
+          <span className="label-mono text-[10px] text-ink-faint">
+            {report.period}
+          </span>
+        </div>
+
+        <h1 className="display text-4xl sm:text-5xl tracking-tight leading-[1.05]">
+          {report.title}
+        </h1>
+
+        <p
+          className="mt-5 text-lg sm:text-xl leading-relaxed text-ink-soft"
+          style={SERIF}
+        >
+          {report.summary}
+        </p>
+
+        {/* Key finding — visual centerpiece, full-bleed within article */}
+        <div className="-mx-4 sm:-mx-6 mt-8 border-y-2 border-ink px-4 sm:px-6 py-10">
+          <p className="label-mono text-[10px] uppercase tracking-[0.22em] text-ink-muted text-center mb-5">
+            Key finding
+          </p>
+          <p className="display text-2xl sm:text-[2rem] leading-[1.15] text-ink text-center max-w-[580px] mx-auto font-bold tracking-tight">
+            {report.heroFinding}
+          </p>
+        </div>
+
+        {/* Byline */}
+        <div className="mt-6 flex flex-wrap items-center gap-x-6 gap-y-2 text-[12px] label-mono text-ink-muted border-b border-rule pb-2">
+          <span>
+            By{" "}
+            <Link href="/team" className="lnk">
+              {report.author}
+            </Link>
+          </span>
+          <time dateTime={report.publishedAt}>
+            {new Date(report.publishedAt).toLocaleDateString("en-US", {
+              year: "numeric",
+              month: "long",
+              day: "numeric",
+              timeZone: "UTC",
+            })}
+          </time>
+          <span>{report.readingTime} min read</span>
+        </div>
+      </header>
+
+      {/* Body */}
+      <div className="mt-2">
+        {/* eslint-disable-next-line @typescript-eslint/no-explicit-any */}
+        <MDXRemote
+          source={report.content}
+          components={MDX_COMPONENTS as any}
+          options={{ mdxOptions: { remarkPlugins: [remarkGfm] } }}
+        />
+      </div>
+
+      {/* Footer */}
+      <div className="mt-16 border-t-[2px] border-ink pt-5 flex items-center justify-between gap-4">
+        <span className="label-mono text-[10px] uppercase tracking-[0.18em] text-ink-muted">
+          Filed under
+        </span>
+        <div className="flex flex-wrap gap-2">
+          <Link
+            href={`/reports/${category}`}
+            className="label-mono text-[11px] border border-rule px-2 py-1 text-ink-muted hover:text-ink hover:border-ink transition-colors"
+          >
+            {catMeta?.label ?? category}
+          </Link>
+          <Link
+            href="/reports"
+            className="label-mono text-[11px] border border-rule px-2 py-1 text-ink-muted hover:text-ink hover:border-ink transition-colors"
+          >
+            All reports
+          </Link>
+        </div>
+      </div>
+
+      {/* Citation */}
+      <div className="mt-8 border border-rule p-6 bg-[var(--color-paper-soft)]">
+        <p className="label-mono text-[10px] uppercase tracking-[0.18em] text-ink-muted mb-3">
+          Cite this report
+        </p>
+        <p className="text-sm text-ink-muted leading-relaxed">
+          OpenChainBench Research. <em>{report.title}</em>. OpenChainBench,{" "}
+          {new Date(report.publishedAt).toLocaleDateString("en-US", {
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            timeZone: "UTC",
+          })}
+          .{" "}
+          <a className="lnk" href={report.canonical}>
+            {report.canonical}
+          </a>
+          . Licensed under CC BY 4.0.
+        </p>
+      </div>
+    </article>
+  );
+}
diff --git a/src/app/reports/[category]/page.tsx b/src/app/reports/[category]/page.tsx
new file mode 100644
index 00000000..3c51de09
--- /dev/null
+++ b/src/app/reports/[category]/page.tsx
@@ -0,0 +1,119 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import Link from "next/link";
+import { SectionRule } from "@/components/section-rule";
+import { ReportCard } from "@/components/reports/report-card";
+import {
+  getAllReportCategories,
+  getReportsByCategory,
+  REPORT_CATEGORY_META,
+} from "@/lib/reports/loader";
+import { pageMetadata } from "@/lib/page-metadata";
+import { safeJsonLd, buildBreadcrumbJsonLd } from "@/lib/jsonld";
+import { SITE } from "@/data/site";
+
+type Props = { params: Promise<{ category: string }> };
+
+export async function generateStaticParams() {
+  return getAllReportCategories().map((category) => ({ category }));
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { category } = await params;
+  const meta = REPORT_CATEGORY_META[category];
+  if (!meta) return {};
+  return pageMetadata({
+    path: `/reports/${category}`,
+    title: `${meta.label} Reports`,
+    description: meta.description,
+  });
+}
+
+export default async function CategoryPage({ params }: Props) {
+  const { category } = await params;
+  const meta = REPORT_CATEGORY_META[category];
+  if (!meta) notFound();
+
+  const reports = getReportsByCategory(category);
+  const pageUrl = `${SITE.url}/reports/${category}`;
+
+  const breadcrumbLd = {
+    "@context": "https://schema.org",
+    ...buildBreadcrumbJsonLd([
+      { name: "Home", item: SITE.url },
+      { name: "Reports", item: `${SITE.url}/reports` },
+      { name: `${meta.label} Reports`, item: pageUrl },
+    ]),
+  };
+
+  const collectionLd = {
+    "@context": "https://schema.org",
+    "@type": "CollectionPage",
+    "@id": `${pageUrl}#collection`,
+    name: `${meta.label} Reports`,
+    description: meta.description,
+    url: pageUrl,
+    numberOfItems: reports.length,
+    hasPart: reports.map((r) => ({
+      "@type": "Article",
+      name: r.title,
+      url: `${SITE.url}/reports/${category}/${r.slug}`,
+      datePublished: r.publishedAt,
+      description: r.summary,
+    })),
+  };
+
+  return (
+    <div className="mx-auto max-w-[1400px] px-4 sm:px-6 lg:px-8 py-8 sm:py-12">
+      <script
+        type="application/ld+json"
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: serialized via safeJsonLd
+        dangerouslySetInnerHTML={{ __html: safeJsonLd(breadcrumbLd) }}
+      />
+      <script
+        type="application/ld+json"
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: serialized via safeJsonLd
+        dangerouslySetInnerHTML={{ __html: safeJsonLd(collectionLd) }}
+      />
+      <nav className="mb-6 flex items-center gap-2 label-mono text-[11px] text-ink-muted">
+        <Link href="/reports" className="hover:text-ink transition-colors">
+          Reports
+        </Link>
+        <span>/</span>
+        <span className="text-ink">{meta.label}</span>
+      </nav>
+
+      <header className="border-b-2 border-ink pb-6 max-w-3xl">
+        <h1 className="display text-3xl sm:text-4xl tracking-tight">
+          {meta.label} Reports
+        </h1>
+        <p className="mt-3 text-base sm:text-lg text-ink-soft leading-snug max-w-2xl">
+          {meta.description}
+        </p>
+        <div className="mt-4">
+          <a
+            href={`/reports/${category}/rss.xml`}
+            className="label-mono text-[11px] border border-rule px-2 py-1 text-ink-muted hover:text-ink hover:border-ink transition-colors"
+          >
+            RSS feed
+          </a>
+        </div>
+      </header>
+
+      {reports.length === 0 ? (
+        <div className="mt-14 text-ink-muted text-base">
+          No {meta.label} reports published yet. Check back soon.
+        </div>
+      ) : (
+        <>
+          <SectionRule label={`${meta.label} reports`} number="i" />
+          <div className="grid gap-6 sm:grid-cols-2 lg:grid-cols-3">
+            {reports.map((r) => (
+              <ReportCard key={r.slug} report={r} />
+            ))}
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/src/app/reports/[category]/rss.xml/route.ts b/src/app/reports/[category]/rss.xml/route.ts
new file mode 100644
index 00000000..595deafb
--- /dev/null
+++ b/src/app/reports/[category]/rss.xml/route.ts
@@ -0,0 +1,71 @@
+import { NextResponse } from "next/server";
+import { getReportsByCategory, REPORT_CATEGORY_META } from "@/lib/reports/loader";
+import { SITE } from "@/data/site";
+
+export const revalidate = 3600;
+
+function escapeXml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function toRfc822(d: Date): string {
+  return d.toUTCString().replace("GMT", "+0000");
+}
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ category: string }> },
+) {
+  const { category } = await params;
+  const catMeta = REPORT_CATEGORY_META[category];
+  const reports = getReportsByCategory(category);
+  const self = `${SITE.url}/reports/${category}/rss.xml`;
+  const title = catMeta
+    ? `OpenChainBench ${catMeta.label} Reports`
+    : `OpenChainBench ${category} Reports`;
+  const description = catMeta?.description ?? `OpenChainBench reports on ${category}.`;
+
+  const lines: string[] = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push('<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">');
+  lines.push("  <channel>");
+  lines.push(`    <title>${escapeXml(title)}</title>`);
+  lines.push(`    <link>${SITE.url}/reports/${category}</link>`);
+  lines.push(`    <description>${escapeXml(description)}</description>`);
+  lines.push("    <language>en</language>");
+  lines.push(`    <lastBuildDate>${toRfc822(new Date())}</lastBuildDate>`);
+  lines.push(
+    `    <atom:link href="${self}" rel="self" type="application/rss+xml" />`,
+  );
+
+  for (const r of reports) {
+    const link = `${SITE.url}/reports/${category}/${r.slug}`;
+    lines.push("    <item>");
+    lines.push(`      <title>${escapeXml(r.title)}</title>`);
+    lines.push(`      <link>${link}</link>`);
+    lines.push(`      <guid isPermaLink="true">${link}</guid>`);
+    lines.push(
+      `      <pubDate>${toRfc822(new Date(r.publishedAt))}</pubDate>`,
+    );
+    lines.push(
+      `      <description>${escapeXml(r.summary)}</description>`,
+    );
+    lines.push("    </item>");
+  }
+
+  lines.push("  </channel>");
+  lines.push("</rss>");
+
+  return new NextResponse(lines.join("\n"), {
+    status: 200,
+    headers: {
+      "Content-Type": "application/rss+xml; charset=utf-8",
+      "Cache-Control": "public, s-maxage=3600, stale-while-revalidate=86400",
+    },
+  });
+}
diff --git a/src/app/reports/page.tsx b/src/app/reports/page.tsx
new file mode 100644
index 00000000..30fd1040
--- /dev/null
+++ b/src/app/reports/page.tsx
@@ -0,0 +1,146 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { ReportCard } from "@/components/reports/report-card";
+import { getAllReports, REPORT_CATEGORY_META } from "@/lib/reports/loader";
+import { pageMetadata } from "@/lib/page-metadata";
+import { reportsLandingLd } from "@/lib/hub-jsonld";
+import { safeJsonLd } from "@/lib/jsonld";
+import { SITE } from "@/data/site";
+
+export const metadata: Metadata = pageMetadata({
+  path: "/reports",
+  title: "Reports",
+  description:
+    "Monthly and quarterly research reports on crypto infrastructure performance: RPC reliability, bridge fees, and prediction markets. Citable, reproducible, CC BY 4.0.",
+});
+
+const SERIF: React.CSSProperties = { fontFamily: "var(--font-serif)" };
+
+export default function ReportsPage() {
+  const reports = getAllReports();
+  const [featured, ...rest] = reports;
+  const categories = Object.entries(REPORT_CATEGORY_META) as Array<[string, { label: string; description: string }]>;
+
+  return (
+    <div className="mx-auto max-w-[1400px] px-4 sm:px-6 lg:px-8 py-8 sm:py-12">
+      {reportsLandingLd().map((ld, i) => (
+        <script
+          key={i}
+          type="application/ld+json"
+          // biome-ignore lint/security/noDangerouslySetInnerHtml: serialized via safeJsonLd
+          dangerouslySetInnerHTML={{ __html: safeJsonLd(ld) }}
+        />
+      ))}
+
+      {/* ── Masthead ── */}
+      <header className="border-b-2 border-ink pb-6 mb-10">
+        <div className="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-4">
+          <div>
+            <h1 className="display text-3xl sm:text-4xl tracking-tight">Reports</h1>
+            <p
+              className="mt-2 text-base sm:text-lg text-ink-soft leading-relaxed max-w-xl"
+              style={SERIF}
+            >
+              Research on crypto infrastructure performance. Every figure is live
+              benchmark data, citable under CC&nbsp;BY&nbsp;4.0.
+            </p>
+          </div>
+          <div className="flex items-center gap-3 shrink-0">
+            <a
+              href="/reports/rss.xml"
+              className="label-mono text-[11px] border border-rule px-2.5 py-1.5 text-ink-muted hover:text-ink hover:border-ink transition-colors"
+            >
+              RSS
+            </a>
+            <a
+              href={`https://x.com/${SITE.twitter}`}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="label-mono text-[11px] border border-rule px-2.5 py-1.5 text-ink-muted hover:text-ink hover:border-ink transition-colors"
+            >
+              {SITE.twitter}
+            </a>
+          </div>
+        </div>
+      </header>
+
+      {reports.length === 0 ? (
+        <p className="text-ink-muted text-base mt-14">No reports published yet. Check back soon.</p>
+      ) : (
+        <div className="lg:grid lg:grid-cols-12 lg:gap-16">
+          {/* ── Left: Featured + rest ── */}
+          <div className="lg:col-span-8">
+            {/* Featured latest report */}
+            {featured && <ReportCard report={featured} featured />}
+
+            {/* Grid of secondary reports */}
+            {rest.length > 0 && (
+              <div className="grid gap-5 sm:grid-cols-2">
+                {rest.map((r) => (
+                  <ReportCard key={`${r.categorySlug}/${r.slug}`} report={r} />
+                ))}
+              </div>
+            )}
+          </div>
+
+          {/* ── Right: Category sidebar ── */}
+          <aside className="lg:col-span-4 mt-12 lg:mt-0">
+            <div className="sticky top-24 space-y-8">
+              <div>
+                <h2 className="label-mono text-[11px] uppercase tracking-[0.18em] text-ink-muted mb-4">
+                  Browse by topic
+                </h2>
+                <div className="space-y-px">
+                  {categories.map(([slug, meta]) => (
+                    <Link
+                      key={slug}
+                      href={`/reports/${slug}`}
+                      className="group flex items-start justify-between gap-4 border border-rule hover:border-ink/40 transition-colors p-4"
+                    >
+                      <div>
+                        <p className="font-medium text-sm text-ink group-hover:text-ink-soft transition-colors">
+                          {meta.label}
+                        </p>
+                        <p className="mt-1 text-xs text-ink-muted leading-relaxed">
+                          {meta.description}
+                        </p>
+                      </div>
+                      <span className="label-mono text-[11px] text-ink-faint group-hover:text-ink-muted transition-colors shrink-0 mt-0.5">
+                        →
+                      </span>
+                    </Link>
+                  ))}
+                </div>
+              </div>
+
+              <div className="border-t border-rule pt-6">
+                <p className="label-mono text-[11px] uppercase tracking-[0.18em] text-ink-muted mb-3">
+                  Get updates
+                </p>
+                <p className="text-sm text-ink-muted leading-relaxed mb-3">
+                  New reports ship every 2–3 months. Subscribe via RSS or follow on X.
+                </p>
+                <div className="flex flex-col gap-2">
+                  <a
+                    href="/reports/rss.xml"
+                    className="label-mono text-[11px] border border-rule px-3 py-2 text-ink-muted hover:text-ink hover:border-ink transition-colors text-center"
+                  >
+                    RSS feed
+                  </a>
+                  <a
+                    href={`https://x.com/${SITE.twitter}`}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    className="label-mono text-[11px] border border-rule px-3 py-2 text-ink-muted hover:text-ink hover:border-ink transition-colors text-center"
+                  >
+                    {SITE.twitter} on X
+                  </a>
+                </div>
+              </div>
+            </div>
+          </aside>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/src/app/reports/rss.xml/route.ts b/src/app/reports/rss.xml/route.ts
new file mode 100644
index 00000000..24660a13
--- /dev/null
+++ b/src/app/reports/rss.xml/route.ts
@@ -0,0 +1,66 @@
+import { NextResponse } from "next/server";
+import { getAllReports } from "@/lib/reports/loader";
+import { SITE } from "@/data/site";
+
+export const revalidate = 3600;
+
+function escapeXml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function toRfc822(d: Date): string {
+  return d.toUTCString().replace("GMT", "+0000");
+}
+
+export async function GET() {
+  const reports = getAllReports();
+  const self = `${SITE.url}/reports/rss.xml`;
+  const lines: string[] = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push('<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">');
+  lines.push("  <channel>");
+  lines.push(
+    `    <title>${escapeXml("OpenChainBench Reports")}</title>`,
+  );
+  lines.push(`    <link>${SITE.url}/reports</link>`);
+  lines.push(
+    `    <description>${escapeXml("Monthly and quarterly research on crypto infrastructure performance — RPC, bridges, prediction markets. Citable, reproducible, CC BY 4.0.")}</description>`,
+  );
+  lines.push("    <language>en</language>");
+  lines.push(`    <lastBuildDate>${toRfc822(new Date())}</lastBuildDate>`);
+  lines.push(
+    `    <atom:link href="${self}" rel="self" type="application/rss+xml" />`,
+  );
+
+  for (const r of reports) {
+    const link = `${SITE.url}/reports/${r.categorySlug}/${r.slug}`;
+    lines.push("    <item>");
+    lines.push(`      <title>${escapeXml(r.title)}</title>`);
+    lines.push(`      <link>${link}</link>`);
+    lines.push(`      <guid isPermaLink="true">${link}</guid>`);
+    lines.push(
+      `      <pubDate>${toRfc822(new Date(r.publishedAt))}</pubDate>`,
+    );
+    lines.push(`      <category>${escapeXml(r.categorySlug)}</category>`);
+    lines.push(
+      `      <description>${escapeXml(r.summary)}</description>`,
+    );
+    lines.push("    </item>");
+  }
+
+  lines.push("  </channel>");
+  lines.push("</rss>");
+
+  return new NextResponse(lines.join("\n"), {
+    status: 200,
+    headers: {
+      "Content-Type": "application/rss+xml; charset=utf-8",
+      "Cache-Control": "public, s-maxage=3600, stale-while-revalidate=86400",
+    },
+  });
+}
diff --git a/src/components/reports/region-winners.tsx b/src/components/reports/region-winners.tsx
new file mode 100644
index 00000000..88dd35ab
--- /dev/null
+++ b/src/components/reports/region-winners.tsx
@@ -0,0 +1,155 @@
+import Link from "next/link";
+import { getBenchmark } from "@/data/benchmarks";
+import { rankedCandidates } from "@/lib/citation";
+import { ProviderLogo } from "@/components/provider-logo";
+
+const REGIONS = [
+  { key: "us-east", label: "US-East", sub: "Virginia" },
+  { key: "eu-west", label: "EU-West", sub: "Amsterdam" },
+  { key: "sgp", label: "Singapore", sub: "Asia-Pacific" },
+];
+
+type Props = { bench: string };
+
+export async function RegionWinners({ bench }: Props) {
+  const results = await Promise.all(
+    REGIONS.map((r) =>
+      getBenchmark(bench, { region: r.key }).catch(() => undefined)
+    )
+  );
+
+  const columns = REGIONS.map((region, i) => {
+    const b = results[i];
+    if (!b || b.editorialStatus !== "live") return { region, ranked: [] as ReturnType<typeof rankedCandidates> };
+    return { region, ranked: rankedCandidates(b) };
+  });
+
+  const anyData = columns.some((c) => c.ranked.length > 0);
+  if (!anyData) return null;
+
+  // Build a unified list of providers with per-region rank and p50
+  const slugsSeen = new Set<string>();
+  const providerMeta: Record<string, { name: string }> = {};
+  for (const { ranked } of columns) {
+    for (const r of ranked) {
+      slugsSeen.add(r.slug);
+      providerMeta[r.slug] = { name: r.name };
+    }
+  }
+
+  type ProviderRow = {
+    slug: string;
+    name: string;
+    regions: Array<{ p50: number | null; rank: number | null }>;
+    wins: number;
+  };
+
+  const rows: ProviderRow[] = Array.from(slugsSeen).map((slug) => {
+    const regions = columns.map(({ ranked }) => {
+      const idx = ranked.findIndex((r) => r.slug === slug);
+      if (idx === -1) return { p50: null, rank: null };
+      return { p50: ranked[idx].ms.p50 ?? null, rank: idx };
+    });
+    const wins = regions.filter((r) => r.rank === 0).length;
+    return { slug, name: providerMeta[slug].name, regions, wins };
+  });
+
+  // Sort: most wins first, then by sum of p50s ascending (faster overall = higher)
+  rows.sort((a, b) => {
+    if (b.wins !== a.wins) return b.wins - a.wins;
+    const sumA = a.regions.reduce((s, r) => s + (r.p50 ?? Infinity), 0);
+    const sumB = b.regions.reduce((s, r) => s + (r.p50 ?? Infinity), 0);
+    return sumA - sumB;
+  });
+
+  return (
+    <figure className="my-10 not-prose">
+      <div className="border-t-[2px] border-ink overflow-x-auto">
+        <table className="w-full text-sm border-collapse">
+          <thead>
+            <tr className="border-b border-rule">
+              <th className="text-left py-2.5 pr-3 pl-0 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium w-6">#</th>
+              <th className="text-left py-2.5 pr-4 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium">
+                Provider
+              </th>
+              {REGIONS.map((region) => (
+                <th
+                  key={region.key}
+                  className="text-right py-2.5 pr-4 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium"
+                >
+                  {region.label}
+                  <span className="normal-case text-ink-faint ml-1 hidden sm:inline">({region.sub})</span>
+                </th>
+              ))}
+              <th className="text-right py-2.5 pl-2 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium">
+                Wins
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            {rows.map((row, i) => {
+              const highlight = row.wins > 0;
+              return (
+                <tr
+                  key={row.slug}
+                  className={`border-b border-rule transition-colors ${
+                    highlight ? "bg-[var(--color-paper-soft)]" : "hover:bg-[var(--color-paper-soft)]/50"
+                  }`}
+                >
+                  <td className={`py-2 pr-3 pl-0 label-mono text-[12px] ${highlight ? "font-bold text-ink" : "text-ink-faint"}`}>
+                    {i + 1}
+                  </td>
+                  <td className="py-2 pr-4">
+                    <div className="flex items-center gap-2 min-w-0">
+                      <ProviderLogo slug={row.slug} name={row.name} size={16} />
+                      <Link
+                        href={`/products/${row.slug}`}
+                        className={`text-[13px] leading-tight hover:text-ink transition-colors truncate ${highlight ? "font-semibold text-ink" : "text-ink-soft"}`}
+                      >
+                        {row.name}
+                      </Link>
+                    </div>
+                  </td>
+                  {row.regions.map((reg, ri) => {
+                    const isWinner = reg.rank === 0;
+                    return (
+                      <td
+                        key={REGIONS[ri].key}
+                        className={`py-2 pr-4 text-right label-mono tabular-nums ${
+                          isWinner ? "text-[13px] font-bold text-ink" : "text-[12px] text-ink-soft"
+                        }`}
+                      >
+                        {reg.p50 != null ? `${Math.round(reg.p50)} ms` : "—"}
+                      </td>
+                    );
+                  })}
+                  <td className="py-2 pl-2 text-right label-mono tabular-nums">
+                    {row.wins > 0 ? (
+                      <span className="text-[13px] font-bold text-ink">{row.wins}/{REGIONS.length}</span>
+                    ) : (
+                      <span className="text-[12px] text-ink-faint">0/{REGIONS.length}</span>
+                    )}
+                  </td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      </div>
+      <figcaption className="mt-3 flex items-center justify-between gap-4">
+        <p className="text-xs text-ink-muted leading-relaxed">
+          p50 latency per probe region. Bold = fastest in that region. Wins = number of regions led.
+        </p>
+        <div className="flex items-center gap-1.5 shrink-0">
+          <span className="w-1.5 h-1.5 rounded-full bg-green-500 shrink-0" />
+          <Link
+            className="label-mono text-[10px] text-ink-muted hover:text-ink transition-colors whitespace-nowrap"
+            href={`/benchmarks/${bench}`}
+          >
+            Live data
+          </Link>
+        </div>
+      </figcaption>
+    </figure>
+  );
+}
diff --git a/src/components/reports/report-card.tsx b/src/components/reports/report-card.tsx
new file mode 100644
index 00000000..2332ded1
--- /dev/null
+++ b/src/components/reports/report-card.tsx
@@ -0,0 +1,119 @@
+import Link from "next/link";
+import type { ReportMeta } from "@/lib/reports/loader";
+import { REPORT_CATEGORY_META } from "@/lib/reports/loader";
+
+const SERIF: React.CSSProperties = { fontFamily: "var(--font-serif)" };
+
+export function ReportCard({
+  report,
+  featured = false,
+}: {
+  report: ReportMeta;
+  featured?: boolean;
+}) {
+  const catMeta = REPORT_CATEGORY_META[report.categorySlug];
+  const href = `/reports/${report.categorySlug}/${report.slug}`;
+
+  if (featured) {
+    return (
+      <article className="border-b-2 border-ink pb-10 mb-10">
+        <div className="flex items-center gap-3 mb-5">
+          <span className="label-mono text-[10px] border border-ink px-2 py-1 text-ink uppercase tracking-[0.15em]">
+            {catMeta?.label ?? report.categorySlug}
+          </span>
+          <span className="label-mono text-[10px] text-ink-faint uppercase tracking-[0.1em]">
+            {report.period}
+          </span>
+        </div>
+
+        <Link href={href} className="group block">
+          <h2 className="display text-3xl sm:text-4xl lg:text-5xl tracking-tight leading-[1.05] text-ink group-hover:text-ink-soft transition-colors">
+            {report.title}
+          </h2>
+        </Link>
+
+        {/* Key finding — the hook */}
+        <div className="mt-6 border-l-[3px] border-ink pl-5 py-0.5">
+          <p className="label-mono text-[10px] uppercase tracking-[0.18em] text-ink-muted mb-2">
+            Key finding
+          </p>
+          <p
+            className="text-lg sm:text-xl leading-snug text-ink italic"
+            style={SERIF}
+          >
+            &ldquo;{report.heroFinding}&rdquo;
+          </p>
+        </div>
+
+        <p className="mt-5 text-base leading-relaxed text-ink-soft" style={SERIF}>
+          {report.summary}
+        </p>
+
+        <div className="mt-6 flex items-center justify-between">
+          <div className="flex items-center gap-4 label-mono text-[11px] text-ink-faint">
+            <time dateTime={report.publishedAt}>
+              {new Date(report.publishedAt).toLocaleDateString("en-US", {
+                year: "numeric",
+                month: "long",
+                day: "numeric",
+                timeZone: "UTC",
+              })}
+            </time>
+            <span>{report.readingTime} min read</span>
+          </div>
+          <Link
+            href={href}
+            className="label-mono text-[11px] border border-ink px-3 py-1.5 text-ink hover:bg-ink hover:text-paper transition-colors"
+          >
+            Read report
+          </Link>
+        </div>
+      </article>
+    );
+  }
+
+  // Standard card
+  return (
+    <article className="border border-rule hover:border-ink/40 transition-colors flex flex-col">
+      <div className="p-5 flex flex-col flex-1">
+        <div className="flex items-center gap-2 mb-4">
+          <span className="label-mono text-[10px] border border-rule px-2 py-0.5 text-ink-muted uppercase tracking-[0.12em]">
+            {catMeta?.label ?? report.categorySlug}
+          </span>
+          <span className="label-mono text-[10px] text-ink-faint">
+            {report.period}
+          </span>
+        </div>
+
+        <Link href={href} className="group flex-1">
+          <h2 className="display text-xl tracking-tight leading-snug text-ink group-hover:text-ink-soft transition-colors">
+            {report.title}
+          </h2>
+          <p className="mt-3 text-sm leading-relaxed text-ink-muted" style={SERIF}>
+            {report.summary}
+          </p>
+        </Link>
+
+        <div className="mt-5 pt-4 border-t border-rule flex items-center justify-between">
+          <div className="label-mono text-[10px] text-ink-faint">
+            <time dateTime={report.publishedAt}>
+              {new Date(report.publishedAt).toLocaleDateString("en-US", {
+                year: "numeric",
+                month: "short",
+                day: "numeric",
+                timeZone: "UTC",
+              })}
+            </time>
+            {" · "}{report.readingTime} min
+          </div>
+          <Link
+            href={href}
+            className="label-mono text-[11px] text-ink-muted hover:text-ink transition-colors"
+          >
+            Read →
+          </Link>
+        </div>
+      </div>
+    </article>
+  );
+}
diff --git a/src/components/reports/stat-table.tsx b/src/components/reports/stat-table.tsx
new file mode 100644
index 00000000..de81fb06
--- /dev/null
+++ b/src/components/reports/stat-table.tsx
@@ -0,0 +1,167 @@
+import Link from "next/link";
+import { getBenchmark } from "@/data/benchmarks";
+import { rankedCandidates } from "@/lib/citation";
+import { fmtUnit } from "@/lib/format";
+import { ProviderLogo } from "@/components/provider-logo";
+
+type Props = {
+  bench: string;
+  chain?: string;
+  region?: string;
+  caption?: string;
+  showSuccessRate?: boolean;
+};
+
+export async function StatTable({
+  bench,
+  chain,
+  region,
+  caption,
+  showSuccessRate = true,
+}: Props) {
+  const b = await getBenchmark(bench, { chain, region }).catch(() => undefined);
+  if (!b || b.editorialStatus !== "live") {
+    return (
+      <p className="my-6 text-sm text-ink-muted italic">
+        Live data temporarily unavailable. See{" "}
+        <Link className="lnk" href={`/benchmarks/${bench}`}>
+          /benchmarks/{bench}
+        </Link>
+        .
+      </p>
+    );
+  }
+
+  const ranked = rankedCandidates(b);
+  if (!ranked.length) return null;
+
+  const hasSuccess = showSuccessRate && ranked.some((r) => r.successRate != null);
+
+  // Leader = #1 by p50. Most reliable = best success rate (only when hasSuccess).
+  // Label is "FASTEST" for latency benches (ms/s/sec), "LEADER" for count/rate/other.
+  const leaderSlug = ranked[0].slug;
+  const leaderLabel = ["ms", "s", "sec"].includes(b.unit ?? "") ? "FASTEST" : "LEADER";
+  const reliableSlug = hasSuccess
+    ? [...ranked].sort((a, c) => (c.successRate ?? 0) - (a.successRate ?? 0))[0].slug
+    : null;
+  // Show RELIABLE badge on the most-reliable provider regardless of whether
+  // it's also the latency leader (fastestSlug === reliableSlug). When they
+  // coincide, one row shows both badges, surfacing the "double winner" case
+  // instead of hiding the reliability signal entirely.
+  const fastestSlug = leaderSlug;
+
+  return (
+    <figure className="my-10 not-prose">
+      <div className="border-t-[2px] border-ink overflow-x-auto">
+        <table className="w-full text-sm border-collapse">
+          <thead>
+            <tr className="border-b border-rule">
+              <th className="text-left py-2.5 pr-3 pl-0 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium w-6">
+                #
+              </th>
+              <th className="text-left py-2.5 pr-3 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium">
+                Provider
+              </th>
+              <th className="text-right py-2.5 pr-3 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium">
+                p50 {b.unit && <span className="normal-case">({b.unit})</span>}
+              </th>
+              {hasSuccess && (
+                <th className="text-right py-2.5 label-mono text-[10px] uppercase tracking-[0.15em] text-ink-muted font-medium">
+                  Success
+                </th>
+              )}
+            </tr>
+          </thead>
+          <tbody>
+            {ranked.map((r, i) => {
+              const isFastest = r.slug === fastestSlug;
+              const isReliable = reliableSlug !== null && r.slug === reliableSlug;
+              const successPct = r.successRate ?? 100;
+              const successColor =
+                successPct >= 99
+                  ? "text-ink"
+                  : successPct >= 95
+                    ? "text-ink-soft"
+                    : "text-amber-600 dark:text-amber-400";
+
+              return (
+                <tr
+                  key={r.slug}
+                  className={`border-b border-rule transition-colors ${
+                    isFastest || isReliable
+                      ? "bg-[var(--color-paper-soft)]"
+                      : "hover:bg-[var(--color-paper-soft)]/50"
+                  }`}
+                >
+                  <td
+                    className={`py-2 pr-3 pl-0 label-mono text-[12px] ${
+                      isFastest || isReliable ? "font-bold text-ink" : "text-ink-faint"
+                    }`}
+                  >
+                    {i + 1}
+                  </td>
+                  <td className="py-2 pr-3">
+                    <div className="flex items-center gap-2.5">
+                      <ProviderLogo slug={r.slug} name={r.name} size={20} />
+                      <Link
+                        href={`/products/${r.slug}`}
+                        className={`hover:text-ink transition-colors text-[13px] leading-tight ${
+                          isFastest || isReliable ? "font-semibold text-ink" : "text-ink-soft"
+                        }`}
+                      >
+                        {r.name}
+                      </Link>
+                      {isFastest && (
+                        <span className="label-mono text-[9px] bg-ink text-paper px-1.5 py-px uppercase tracking-[0.1em] shrink-0">
+                          {leaderLabel}
+                        </span>
+                      )}
+                      {isReliable && (
+                        <span className="label-mono text-[9px] border border-ink text-ink px-1.5 py-px uppercase tracking-[0.1em] shrink-0">
+                          RELIABLE
+                        </span>
+                      )}
+                    </div>
+                  </td>
+                  <td
+                    className={`py-2 pr-3 text-right label-mono tabular-nums ${
+                      isFastest ? "text-[14px] font-bold text-ink" : "text-[13px] text-ink-soft"
+                    }`}
+                  >
+                    {fmtUnit(r.ms.p50, b.unit)}
+                  </td>
+                  {hasSuccess && (
+                    <td className={`py-2 text-right label-mono text-[13px] tabular-nums ${successColor}`}>
+                      <span className="flex items-center justify-end gap-2">
+                        <span
+                          className="hidden sm:block h-1 rounded-full bg-current opacity-25 shrink-0"
+                          style={{ width: `${Math.round(successPct * 0.4)}px` }}
+                        />
+                        {successPct.toFixed(1)}%
+                      </span>
+                    </td>
+                  )}
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      </div>
+
+      {caption && (
+        <figcaption className="mt-3 flex items-start gap-4 justify-between">
+          <p className="text-xs text-ink-muted leading-relaxed">{caption}</p>
+          <div className="flex items-center gap-1.5 shrink-0 pt-0.5">
+            <span className="w-1.5 h-1.5 rounded-full bg-green-500 shrink-0" />
+            <Link
+              className="label-mono text-[10px] text-ink-muted hover:text-ink transition-colors whitespace-nowrap"
+              href={`/benchmarks/${bench}`}
+            >
+              Live data
+            </Link>
+          </div>
+        </figcaption>
+      )}
+    </figure>
+  );
+}
diff --git a/src/components/site-footer.tsx b/src/components/site-footer.tsx
index ecaa15bb..4150e076 100644
--- a/src/components/site-footer.tsx
+++ b/src/components/site-footer.tsx
@@ -27,6 +27,7 @@ export function SiteFooter() {
             title="Read"
             links={[
               { label: "Benchmarks", href: "/benchmarks" },
+              { label: "Reports", href: "/reports" },
               { label: "Products", href: "/products" },
               { label: "Chains", href: "/chains" },
               { label: "Prediction markets", href: "/prediction-markets" },
diff --git a/src/components/site-header.tsx b/src/components/site-header.tsx
index 3a622cab..aef5dbd8 100644
--- a/src/components/site-header.tsx
+++ b/src/components/site-header.tsx
@@ -46,6 +46,11 @@ const NAV: NavItem[] = [
     label: "Methodology",
     match: (p) => p === "/methodology",
   },
+  {
+    href: "/reports",
+    label: "Reports",
+    match: (p) => p === "/reports" || p.startsWith("/reports/"),
+  },
   { href: "/about", label: "About", match: (p) => p === "/about" },
   { href: "/contribute", label: "Contribute", match: (p) => p === "/contribute" },
 ];
diff --git a/src/content/reports/rpc/2026-08-state-of-public-rpc.mdx b/src/content/reports/rpc/2026-08-state-of-public-rpc.mdx
new file mode 100644
index 00000000..8b384567
--- /dev/null
+++ b/src/content/reports/rpc/2026-08-state-of-public-rpc.mdx
@@ -0,0 +1,200 @@
+---
+title: "Best Free Public RPC 2026: Speed, Reliability, and What to Use"
+category: "rpc"
+slug: "2026-08-state-of-public-rpc"
+publishedAt: "2026-08-01"
+period: "August 2026"
+summary: "Free public RPCs are faster than ever, and less reliable than most builders assume. This report benchmarks the leading providers by what actually matters: correctness first, latency second."
+heroFinding: "The fastest free RPC in this cohort fails one call in five. The most reliable didn't fail a single probe in the measurement window."
+author: "OpenChainBench Research"
+readingTime: 15
+canonical: "https://openchainbench.com/reports/rpc/2026-08-state-of-public-rpc"
+---
+
+<Summary>
+- Free public RPCs are fast enough for most use cases, but success rates vary wildly across the cohort.
+- The fastest providers are not the most reliable. Latency rankings published by providers themselves almost always hide this.
+- As of August 2026, PublicNode is the only provider in this cohort sustaining near-100% success across five or more EVM chains simultaneously.
+- Foundation endpoints on L2s (Arbitrum, Base, Optimism) consistently trail third-party providers on latency; on reliability they match but do not lead.
+- Latency grows with geographic distance, but geographic penalties vary by region and provider — check the per-region tab for your users' location before choosing a static endpoint.
+- Across 19 chains and 3 regions (57 contests), PublicNode wins 28. dRPC, the next third-party provider, trails by 14.
+- For indexers and event listeners, filter by success rate first. A 90% success rate means hundreds of silent failures per hour at typical read rates.
+</Summary>
+
+<TOC sections="Methodology|The Speed Trap: Why Latency Rankings Mislead|Reliability Champion|Chain-by-Chain Standouts|Regional Divergence|Provider Wins Across 19 Chains|Reproducibility Recipe|Decision Framework|What to Watch Next|Sources and Reproducibility" />
+
+## Methodology
+
+Every number in this report is a live query against the [OpenChainBench Prometheus](https://openchainbench.com/methodology). The harness probes each provider with a rotating `eth_getBlockByNumber` request every 60 seconds from three geographic regions: `us-east-1`, `eu-west-1`, and `ap-southeast-1` (Singapore). Each probe is classified into one of five states: `ok`, `http_err`, `jsonrpc_err`, `stale` (block number behind chain tip by more than 20 blocks), or `timeout` (no response within 5 seconds).
+
+Latency figures are the p50 over a 24-hour rolling window. Success rate is the fraction of probes returning `ok`. All benchmarks are reproducible: the harness source lives at [github.com/ChainBench/OpenChainBench/harnesses](https://github.com/ChainBench/OpenChainBench/tree/main/harnesses), and the live bench pages link to the Prometheus queries that back each figure.
+
+This report covers data from the [Ethereum RPC bench](/benchmarks/ethereum-rpc), [RPC Reliability bench](/benchmarks/rpc-reliability), [RPC Capabilities bench](/benchmarks/rpc-capabilities), and a selection of per-chain RPC leaderboards. The live cross-chain view across all providers and chains is on the [RPC hub](/rpc).
+
+## The Speed Trap: Why Latency Rankings Mislead
+
+Every "fastest RPC" ranking on the web is a latency ranking. p50 milliseconds, median response time, average latency. The implicit assumption is that a faster response is a better response.
+
+That assumption breaks for free public RPCs.
+
+An RPC endpoint can return an HTTP 200 with a JSON body in milliseconds and still be wrong. If the `result` field contains a JSON-RPC error, or if the block number is 40 blocks behind the chain tip, the low latency figure is meaningless. The client asked a question and got a wrong answer, fast.
+
+OpenChainBench classifies every probe response. A 200 that contains `{"jsonrpc":"2.0","error":{"code":-32603}}` counts as `jsonrpc_err`, not as a successful call. A 200 that returns a block number 25 blocks behind the tip counts as `stale`. Only probes classified `ok` count toward the success rate.
+
+When you apply this filter, the ranking changes dramatically. Cloudflare-eth is the clearest example in this cohort: it returns sub-second HTTP 200s, but a large share carry a JSON-RPC error body (`-32046 Cannot fulfill request`) rather than a block number. <Mark>Fast on latency metrics, wrong in practice.</Mark> Providers that dominate raw-latency rankings often fall to the middle or bottom once correctness is factored in.
+
+Two providers are absent from the latency ranking for different reasons. Merkle sits behind an aggressive bot filter that, in our testing, <Mark>locks out programmatic clients for 20 minutes</Mark> after a single unauthenticated request — a benchmark of it would measure cache-hit latency, not availability. Cloudflare-eth is tracked by the harness but has no rankable latency: with nearly every probe classified as `jsonrpc_err` (`-32046 Cannot fulfill request`), there are not enough `ok` responses to calculate a meaningful p50. It remains the clearest illustration of the speed-vs-correctness split: fast HTTP round-trips, wrong answers, no latency data.
+
+<StatTable bench="ethereum-rpc" caption="Ethereum RPC providers with a rankable p50 latency over 24 hours. Merkle and Cloudflare-eth are absent; see the paragraph above." />
+
+The lesson is not that latency is unimportant. A 400 ms p50 would disqualify a provider for real-time frontend use regardless of its success rate. The lesson is that <Mark>below 95% success rate, latency is irrelevant.</Mark>
+
+### Why free public endpoints degrade
+
+Free public RPC endpoints are subsidized products. A provider offers them to acquire developer mindshare, then sells dedicated nodes, websocket connections, or archive tiers to the subset of users whose usage grows. The subsidy model creates a structural tension: the more popular the free endpoint, the more it costs to maintain it at quality, and the incentive structure suggests providers may throttle or degrade free-tier traffic as their paid base grows.
+
+The consequence shows up in success rates. A provider whose free tier is heavily used at peak hours will serve throttle errors (`429`, `-32005`) that the harness classifies as `jsonrpc_err`. Because the harness probes at a fixed 60-second cadence from three regions, it catches the degraded hour that a casual benchmark misses entirely.
+
+## Reliability Champion
+
+One provider consistently outperforms the field on success rate across multiple chains and regions: **PublicNode**.
+
+PublicNode runs near-100% success rates on Ethereum, Arbitrum, Base, Optimism, and Avalanche over the measurement window. It achieves this without a premium tier for RPC access: the project is community-funded and operates endpoints as a public good. Its architecture uses geographic PoP distribution with automatic failover. A failure in one data center is invisible to the probe.
+
+What makes PublicNode structurally different is that it has <Mark>no paid conversion funnel for RPC access.</Mark> Most other providers in this cohort have an incentive structure that can lead to throttling free-tier users toward paid plans. PublicNode does not. That difference shows up in the data.
+
+The practical implication is simple: if you need a free RPC for anything that fails silently on error, PublicNode is the standout option in the no-key free tier.
+
+The Ethereum cohort splits into two groups. Several providers — including PublicNode — recorded zero probe failures over the measurement window. A second group sits in the 80–82% band: dRPC at around 80% and one other provider nearby. A 80% success rate means one in five of your `eth_call` requests silently fails — <Mark>400 failed reads per hour</Mark> at 100 reads per minute. Whether that is tolerable depends entirely on how your application handles errors.
+
+## Chain-by-Chain Standouts
+
+### Ethereum
+
+The Ethereum RPC market is the most competitive in the cohort. Multiple providers compete on latency within ranges that are well within acceptable frontend budgets. The differentiation on Ethereum is almost entirely on reliability, which is why the success rate column matters more than the latency column on this bench.
+
+PublicNode's Ethereum endpoint is not the fastest. It typically ranks in the middle by p50, but near the top by success rate. This inversion is a consistent pattern across the RPC dataset: the most reliable provider is rarely the fastest, because running infrastructure that stays correct under load is a different engineering problem than minimizing median response time.
+
+### L2s: Foundation Endpoints Trail on Speed
+
+On Arbitrum, Base, and Optimism, the foundation-operated endpoints (arb1.arbitrum.io, mainnet.base.org, mainnet.optimism.io) are the most obvious choice for builders new to each chain. They are the endpoints documented first in every official SDK. But they consistently trail third-party providers on latency. On reliability, foundation endpoints reach comparable success rates — they are sized for availability, not for speed under continuous load.
+
+<StatTable bench="arbitrum-rpc" caption="Arbitrum RPC: foundation vs specialist endpoints." />
+
+<RegionWinners bench="arbitrum-rpc" />
+
+<StatTable bench="base-rpc" caption="Base RPC providers. Third-party providers outperform mainnet.base.org on latency." />
+
+<RegionWinners bench="base-rpc" />
+
+Foundation endpoints are maintained to be accessible, not to be fast. They are sized for the long tail of infrequent callers, not for continuous probing or indexing traffic. The specialist providers that sell dedicated nodes keep their free tier competitive because it feeds developer acquisition — a different incentive from endpoints whose paid base is large enough not to care about free-tier latency.
+
+### L1s: Foundation Endpoints Dominate
+
+The pattern reverses on Solana and Monad.
+
+Solana's `api.mainnet-beta.solana.com` leads on latency among the providers in this cohort. This is structurally expected: the Solana Foundation operates the endpoint as a showcase for the chain's speed claims, and allocates engineering resources to keep it performant.
+
+<StatTable bench="solana-rpc" caption="Solana RPC providers. Foundation endpoint leads by a wide margin." />
+
+Monad's `rpc.monad.xyz` returns the fastest median responses in the entire RPC dataset across all chains. Monad's parallel-execution architecture makes the on-chain layer itself much faster, and the foundation endpoint sits co-located with validator nodes. No third-party provider is competitive on raw latency at this stage.
+
+### HyperEVM / Hyperliquid
+
+Hyperliquid's EVM presents a distinct case. Hyperliquid Labs operates the primary publicly accessible RPC and the competitive pool remains small compared to EVM chains. The data below serves as a reliability monitor, not a competitive ranking — do not use latency position here to select a provider.
+
+<StatTable bench="hyperliquid-rpc" caption="HyperEVM RPC monitoring. Thin competitive field; treat as a reliability baseline, not a speed ranking." />
+
+## Regional Divergence
+
+The headline p50 in every table above is a global average. The table below shows the full latency ranking for each of the three probe regions side by side. Read across the rows: position changes between columns are real ranking shifts; value changes show how the same provider's latency grows as geographic distance increases.
+
+<RegionWinners bench="ethereum-rpc" />
+
+Latency leadership at the top is typically stable — the same provider that wins Virginia usually wins Singapore. What changes is the magnitude: every provider's p50 grows as probes travel further, and those without infrastructure in the probe's region carry the largest penalty. One pattern worth noting on the Arbitrum bench: PublicNode's Singapore p50 undercuts its Virginia figure — evidence of an Asian PoP serving L2 traffic efficiently from a closer datacenter. That is structurally rare in the free-tier cohort. <Mark>No single public RPC is optimal everywhere.</Mark> If your users are global, a geo-routing strategy (CDN-edge RPC selection, or multiple endpoints with latency-based fallback) beats any static choice. The [RPC Capabilities bench](/benchmarks/rpc-capabilities) has live per-region breakdowns for every provider, queryable via `?region=us-east|eu-west|sgp`.
+
+## Provider Wins Across 19 Chains
+
+19 chains, 3 probe regions — 57 regional contests. A "win" is the lowest p50 among providers returning a classified `ok` response in that region for that chain. Data snapshot: July 28, 2026 — live current rankings on the [RPC hub](/rpc).
+
+**Win count summary**
+
+| Provider | US-East | EU-West | Singapore | Total / 57 |
+|---|---:|---:|---:|---:|
+| PublicNode | 9 | 10 | 9 | 28 |
+| Foundation (own-chain) | 5 | 5 | 5 | 15 |
+| dRPC | 5 | 4 | 5 | 14 |
+
+
+Foundation endpoints win exclusively on their own chain and cannot serve traffic on other networks. Among third-party providers, PublicNode takes 28 slots across 10 chains; dRPC, the next third-party provider, trails by 14 wins (28 vs 14) concentrated on 5 chains. The per-region breakdown for every chain is live on the [RPC Capabilities bench](/benchmarks/rpc-capabilities) via `?region=us-east|eu-west|sgp`.
+
+## Reproducibility Recipe
+
+Every number in this report can be reproduced. Here is the exact curl command to run a single probe matching the harness behavior:
+
+```bash
+REQUEST_ID=$(cat /dev/urandom | LC_ALL=C tr -dc 'a-f0-9' | head -c 16)
+curl -s -X POST https://ethereum.publicnode.com \
+  -H 'Content-Type: application/json' \
+  -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_getBlockByNumber\",\"params\":[\"latest\",false],\"id\":\"$REQUEST_ID\"}" \
+  | jq '{ok: (.result != null), block: (.result.number | if . then tonumber else null end)}'
+```
+
+The `REQUEST_ID` rotation prevents provider-side caching of responses, which can inflate apparent performance in naive benchmarks that repeat the same request body. The harness generates a new UUID per probe for the same reason.
+
+To reproduce the archive depth test (which determines how far back `eth_getLogs` can query):
+
+```bash
+# Block 1 = genesis-era; a full-archive provider returns a result, a pruned node returns -32001
+curl -s -X POST https://ethereum.publicnode.com \
+  -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045","0x1"],"id":1}' \
+  | jq '{archive_supported: (.result != null), error_code: (.error.code // null)}'
+```
+
+A response of `null` for `result` with error code `-32001` (`missing trie node`) confirms the provider does not serve archive queries. A non-null result confirms full archive depth. The harness tests five depth levels: 300 blocks (Geth default pruning), 7,200 (recent-week), 216,000 (recent-month), 1,296,000 (recent-year), and genesis.
+
+The full harness source, including all probe types and Prometheus metric definitions, is at [harnesses/rpc-capabilities](https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities).
+
+## Decision Framework
+
+Which free RPC you should use depends on what you are building. All figures below are live on the [RPC hub](/rpc), updated every 60 seconds.
+
+<UseCase label="Frontend dApp / wallet UI">
+Latency matters because it affects perceived speed for end users. Success rates above 95% are necessary but not differentiating: the user retries failed wallet operations. Use the p50 leader for each chain in your target region. For Ethereum in Asia: check the `sgp` regional filter on the [RPC Capabilities bench](/benchmarks/rpc-capabilities) for the current leader.
+</UseCase>
+
+<UseCase label="Indexer / event listener">
+Success rate is the primary variable. One `jsonrpc_err` on `eth_getLogs` means a missed event and a corrupted index. Use PublicNode (near-100% success, archive supported). Build in exponential backoff with a secondary fallback: even high-success providers have incident windows.
+</UseCase>
+
+<UseCase label="MEV bot / frontrunner">
+Latency is critical and the public RPC market is the wrong solution. Any free public endpoint with shared infrastructure introduces queueing delay that a co-located private node eliminates. This report covers public no-key endpoints only; MEV infrastructure is outside scope.
+</UseCase>
+
+<UseCase label="Archive query workload">
+Filter first by archive depth support using the [RPC Capabilities bench](/benchmarks/rpc-capabilities), then by latency. Several Ethereum providers in this cohort do not support archive queries at all. Sending historical `eth_getLogs` to them returns an error, silently if your client does not check error codes.
+</UseCase>
+
+<UseCase label="Multi-chain app">
+As of August 2026, PublicNode is the only provider in this cohort with near-100% success rate across five or more EVM chains simultaneously. If you need a single RPC provider for a multi-chain architecture, it is the only option in the no-key free tier that meets reliability thresholds across the board.
+</UseCase>
+
+## What to Watch Next
+
+This is the first edition of the OpenChainBench RPC Report. Starting with the September 2026 edition, each report will track month-over-month movement across three signals: success rate shifts, latency ranking changes, and incident counts per provider. Providers that degraded, chains where the competitive landscape shifted, and new entrants to the cohort will all appear in that section.
+
+The metrics most likely to move between now and September: success rates on Base and Arbitrum foundation endpoints (both chains are actively investing in RPC infrastructure), and the provider count on HyperEVM (currently thin).
+
+If you want to be notified when the next edition publishes, follow [@OpenChainBench](https://x.com/OpenChainBench) or subscribe to the [RSS feed](/reports/rpc/rss.xml).
+
+## Sources and Reproducibility
+
+All data in this report is derived from OpenChainBench's live Prometheus instance. The underlying metrics are public and queryable.
+
+- **Live bench pages:** [ethereum-rpc](/benchmarks/ethereum-rpc), [rpc-reliability](/benchmarks/rpc-reliability), [rpc-capabilities](/benchmarks/rpc-capabilities), [arbitrum-rpc](/benchmarks/arbitrum-rpc), [base-rpc](/benchmarks/base-rpc), [optimism-rpc](/benchmarks/optimism-rpc), [solana-rpc](/benchmarks/solana-rpc), [monad-rpc](/benchmarks/monad-rpc), [hyperliquid-rpc](/benchmarks/hyperliquid-rpc)
+- **Machine-readable data:** [/api/stat/ethereum-rpc](/api/stat/ethereum-rpc), [/api/stat/rpc-reliability](/api/stat/rpc-reliability)
+- **Harness source:** [github.com/ChainBench/OpenChainBench/harnesses](https://github.com/ChainBench/OpenChainBench/tree/main/harnesses)
+- **Prometheus queries:** available via [/api/citable](/api/citable) or the methodology page
+- **License:** All data and figures in this report are published under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). You may reproduce them in editorial, research, or commercial contexts with attribution to OpenChainBench and a link to the canonical URL.
+- **Corrections:** Data errors, methodology disputes, and provider rebuttals can be filed as [GitHub issues](https://github.com/ChainBench/OpenChainBench/issues/new). Material corrections are applied in place with a dated note.
diff --git a/src/lib/reports/loader.ts b/src/lib/reports/loader.ts
new file mode 100644
index 00000000..0f10f221
--- /dev/null
+++ b/src/lib/reports/loader.ts
@@ -0,0 +1,105 @@
+import fs from "node:fs";
+import path from "node:path";
+import matter from "gray-matter";
+
+const REPORTS_DIR = path.join(process.cwd(), "src/content/reports");
+
+export type ReportMeta = {
+  title: string;
+  category: string;
+  categorySlug: string;
+  slug: string;
+  publishedAt: string;
+  period: string;
+  summary: string;
+  heroFinding: string;
+  author: string;
+  readingTime: number;
+  ogImage?: string;
+  canonical: string;
+};
+
+export type Report = ReportMeta & {
+  content: string;
+};
+
+export const REPORT_CATEGORY_META: Record<
+  string,
+  { label: string; description: string }
+> = {
+  rpc: {
+    label: "RPC",
+    description:
+      "Public no-key RPC endpoints benchmarked for latency, reliability, and archive depth across EVM chains.",
+  },
+  bridge: {
+    label: "Bridge",
+    description:
+      "Cross-chain USDC transfer routes benchmarked for quote latency and effective fee.",
+  },
+  "prediction-markets": {
+    label: "Prediction Markets",
+    description:
+      "On-chain prediction markets benchmarked for quote availability, market coverage, and resolution latency.",
+  },
+};
+
+function parseReport(filePath: string): Report {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const { data, content } = matter(raw);
+  const rel = filePath.replace(REPORTS_DIR + path.sep, "");
+  const categorySlug = rel.split(path.sep)[0];
+  return {
+    title: String(data.title ?? ""),
+    category: String(data.category ?? categorySlug),
+    categorySlug,
+    slug: String(data.slug ?? ""),
+    publishedAt: String(data.publishedAt ?? ""),
+    period: String(data.period ?? ""),
+    summary: String(data.summary ?? ""),
+    heroFinding: String(data.heroFinding ?? ""),
+    author: String(data.author ?? "OpenChainBench Research"),
+    readingTime: Number(data.readingTime ?? 10),
+    ogImage: data.ogImage ? String(data.ogImage) : undefined,
+    canonical: String(data.canonical ?? ""),
+    content,
+  };
+}
+
+export function getAllReports(): Report[] {
+  if (!fs.existsSync(REPORTS_DIR)) return [];
+  const reports: Report[] = [];
+  for (const cat of fs.readdirSync(REPORTS_DIR)) {
+    const catDir = path.join(REPORTS_DIR, cat);
+    if (!fs.statSync(catDir).isDirectory()) continue;
+    for (const file of fs.readdirSync(catDir)) {
+      if (!file.endsWith(".mdx")) continue;
+      try {
+        reports.push(parseReport(path.join(catDir, file)));
+      } catch {
+        // skip malformed files
+      }
+    }
+  }
+  return reports.sort((a, b) => b.publishedAt.localeCompare(a.publishedAt));
+}
+
+export function getReportsByCategory(categorySlug: string): Report[] {
+  return getAllReports().filter((r) => r.categorySlug === categorySlug);
+}
+
+export function getReport(
+  categorySlug: string,
+  slug: string,
+): Report | undefined {
+  return getAllReports().find(
+    (r) => r.categorySlug === categorySlug && r.slug === slug,
+  );
+}
+
+export function getAllReportCategories(): string[] {
+  if (!fs.existsSync(REPORTS_DIR)) return [];
+  return fs
+    .readdirSync(REPORTS_DIR)
+    .filter((f) => fs.statSync(path.join(REPORTS_DIR, f)).isDirectory());
+}
diff --git a/src/lib/sitemap-builder.ts b/src/lib/sitemap-builder.ts
index c700a10e..5ab6faef 100644
--- a/src/lib/sitemap-builder.ts
+++ b/src/lib/sitemap-builder.ts
@@ -2,6 +2,7 @@ import { readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import type { MetadataRoute } from "next";
 import { getBenchmarks } from "@/data/benchmarks";
+import { getAllReports, getAllReportCategories } from "@/lib/reports/loader";
 import { COMPARE_PAIRS } from "@/data/compare-pairs";
 import { adHocPairs } from "@/lib/compare/adhoc-pairs";
 import { REMOVED_BENCH_SLUGS } from "@/middleware";
@@ -107,6 +108,38 @@ async function safeLoad<T>(
   }
 }
 
+function reportsRoutes(): MetadataRoute.Sitemap {
+  const entries: MetadataRoute.Sitemap = [
+    {
+      url: `${SITE.url}/reports`,
+      lastModified: BUILD_TIME,
+      changeFrequency: "monthly",
+      priority: 0.8,
+    },
+  ];
+  try {
+    for (const cat of getAllReportCategories()) {
+      entries.push({
+        url: `${SITE.url}/reports/${cat}`,
+        lastModified: BUILD_TIME,
+        changeFrequency: "monthly",
+        priority: 0.7,
+      });
+    }
+    for (const r of getAllReports()) {
+      entries.push({
+        url: `${SITE.url}/reports/${r.categorySlug}/${r.slug}`,
+        lastModified: new Date(r.publishedAt),
+        changeFrequency: "monthly",
+        priority: 0.85,
+      });
+    }
+  } catch {
+    // content dir may not exist yet
+  }
+  return entries;
+}
+
 function staticHubRoutes(catalogTs: Date): MetadataRoute.Sitemap {
   return [
     { url: SITE.url, lastModified: catalogTs, changeFrequency: "daily", priority: 1.0 },
@@ -494,6 +527,7 @@ async function buildFullSitemap(): Promise<MetadataRoute.Sitemap> {
 
   return [
     ...staticRoutes,
+    ...reportsRoutes(),
     ...benchmarkRoutes,
     ...providerRoutes,
     ...hlBuilderRoutes,