feat(scaling): build the scorecard from benchmark pipeline results

app/scaling/[area]/page.tsx

@@ -24,12 +24,12 @@ export default async function ScalingAreaPage({ params }: { params: Promise<{ ar
   const ceilings = withDaWorkloads(snapshot.ceilings);
   return (
     <div className="flex flex-col gap-10 pb-8">
-      <Header loaded={loaded} title={`${entry[1]} · ${snapshot.network}`} crumb={entry[1]} />
+      <Header title={`${entry[1]} · ${snapshot.network}`} crumb={entry[1]} />
       <section className="flex flex-col gap-3">
         <Text as="h2" variant="headline">Ceiling <span className="text-bds-gray-60">· Mgas/s</span></Text>
-        <RunBackedCeilingCard area={entry[0]} ceilings={ceilings} />
+        <RunBackedCeilingCard area={entry[0]} ceilings={ceilings} benchUrl={process.env.SCALING_BENCH_BASE_URL} />
       </section>
-      {area === 'da' ? <DaWorkloads observedP50={snapshot.ladder.observed.p50.value} /> : null}
+      {area === 'da' ? <DaWorkloads observedP50={snapshot.ladder.observed.p50.value} benchUrl={process.env.SCALING_BENCH_BASE_URL} /> : null}
       {section ? (
         <SectionTable section={section} windows={snapshot.windows} />
       ) : (

app/scaling/archiveSize.test.ts

@@ -0,0 +1,66 @@
+import { readFileSync } from 'node:fs';
+
+import { afterEach, expect, it, vi } from 'vitest';
+
+import { ARCHIVE_SNAPSHOTS_URL, fetchArchiveSize, loadArchiveSize, parseArchiveSize, withArchiveSize } from './archiveSize';
+import type { Snapshot } from './snapshot.mjs';
+
+// Synthetic sizes in the chain.base.org shape, with extra fields the parser must ignore.
+const ENTRIES = [
+  { network: 'sepolia', profile: 'archive', block: 9, date: '2026-01-01', size: 1e12, components: [] },
+  {
+    chainId: '8453', network: 'mainnet', profile: 'archive', block: 1_234_567, timestamp: '1767225600', date: '2026-01-01', size: 6e12, isModular: true,
+    components: [{ name: 'state', displayName: 'State', size: 1e12 }, { name: 'proofs', size: 1.5e12 }, { name: 'receipts', size: 2e12, fullSize: 1e11 }],
+  },
+];
+const ARCHIVE = { size: 6e12, sizeWithoutProofs: 4.5e12, block: 1_234_567, date: '2026-01-01', source: 'chain.base.org' };
+const fixture = (network: string): Snapshot => ({ ...JSON.parse(readFileSync(new URL('./fixtures/synthetic.v2.json', import.meta.url), 'utf8')), network });
+
+afterEach(() => vi.restoreAllMocks());
+
+it('reads the mainnet archive entry, total including proofs and without them', () => {
+  expect(parseArchiveSize(ENTRIES)).toEqual(ARCHIVE);
+});
+
+it('rejects a response that is not the expected shape', () => {
+  const mainnet = ENTRIES[1];
+  for (const bad of [
+    {},
+    [ENTRIES[0]],
+    [{ ...mainnet, size: '6e12' }],
+    [{ ...mainnet, size: 0 }],
+    [{ ...mainnet, block: 1.5 }],
+    [{ ...mainnet, date: 'yesterday' }],
+    [{ ...mainnet, date: '2026-02-30' }],
+    [{ ...mainnet, components: null }],
+    [{ ...mainnet, components: [{ name: 'proofs', size: -1 }] }],
+    [{ ...mainnet, components: [{ name: 'proofs', size: 7e12 }] }],
+  ]) expect(parseArchiveSize(bad)).toBeNull();
+});
+
+it('fetches with a timeout and throws on a failed or malformed response', async () => {
+  const fetchImpl = vi.fn(async () => Response.json(ENTRIES));
+  expect(await fetchArchiveSize(fetchImpl as unknown as typeof fetch)).toEqual(ARCHIVE);
+  expect(fetchImpl).toHaveBeenCalledWith(ARCHIVE_SNAPSHOTS_URL, { signal: expect.any(AbortSignal) });
+  await expect(fetchArchiveSize((async () => new Response('down', { status: 502 })) as typeof fetch)).rejects.toThrow('502');
+  await expect(fetchArchiveSize((async () => Response.json([{ network: 'mainnet' }])) as typeof fetch)).rejects.toThrow('unexpected response shape');
+});
+
+it('falls back to null on a timeout, logging why', async () => {
+  const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+  const timeout = () => Promise.reject(new DOMException('The operation was aborted due to timeout', 'TimeoutError'));
+  expect(await loadArchiveSize(timeout)).toBeNull();
+  expect(warn).toHaveBeenCalledOnce();
+  expect(await loadArchiveSize(async () => ARCHIVE as never)).toEqual(ARCHIVE);
+});
+
+it('replaces a mainnet snapshot’s archive size and leaves others or a failed fetch alone', () => {
+  const mainnet = fixture('Base mainnet');
+  expect(withArchiveSize(mainnet, ARCHIVE as never).production!.archiveBytes).toEqual({
+    value: 6e12, asOf: '2026-01-01', source: 'chain.base.org snapshot, block 1,234,567', note: 'incl. proofs',
+  });
+  expect(withArchiveSize(mainnet, ARCHIVE as never).production!.stateBytesPerGas).toEqual(mainnet.production!.stateBytesPerGas);
+  expect(withArchiveSize(mainnet, null)).toBe(mainnet);
+  const synthetic = fixture('synthetic-testnet');
+  expect(withArchiveSize(synthetic, ARCHIVE as never)).toBe(synthetic);
+});

app/scaling/archiveSize.ts

@@ -0,0 +1,63 @@
+import { unstable_cache } from 'next/cache';
+
+import type { Snapshot } from './snapshot.mjs';
+
+// chain.base.org lists the latest node snapshots publicly. It sends no CORS header, so the server fetches it.
+export const ARCHIVE_SNAPSHOTS_URL = 'https://chain.base.org/api/snapshots';
+const TIMEOUT_MS = 5_000;
+const REVALIDATE_SECONDS = 3_600;
+
+// `size` is the whole archive snapshot, proofs included: production nodes run archive with proofs.
+export type ArchiveSize = { size: number; sizeWithoutProofs: number; block: number; date: string; source: 'chain.base.org' };
+
+const isObj = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isDay = (date: string) => !Number.isNaN(Date.parse(date)) && new Date(date).toISOString().slice(0, 10) === date;
+const isSize = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+
+// The mainnet archive entry, checked field by field; extra fields are ignored. Null when the shape is off.
+export function parseArchiveSize(json: unknown): ArchiveSize | null {
+  if (!Array.isArray(json)) return null;
+  const entry = json.find((e) => isObj(e) && e.network === 'mainnet' && e.profile === 'archive');
+  if (!isObj(entry)) return null;
+  const { size, block, date, components } = entry;
+  if (!isSize(size) || size === 0 || !Number.isSafeInteger(block) || (block as number) <= 0) return null;
+  // A real calendar day: 2026-02-30 matches the pattern but is not one.
+  if (typeof date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(date) || !isDay(date) || !Array.isArray(components)) return null;
+  if (!components.every((c) => isObj(c) && typeof c.name === 'string' && isSize(c.size))) return null;
+  const proofs = (components as { name: string; size: number }[]).find((c) => c.name === 'proofs')?.size ?? 0;
+  if (proofs > size) return null;
+  return { size, sizeWithoutProofs: size - proofs, block: block as number, date, source: 'chain.base.org' };
+}
+
+// Throws on any failure so a failed fetch is not cached.
+export async function fetchArchiveSize(fetchImpl: typeof fetch = fetch): Promise<ArchiveSize> {
+  const res = await fetchImpl(ARCHIVE_SNAPSHOTS_URL, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+  if (!res.ok) throw new Error(`${ARCHIVE_SNAPSHOTS_URL}: ${res.status}`);
+  const archive = parseArchiveSize(await res.json());
+  if (!archive) throw new Error(`${ARCHIVE_SNAPSHOTS_URL}: unexpected response shape`);
+  return archive;
+}
+
+const fetchArchiveSizeCached = unstable_cache(() => fetchArchiveSize(), ['scaling-archive-size'], { revalidate: REVALIDATE_SECONDS });
+
+// Optional context: on failure the page keeps the snapshot's archive size.
+export async function loadArchiveSize(load: () => Promise<ArchiveSize> = fetchArchiveSizeCached): Promise<ArchiveSize | null> {
+  try {
+    return await load();
+  } catch (error) {
+    console.warn('[scaling] archive size from chain.base.org unavailable, using the snapshot value:', error);
+    return null;
+  }
+}
+
+// Only mainnet snapshots take the live mainnet archive size; testnet and synthetic ones keep their own.
+export function withArchiveSize(snapshot: Snapshot, archive: ArchiveSize | null): Snapshot {
+  if (!archive || !/\bmainnet\b/i.test(snapshot.network)) return snapshot;
+  return {
+    ...snapshot,
+    production: {
+      ...snapshot.production,
+      archiveBytes: { value: archive.size, asOf: archive.date, source: `chain.base.org snapshot, block ${archive.block.toLocaleString('en-US')}`, note: 'incl. proofs' },
+    },
+  };
+}