Integrate with test backend data

Dockerfile

@@ -9,20 +9,18 @@ ARG PNPM_VERSION=10.25.0
 
 # Build-time data-source configuration. HF Spaces "Variables" are NOT injected
 # into Docker RUN steps automatically — only into the final runtime — so we
-# bake the DuckDB-mode defaults here. `cache-hf-data.mjs` reads these to know
-# which dataset to clone and to apply lean cache mode (skip JSON-fallback
-# artifacts). Override at build time via `--build-arg HF_DATASET_REPO=...`.
-ARG DATA_BACKEND=duckdb
+# bake the selected backend here. `DATA_BACKEND=v2` reads `SNAPSHOT_URL`
+# directly; legacy DuckDB mode still clones `HF_DATASET_REPO` into the cache.
+# Override at build time via `--build-arg ...`.
+ARG DATA_BACKEND=v2
 ARG HF_DATASET_REPO=https://huggingface.co/datasets/evaleval/card_backend
-# Static prerender (`next build`) executes route handlers, which call
-# `getModelCards` etc. → `lib/duckdb-data.ts`, which requires
-# `LOCAL_PIPELINE_OUTPUT`. The cache populated by `cache-hf-data.mjs`
-# lives at `/app/.cache/hf-data`. `HF_DATA_OFFLINE=1` keeps the metadata
-# fetchers (`lib/hf-data.ts`) from attempting `evaleval/card_backend`
-# network reads with `revalidate: 0` (which Next 15 treats as dynamic
-# and fails the static export of `/`).
+ARG SNAPSHOT_URL=https://huggingface.co/datasets/evaleval/eval-cards-data/resolve/main/warehouse/2026-05-03T21-46-50Z
+# Static prerender (`next build`) executes route handlers. In legacy mode the
+# cache populated by `cache-hf-data.mjs` lives at `/app/.cache/hf-data`; in v2
+# the cache step is skipped and the app reads the pinned Stage J snapshot.
 ENV DATA_BACKEND=${DATA_BACKEND} \
     HF_DATASET_REPO=${HF_DATASET_REPO} \
+    SNAPSHOT_URL=${SNAPSHOT_URL} \
     LOCAL_PIPELINE_OUTPUT=/app/.cache/hf-data \
     HF_DATA_LOCAL_DIR=/app/.cache/hf-data \
     HF_DATA_OFFLINE=1
@@ -49,13 +47,15 @@ RUN pnpm run build
 FROM node:18-bullseye-slim AS runner
 WORKDIR /app
 
-# Runtime needs the same DuckDB-mode envs that the builder used. HF Space
-# Variables aren't set on this Space, and Docker multi-stage doesn't carry
-# ENVs across stages — without these, lib/duckdb-data.ts throws
-# "DATA_BACKEND=duckdb requires LOCAL_PIPELINE_OUTPUT" at request time and
-# every model/eval/developer endpoint returns empty.
+ARG DATA_BACKEND=v2
+ARG SNAPSHOT_URL=https://huggingface.co/datasets/evaleval/eval-cards-data/resolve/main/warehouse/2026-05-03T21-46-50Z
+
+# Runtime needs the same data-source envs that the builder used. Docker
+# multi-stage doesn't carry ENVs across stages, so keep backend selection and
+# snapshot/cache pointers explicit here too.
 ENV NODE_ENV=production \
-    DATA_BACKEND=duckdb \
+    DATA_BACKEND=${DATA_BACKEND} \
+    SNAPSHOT_URL=${SNAPSHOT_URL} \
     LOCAL_PIPELINE_OUTPUT=/app/.cache/hf-data \
     HF_DATA_LOCAL_DIR=/app/.cache/hf-data \
     HF_DATA_OFFLINE=1

app/page.tsx

@@ -244,7 +244,7 @@ export default async function HomePage() {
               <p className="mx-auto mt-2 max-w-2xl text-sm leading-6 text-[color:var(--fg-muted)]">
                 The current backend snapshot does not include{" "}
                 <code className="rounded-sm bg-[color:var(--bg-surface)] px-1.5 py-0.5 font-mono text-xs">
-                  corpus-aggregates.json
+                  headline.json
                 </code>
                 . When it does, this section will render the four corpus-level rollups.
               </p>

components/signals/corpus-dashboard.tsx

@@ -20,7 +20,7 @@ import {
   formatPercent,
 } from "./signal-utils"
 
-const CATEGORY_ORDER = ["agentic", "general", "knowledge", "reasoning", "safety", "other"]
+const CATEGORY_ORDER = ["Agentic", "General", "Knowledge", "Reasoning", "Safety", "Other"]
 
 const SOURCE_COLORS: Record<string, string> = {
   first_party: "bg-amber-500",
@@ -51,13 +51,21 @@ export function CorpusDashboard({
   }, [mode])
 
   const categoryKeys = useMemo(
-    () =>
-      CATEGORY_ORDER.filter((category) =>
-        aggregates.reproducibility.by_category[category] ||
-        aggregates.completeness.by_category[category] ||
-        aggregates.provenance.by_category[category] ||
-        aggregates.comparability.by_category[category]
-      ),
+    () => {
+      const available = new Set([
+        ...Object.keys(aggregates.reproducibility.by_category),
+        ...Object.keys(aggregates.completeness.by_category),
+        ...Object.keys(aggregates.provenance.by_category),
+        ...Object.keys(aggregates.comparability.by_category),
+      ])
+
+      return [
+        ...CATEGORY_ORDER.filter((category) => available.has(category)),
+        ...Array.from(available)
+          .filter((category) => !CATEGORY_ORDER.includes(category))
+          .sort((a, b) => a.localeCompare(b)),
+      ]
+    },
     [aggregates]
   )
 
@@ -190,25 +198,14 @@ function CompletenessSection({
       icon={<ClipboardCheck className="h-5 w-5" />}
       title="Reporting Completeness"
       subtitle="How much benchmark documentation is populated."
-      headline={formatPercent(block.completeness_score_mean)}
-      headlineLabel={`Median ${formatPercent(block.completeness_score_median)} across ${block.total_benchmarks.toLocaleString()} benchmarks`}
+      headline={formatPercent(block.completeness_avg)}
+      headlineLabel={`Range ${formatPercent(block.completeness_min)} to ${formatPercent(block.completeness_max)} across ${block.total_triples.toLocaleString()} reported score triples`}
     >
       {scores.length > 0 && <Histogram scores={scores} />}
-      <div className="mt-4 grid gap-2">
-        {Object.entries(block.per_field_population).slice(0, 10).map(([field, value]) => (
-          <div key={field} className="rounded-xl border border-border/60 bg-background px-3 py-2">
-            <div className="flex items-start justify-between gap-3 text-sm">
-              <span className="font-medium">{formatFieldLabel(field)}</span>
-              <span className="shrink-0 tabular-nums text-muted-foreground">
-                {formatPercent(value.mean_score)}
-              </span>
-            </div>
-            <div className="mt-2 grid gap-1.5">
-              <MetricBar label="Any data" value={value.populated_rate} compact />
-              <MetricBar label="Fully populated" value={value.fully_populated_rate} compact />
-            </div>
-          </div>
-        ))}
+      <div className="mt-4 grid gap-2 sm:grid-cols-3">
+        <MiniMetric label="Minimum" value={formatPercent(block.completeness_min)} />
+        <MiniMetric label="Average" value={formatPercent(block.completeness_avg)} />
+        <MiniMetric label="Maximum" value={formatPercent(block.completeness_max)} />
       </div>
     </DashboardSection>
   )
@@ -217,14 +214,16 @@ function CompletenessSection({
 function ProvenanceSection({ block }: { block: ProvenanceCorpusBlock }) {
   const distribution = block.source_type_distribution
   const total = Object.values(distribution).reduce((sum, value) => sum + value, 0)
+  const multiSourceRate = rate(block.multi_source_triples, block.total_triples)
+  const firstPartyOnlyRate = rate(block.first_party_only_triples, block.total_triples)
 
   return (
     <DashboardSection
       icon={<BarChart3 className="h-5 w-5" />}
       title="Provenance"
       subtitle="Who reported the scores, and whether groups have multiple sources."
-      headline={formatPercent(block.multi_source_rate)}
-      headlineLabel="of (model, benchmark, metric) groups have multiple reporting sources"
+      headline={formatPercent(multiSourceRate)}
+      headlineLabel="of reported score triples have multiple reporting sources"
     >
       <div className="overflow-hidden rounded-full border border-border/70 bg-muted/30">
         <div className="flex h-4 w-full">
@@ -240,34 +239,40 @@ function ProvenanceSection({ block }: { block: ProvenanceCorpusBlock }) {
       </div>
 
       <div className="mt-3 grid gap-2 sm:grid-cols-2">
-        <RatioTile label="Multi-source groups" value={block.multi_source_rate} count={block.multi_source_groups} />
-        <RatioTile label="First-party only groups" value={block.first_party_only_rate} count={block.first_party_only_groups} />
+        <RatioTile label="Multi-source triples" value={multiSourceRate} count={block.multi_source_triples} />
+        <RatioTile label="First-party only triples" value={firstPartyOnlyRate} count={block.first_party_only_triples} />
       </div>
     </DashboardSection>
   )
 }
 
 function ComparabilitySection({ block }: { block: ComparabilityCorpusBlock }) {
+  const variantRate = rate(block.variant_divergent_count, block.groups_with_variant_check)
+  const crossPartyRate = rate(
+    block.cross_party_divergent_count,
+    block.groups_with_cross_party_check
+  )
+
   return (
     <DashboardSection
       icon={<GitCompareArrows className="h-5 w-5" />}
       title="Comparability"
       subtitle="Eligible groups where scores diverge across setups or reporting organizations."
-      headline={formatNullableRate(block.variant_divergence_rate)}
-      headlineLabel={`${block.variant_divergent_groups.toLocaleString()} of ${block.variant_eligible_groups.toLocaleString()} setup-eligible groups diverge`}
+      headline={formatNullableRate(variantRate)}
+      headlineLabel={`${block.variant_divergent_count.toLocaleString()} of ${block.groups_with_variant_check.toLocaleString()} setup-eligible groups diverge`}
     >
       <div className="grid gap-3 md:grid-cols-2">
         <ComparabilityRateCard
           title="Variant divergence"
-          rate={block.variant_divergence_rate}
-          eligible={block.variant_eligible_groups}
-          divergent={block.variant_divergent_groups}
+          rate={variantRate}
+          eligible={block.groups_with_variant_check}
+          divergent={block.variant_divergent_count}
         />
         <ComparabilityRateCard
           title="Cross-party divergence"
-          rate={block.cross_party_divergence_rate}
-          eligible={block.cross_party_eligible_groups}
-          divergent={block.cross_party_divergent_groups}
+          rate={crossPartyRate}
+          eligible={block.groups_with_cross_party_check}
+          divergent={block.cross_party_divergent_count}
         />
       </div>
     </DashboardSection>
@@ -288,6 +293,15 @@ function CategoryPanel({
   comparability?: ComparabilityCorpusBlock
 }) {
   const categoryLabel = `${category.charAt(0).toUpperCase()}${category.slice(1)}`
+  const multiSourceRate = rate(provenance?.multi_source_triples, provenance?.total_triples)
+  const variantRate = rate(
+    comparability?.variant_divergent_count,
+    comparability?.groups_with_variant_check
+  )
+  const crossPartyRate = rate(
+    comparability?.cross_party_divergent_count,
+    comparability?.groups_with_cross_party_check
+  )
 
   return (
     <section className="rounded-2xl border border-border/70 bg-card p-4 shadow-sm">
@@ -297,11 +311,11 @@ function CategoryPanel({
       </div>
       <div className="grid gap-3 sm:grid-cols-2">
         <MiniMetric label="Reproducibility gaps" value={formatPercent(reproducibility?.reproducibility_gap_rate)} />
-        <MiniMetric label="Documentation mean" value={formatPercent(completeness?.completeness_score_mean)} />
-        <MiniMetric label="Multi-source groups" value={formatPercent(provenance?.multi_source_rate)} />
-        <MiniMetric label="Variant divergence" value={formatNullableRate(comparability?.variant_divergence_rate)} />
+        <MiniMetric label="Documentation mean" value={formatPercent(completeness?.completeness_avg)} />
+        <MiniMetric label="Multi-source triples" value={formatPercent(multiSourceRate)} />
+        <MiniMetric label="Variant divergence" value={formatNullableRate(variantRate)} />
       </div>
-      {comparability?.cross_party_divergence_rate == null && (
+      {crossPartyRate == null && (
         <div className="mt-3 rounded-xl border border-dashed border-border/70 bg-muted/10 px-3 py-2 text-sm text-muted-foreground">
           Cross-party divergence: N/A - not enough multi-org coverage.
         </div>
@@ -411,7 +425,7 @@ function RatioTile({ label, value, count }: { label: string; value: number | nul
       <div className="text-sm font-medium">{label}</div>
       <div className="mt-1 flex items-baseline justify-between gap-2">
         <span className="text-xl font-semibold tabular-nums">{formatPercent(value)}</span>
-        <span className="text-xs text-muted-foreground">{count.toLocaleString()} groups</span>
+        <span className="text-xs text-muted-foreground">{count.toLocaleString()} triples</span>
       </div>
     </div>
   )
@@ -463,6 +477,11 @@ function formatNullableRate(value: number | null | undefined) {
   return value == null ? "N/A" : formatPercent(value)
 }
 
+function rate(numerator: number | null | undefined, denominator: number | null | undefined) {
+  if (numerator == null || denominator == null || denominator <= 0) return null
+  return numerator / denominator
+}
+
 function formatGeneratedDate(value: string) {
   const date = new Date(value)
   if (Number.isNaN(date.getTime())) {

components/signals/corpus-signals-strip.tsx

@@ -39,8 +39,13 @@ export function CorpusSignalsStrip({
   const tpShare = totalReports > 0 ? prov.source_type_distribution.third_party / totalReports : 0
   const fpShare = totalReports > 0 ? prov.source_type_distribution.first_party / totalReports : 0
 
-  const cmpRate = cmp.variant_divergence_rate
-  const crossPartyAvailable = cmp.cross_party_eligible_groups > 0
+  const multiSourceRate = rate(prov.multi_source_triples, prov.total_triples)
+  const cmpRate = rate(cmp.variant_divergent_count, cmp.groups_with_variant_check)
+  const crossPartyRate = rate(
+    cmp.cross_party_divergent_count,
+    cmp.groups_with_cross_party_check
+  )
+  const crossPartyAvailable = cmp.groups_with_cross_party_check > 0
 
   return (
     <div className="signals-grid">
@@ -58,29 +63,29 @@ export function CorpusSignalsStrip({
       />
       <SignalTile
         id="completeness"
-        statValue={pctNum(comp.completeness_score_mean)}
+        statValue={pctNum(comp.completeness_avg)}
         statUnit="%"
-        headline={`mean across ${comp.total_benchmarks.toLocaleString()} benchmarks (median ${formatPct(comp.completeness_score_median)}).`}
-        detail="Source-provenance fields populate fully; preregistration fields are unmet."
+        headline={`mean across ${comp.total_triples.toLocaleString()} reported score triples.`}
+        detail={`Observed range: ${formatPct(comp.completeness_min)} to ${formatPct(comp.completeness_max)}.`}
         asks="Is the benchmark itself documented well enough to interpret a score on it?"
       />
       <SignalTile
         id="provenance"
-        statValue={pctNum(prov.multi_source_rate)}
+        statValue={pctNum(multiSourceRate)}
         statUnit="%"
-        headline="of (model, benchmark) groups have reports from more than one party."
-        detail={`${formatPct(tpShare)} third-party, ${formatPct(fpShare)} first-party of ${totalReports.toLocaleString()} results.`}
+        headline="of reported score triples have reports from more than one party."
+        detail={`${formatPct(tpShare)} third-party, ${formatPct(fpShare)} first-party of ${totalReports.toLocaleString()} triples.`}
         asks="Who reported this score, and have others reproduced it?"
       />
       <SignalTile
         id="comparability"
         statValue={pctNum(cmpRate)}
         statUnit="%"
-        headline={`of setup-eligible groups diverge across variants (${cmp.variant_divergent_groups.toLocaleString()} of ${cmp.variant_eligible_groups.toLocaleString()}).`}
+        headline={`of setup-eligible groups diverge across variants (${cmp.variant_divergent_count.toLocaleString()} of ${cmp.groups_with_variant_check.toLocaleString()}).`}
         detail={
           crossPartyAvailable
-            ? `Cross-party divergence: ${formatPct(cmp.cross_party_divergence_rate)}.`
-            : "Cross-party divergence not yet computable — too few multi-org reports."
+            ? `Cross-party divergence: ${formatPct(crossPartyRate)}.`
+            : "Cross-party divergence not yet computable: too few multi-org reports."
         }
         asks="Are scores on the same benchmark actually measuring the same thing?"
       />
@@ -154,6 +159,11 @@ function formatPct(value: number | null | undefined): string {
   return `${Math.round(value * 100)}%`
 }
 
+function rate(numerator: number | null | undefined, denominator: number | null | undefined) {
+  if (numerator == null || denominator == null || denominator <= 0) return null
+  return numerator / denominator
+}
+
 const FIELD_LABELS: Record<string, string> = {
   temperature: "temperature",
   max_tokens: "max tokens",

lib/backend-artifacts.ts

@@ -12,6 +12,7 @@ export interface BackendManifest {
   skipped_config_count?: number
   summary_artifacts?: {
     corpus_aggregates?: string
+    eval_hierarchy?: string
     [key: string]: string | undefined
   }
 }
@@ -177,6 +178,27 @@ export interface CorpusAggregates {
   completeness: Stratified<CompletenessCorpusBlock>
   provenance: Stratified<ProvenanceCorpusBlock>
   comparability: Stratified<ComparabilityCorpusBlock>
+  developers?: DeveloperListEntry[]
+  families?: Array<{
+    family_key: string
+    display_name: string
+    model_count: number
+    eval_count: number
+  }>
+  categories?: Array<{
+    category: string
+    model_count: number
+    eval_count: number
+  }>
+}
+
+export interface DeveloperListEntry {
+  developer: string
+  route_id: string
+  model_count: number
+  benchmark_count: number
+  evaluation_count: number
+  popular_evals: Array<{ benchmark: string; model_count: number }>
 }
 
 export interface Stratified<T> {
@@ -198,35 +220,25 @@ export interface ReproducibilityCorpusBlock {
 }
 
 export interface CompletenessCorpusBlock {
-  total_benchmarks: number
-  completeness_score_mean: number | null
-  completeness_score_median: number | null
-  per_field_population: Record<string, {
-    mean_score: number
-    populated_rate: number
-    fully_populated_rate: number
-    benchmark_count: number
-  }>
+  total_triples: number
+  completeness_avg: number | null
+  completeness_min: number | null
+  completeness_max: number | null
 }
 
 export interface ProvenanceCorpusBlock {
   total_triples: number
-  total_groups: number
-  multi_source_groups: number
-  multi_source_rate: number | null
-  first_party_only_groups: number
-  first_party_only_rate: number | null
+  multi_source_triples: number
+  first_party_only_triples: number
   source_type_distribution: Record<ProvenanceSourceType, number>
 }
 
 export interface ComparabilityCorpusBlock {
-  total_groups: number
-  variant_eligible_groups: number
-  variant_divergent_groups: number
-  variant_divergence_rate: number | null
-  cross_party_eligible_groups: number
-  cross_party_divergent_groups: number
-  cross_party_divergence_rate: number | null
+  total_triples: number
+  variant_divergent_count: number
+  cross_party_divergent_count: number
+  groups_with_variant_check: number
+  groups_with_cross_party_check: number
 }
 
 export interface HierarchyTags {

lib/benchmark-schema.ts

@@ -124,6 +124,7 @@ export interface ScoreDetails {
 }
 
 export interface GenerationConfig {
+  num_few_shot?: number
   generation_args?: {
     temperature?: number
     top_p?: number

lib/data-backend.ts

@@ -1,27 +1,138 @@
 import "server-only"
 
-import {
-  fetchBackendManifest,
-  fetchBackendManifestStatus,
-  fetchEvalHierarchy,
-} from "@/lib/hf-data"
-
-export {
-  getDashboardDataFromDuckDB as getDashboardData,
-  getModelCardsFromDuckDB as getModelCards,
-  getModelCardsLiteFromDuckDB as getModelCardsLite,
-  getEvalListDataFromDuckDB as getEvalListData,
-  getEvalListLiteDataFromDuckDB as getEvalListLiteData,
-  getEvalListFromDuckDB as getEvalList,
-  getDeveloperListFromDuckDB as getDeveloperList,
-  getDeveloperSummaryByIdFromDuckDB as getDeveloperSummaryById,
-  getModelSummaryByIdFromDuckDB as getModelSummaryById,
-  getEvalSummaryByIdFromDuckDB as getEvalSummaryById,
-} from "@/lib/duckdb-data"
-
-// Metadata-style artifacts are still read through the existing JSON/HF path.
-// They are not request-time processing hotspots and the DuckDB shadow doesn't
-// re-shape them, so calling lib/hf-data directly avoids needless indirection.
-export const getBackendManifestData = fetchBackendManifest
-export const getBackendManifestStatusData = fetchBackendManifestStatus
-export const getEvalHierarchyData = fetchEvalHierarchy
+import type { BackendManifestStatus } from "@/lib/backend-artifacts"
+
+const BACKEND_VERSION = process.env.DATA_BACKEND?.trim().toLowerCase() ?? "duckdb"
+
+function useViewLayerBackend() {
+  return BACKEND_VERSION === "v2" || BACKEND_VERSION === "stage-j"
+}
+
+async function legacyBackend() {
+  return import("@/lib/duckdb-data")
+}
+
+async function viewBackend() {
+  return import("@/lib/view-data")
+}
+
+async function sidecars() {
+  return import("@/lib/sidecars")
+}
+
+async function hfData() {
+  return import("@/lib/hf-data")
+}
+
+export async function getModelCards() {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getModelCards()
+  }
+
+  return (await legacyBackend()).getModelCardsFromDuckDB()
+}
+
+export async function getModelCardsLite() {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getModelCardsLite()
+  }
+
+  return (await legacyBackend()).getModelCardsLiteFromDuckDB()
+}
+
+export async function getEvalListData() {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getEvalListData()
+  }
+
+  return (await legacyBackend()).getEvalListDataFromDuckDB()
+}
+
+export async function getEvalListLiteData() {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getEvalListLiteData()
+  }
+
+  return (await legacyBackend()).getEvalListLiteDataFromDuckDB()
+}
+
+export async function getEvalList() {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getEvalList()
+  }
+
+  return (await legacyBackend()).getEvalListFromDuckDB()
+}
+
+export async function getDashboardData() {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getDashboardData()
+  }
+
+  return (await legacyBackend()).getDashboardDataFromDuckDB()
+}
+
+export async function getDeveloperList() {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getDeveloperList()
+  }
+
+  return (await legacyBackend()).getDeveloperListFromDuckDB()
+}
+
+export async function getDeveloperSummaryById(routeId: string) {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getDeveloperSummaryById(routeId)
+  }
+
+  return (await legacyBackend()).getDeveloperSummaryByIdFromDuckDB(routeId)
+}
+
+export async function getModelSummaryById(modelId: string) {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getModelSummaryById(modelId)
+  }
+
+  return (await legacyBackend()).getModelSummaryByIdFromDuckDB(modelId)
+}
+
+export async function getEvalSummaryById(evalId: string) {
+  if (useViewLayerBackend()) {
+    return (await viewBackend()).getEvalSummaryById(evalId)
+  }
+
+  return (await legacyBackend()).getEvalSummaryByIdFromDuckDB(evalId)
+}
+
+export async function getBackendManifestData() {
+  if (useViewLayerBackend()) {
+    return (await sidecars()).fetchManifest()
+  }
+
+  return (await hfData()).fetchBackendManifest()
+}
+
+export async function getBackendManifestStatusData(): Promise<BackendManifestStatus> {
+  if (useViewLayerBackend()) {
+    const manifest = await (await sidecars()).fetchManifest()
+    return {
+      currentManifest: manifest,
+      latestManifest: manifest,
+      currentManifestSignature: manifest.generated_at,
+      latestManifestSignature: manifest.generated_at,
+      updateAvailable: false,
+      refreshing: false,
+      pendingRefreshCount: 0,
+    }
+  }
+
+  return (await hfData()).fetchBackendManifestStatus()
+}
+
+export async function getEvalHierarchyData() {
+  if (useViewLayerBackend()) {
+    return (await sidecars()).fetchHierarchy()
+  }
+
+  return (await hfData()).fetchEvalHierarchy()
+}

lib/duckdb.ts

@@ -0,0 +1,46 @@
+import "server-only"
+
+import { DuckDBConnection } from "@duckdb/node-api"
+
+let connectionPromise: Promise<DuckDBConnection> | null = null
+
+function getSnapshotUrl() {
+  const snapshotUrl = process.env.SNAPSHOT_URL?.trim()
+  if (!snapshotUrl) {
+    throw new Error("DATA_BACKEND=v2 requires SNAPSHOT_URL to point at a Stage J snapshot directory")
+  }
+
+  return snapshotUrl.replace(/\/+$/, "")
+}
+
+function snapshotArtifact(name: string) {
+  return `${getSnapshotUrl()}/${name}`
+}
+
+function sqlString(value: string) {
+  return `'${value.replace(/'/g, "''")}'`
+}
+
+const VIEW_FILES = {
+  models_view: "models_view.parquet",
+  evals_view: "evals_view.parquet",
+  eval_results_view: "eval_results_view.parquet",
+} as const
+
+export async function getConnection(): Promise<DuckDBConnection> {
+  if (!connectionPromise) {
+    connectionPromise = (async () => {
+      const connection = await DuckDBConnection.create()
+
+      for (const [viewName, fileName] of Object.entries(VIEW_FILES)) {
+        await connection.run(
+          `CREATE OR REPLACE VIEW ${viewName} AS SELECT * FROM read_parquet(${sqlString(snapshotArtifact(fileName))})`
+        )
+      }
+
+      return connection
+    })()
+  }
+
+  return connectionPromise
+}

lib/hf-data.ts

@@ -138,6 +138,15 @@ function getManifestSignature(manifest: BackendManifest | null | undefined) {
 // reading the same on-disk artifacts cannot diverge mid-test via background
 // refresh, and useful generally for offline development.
 const OFFLINE = process.env.HF_DATA_OFFLINE === "1"
+const DATA_BACKEND_VERSION = process.env.DATA_BACKEND?.trim().toLowerCase()
+
+function useViewLayerBackend() {
+  return DATA_BACKEND_VERSION === "v2" || DATA_BACKEND_VERSION === "stage-j"
+}
+
+async function fetchSnapshotSidecars() {
+  return import("@/lib/sidecars")
+}
 
 async function fetchRemoteJson<T>(relativePath: string): Promise<T> {
   if (OFFLINE) {
@@ -423,6 +432,19 @@ async function fetchHFJson<T>(relativePath: string): Promise<T> {
 }
 
 export async function fetchBackendManifestStatus(): Promise<BackendManifestStatus> {
+  if (useViewLayerBackend()) {
+    const manifest = await (await fetchSnapshotSidecars()).fetchManifest()
+    return {
+      currentManifest: manifest,
+      latestManifest: manifest,
+      currentManifestSignature: manifest.generated_at,
+      latestManifestSignature: manifest.generated_at,
+      updateAvailable: false,
+      refreshing: false,
+      pendingRefreshCount: 0,
+    }
+  }
+
   const snapshot = await getManifestSnapshot()
   const currentManifest = getCurrentManifestFromSnapshot(snapshot)
   const currentManifestSignature = getManifestSignature(currentManifest)
@@ -864,14 +886,26 @@ export async function fetchDevelopersList(): Promise<HFDeveloperEntry[]> {
 }
 
 export async function fetchBenchmarkMetadataMap(): Promise<Record<string, BenchmarkCard>> {
+  if (useViewLayerBackend()) {
+    return (await import("@/lib/view-data")).getBenchmarkMetadataMap()
+  }
+
   return fetchHFJson<Record<string, BenchmarkCard>>("benchmark-metadata.json")
 }
 
 export async function fetchBackendManifest(): Promise<BackendManifest> {
+  if (useViewLayerBackend()) {
+    return (await fetchSnapshotSidecars()).fetchManifest()
+  }
+
   return fetchHFJson<BackendManifest>("manifest.json")
 }
 
 export async function fetchEvalHierarchy(): Promise<EvalHierarchy> {
+  if (useViewLayerBackend()) {
+    return adaptEvalHierarchy(await (await fetchSnapshotSidecars()).fetchHierarchy())
+  }
+
   const raw = await fetchHFJson<EvalHierarchy>("eval-hierarchy.json")
   return adaptEvalHierarchy(raw)
 }
@@ -975,6 +1009,10 @@ export async function fetchComparisonIndex(): Promise<ComparisonIndex> {
 }
 
 export async function fetchCorpusAggregates(): Promise<CorpusAggregates | null> {
+  if (useViewLayerBackend()) {
+    return (await fetchSnapshotSidecars()).fetchHeadline()
+  }
+
   return fetchHFJsonSafe<CorpusAggregates>("corpus-aggregates.json")
 }
 

lib/sidecars.ts

@@ -0,0 +1,59 @@
+import "server-only"
+
+import type {
+  BackendManifest,
+  CorpusAggregates,
+  EvalHierarchy,
+} from "@/lib/backend-artifacts"
+
+let cache: {
+  manifest?: Promise<BackendManifest>
+  headline?: Promise<CorpusAggregates>
+  hierarchy?: Promise<EvalHierarchy>
+} = {}
+
+function getSnapshotUrl() {
+  const snapshotUrl = process.env.SNAPSHOT_URL?.trim()
+  if (!snapshotUrl) {
+    throw new Error("DATA_BACKEND=v2 requires SNAPSHOT_URL to point at a Stage J snapshot directory")
+  }
+
+  return snapshotUrl.replace(/\/+$/, "")
+}
+
+function sidecarUrl(name: string) {
+  return `${getSnapshotUrl()}/${name}`
+}
+
+async function fetchJson<T>(name: string): Promise<T> {
+  const url = sidecarUrl(name)
+
+  if (url.startsWith("file://")) {
+    const fs = await import("fs/promises")
+    const text = await fs.readFile(new URL(url), "utf8")
+    return JSON.parse(text) as T
+  }
+
+  const response = await fetch(url, { next: { revalidate: 3600 } })
+  if (!response.ok) {
+    throw new Error(`Snapshot sidecar fetch failed: ${response.status} ${response.statusText} for ${url}`)
+  }
+
+  return (await response.json()) as T
+}
+
+export function fetchManifest(): Promise<BackendManifest> {
+  return (cache.manifest ??= fetchJson<BackendManifest>("manifest.json"))
+}
+
+export function fetchHeadline(): Promise<CorpusAggregates> {
+  return (cache.headline ??= fetchJson<CorpusAggregates>("headline.json"))
+}
+
+export function fetchHierarchy(): Promise<EvalHierarchy> {
+  return (cache.hierarchy ??= fetchJson<EvalHierarchy>("hierarchy.json"))
+}
+
+export function resetSidecarCacheForTests() {
+  cache = {}
+}

lib/view-data.ts

@@ -0,0 +1,569 @@
+import "server-only"
+
+import { getConnection } from "@/lib/duckdb"
+import { fetchHeadline } from "@/lib/sidecars"
+import {
+  EVALUATION_CATEGORIES,
+  type BenchmarkCard,
+  type BenchmarkEvaluation,
+  type CategoryType,
+  type EvaluationCardData,
+  type EvaluationResult,
+  type GenerationConfig,
+  type MetricConfig,
+  type ModelInfo,
+  type ModelEvaluationSummary,
+  type ModelVariantSummary,
+  type ScoreDetails,
+  type SourceData,
+  type SourceMetadata,
+} from "@/lib/benchmark-schema"
+import type { DeveloperListEntry } from "@/lib/backend-artifacts"
+import type {
+  BenchmarkEvalListItem,
+  BenchmarkEvalSummary,
+  ModelResultForBenchmark,
+} from "@/lib/eval-processing"
+
+type Row = Record<string, any>
+
+const MODEL_CARD_COLUMNS = `
+  id, route_id, model_name, model_id, canonical_model_name, developer,
+  evaluations_count, benchmarks_count, variant_count,
+  categories, category_stats, latest_timestamp,
+  evaluator_count, evaluator_names, source_type_count, source_types,
+  evidence_count, missing_generation_config_count,
+  third_party_eval_count, independent_verification_ratio,
+  reproducibility_status, eval_libraries, latest_source_name,
+  params_billions, benchmark_names, score_summary,
+  reproducibility_summary, provenance_summary, comparability_summary,
+  top_scores, source_urls, detail_urls,
+  model_url, release_date, input_modalities, output_modalities,
+  architecture, params, inference_engine, inference_platform
+`
+
+const EVAL_LIST_COLUMNS = `
+  evaluation_id, evaluation_name, canonical_display_name,
+  composite_benchmark_key, composite_benchmark_name,
+  benchmark_family_key, benchmark_leaf_key, category,
+  metric_config, models_count, evaluator_names, source_types,
+  latest_source_name, third_party_ratio,
+  missing_generation_config_count, best_model, worst_model,
+  avg_score, avg_score_norm, has_card, benchmark_card,
+  is_aggregated, aggregate_sources, tags,
+  metrics_count, metric_names, instance_data, top_score,
+  subtasks_count, is_summary_score, summary_eval_ids,
+  root_metrics, subtasks, leaderboard_metrics,
+  reproducibility_summary, provenance_summary, comparability_summary,
+  source_data
+`
+
+const CELL_JOIN_COLUMNS = `
+  r.*,
+  e.evaluation_name AS eval_evaluation_name,
+  e.canonical_display_name AS eval_canonical_display_name,
+  e.composite_benchmark_key AS eval_composite_benchmark_key,
+  e.composite_benchmark_name AS eval_composite_benchmark_name,
+  e.benchmark_family_key AS eval_benchmark_family_key,
+  e.benchmark_leaf_key AS eval_benchmark_leaf_key,
+  e.category AS eval_category,
+  e.metric_config AS eval_metric_config,
+  e.source_data AS eval_source_data,
+  e.benchmark_card AS eval_benchmark_card,
+  e.tags AS eval_tags,
+  e.is_summary_score AS eval_is_summary_score,
+  e.summary_eval_ids AS eval_summary_eval_ids
+`
+
+function normalizeDuckDBValue(value: unknown): unknown {
+  if (typeof value === "bigint") {
+    return Number(value)
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString()
+  }
+
+  if (value instanceof Map) {
+    return Object.fromEntries(
+      Array.from(value.entries()).map(([key, mapValue]) => [String(key), normalizeDuckDBValue(mapValue)])
+    )
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(normalizeDuckDBValue)
+  }
+
+  if (value && typeof value === "object") {
+    const duckValue = value as {
+      constructor?: { name?: string }
+      entries?: unknown
+      items?: unknown
+      scale?: unknown
+      value?: unknown
+      toString?: () => string
+    }
+    const constructorName = duckValue.constructor?.name ?? ""
+
+    if (constructorName === "DuckDBStructValue" && duckValue.entries && typeof duckValue.entries === "object") {
+      return normalizeDuckDBValue(duckValue.entries)
+    }
+
+    if (
+      (constructorName === "DuckDBListValue" || constructorName === "DuckDBArrayValue") &&
+      Array.isArray(duckValue.items)
+    ) {
+      return duckValue.items.map(normalizeDuckDBValue)
+    }
+
+    if (constructorName === "DuckDBMapValue" && Array.isArray(duckValue.entries)) {
+      return Object.fromEntries(
+        duckValue.entries.map((entry) => {
+          const pair = entry as { key: unknown; value: unknown }
+          return [String(pair.key), normalizeDuckDBValue(pair.value)]
+        })
+      )
+    }
+
+    if (constructorName === "DuckDBDecimalValue" && typeof duckValue.toString === "function") {
+      return Number(duckValue.toString())
+    }
+
+    if (constructorName.startsWith("DuckDB") && typeof duckValue.toString === "function") {
+      return duckValue.toString()
+    }
+
+    return Object.fromEntries(
+      Object.entries(value).map(([key, objectValue]) => [key, normalizeDuckDBValue(objectValue)])
+    )
+  }
+
+  return value
+}
+
+async function readRows<T = Row>(sql: string, params: unknown[] = []): Promise<T[]> {
+  const connection = await getConnection()
+  const reader = params.length > 0
+    ? await connection.runAndReadAll(sql, params as any[])
+    : await connection.runAndReadAll(sql)
+  return reader.getRowObjects().map((row) => normalizeDuckDBValue(row) as T)
+}
+
+function asNumber(value: unknown, fallback = 0) {
+  if (typeof value === "number" && Number.isFinite(value)) return value
+  if (typeof value === "bigint") return Number(value)
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return fallback
+}
+
+function optionalNumber(value: unknown) {
+  if (value == null) return undefined
+  const parsed = asNumber(value, Number.NaN)
+  return Number.isFinite(parsed) ? parsed : undefined
+}
+
+function asString(value: unknown, fallback = "") {
+  return typeof value === "string" ? value : fallback
+}
+
+function optionalString(value: unknown) {
+  return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
+function asArray<T>(value: unknown): T[] {
+  return Array.isArray(value) ? value as T[] : []
+}
+
+function normalizeCategory(value: unknown): CategoryType {
+  return EVALUATION_CATEGORIES.includes(value as CategoryType)
+    ? value as CategoryType
+    : "General"
+}
+
+function emptyEvaluationsByCategory(): Record<CategoryType, BenchmarkEvaluation[]> {
+  return EVALUATION_CATEGORIES.reduce((acc, category) => {
+    acc[category] = []
+    return acc
+  }, {} as Record<CategoryType, BenchmarkEvaluation[]>)
+}
+
+function sourceMetadataFromRow(row: Row): SourceMetadata {
+  if (row.source_metadata && typeof row.source_metadata === "object") {
+    return row.source_metadata as SourceMetadata
+  }
+
+  return {
+    source_type: "documentation",
+    source_organization_name: asString(row.latest_source_name, "Unknown"),
+    evaluator_relationship: "other",
+  }
+}
+
+function sourceDataFromRow(row: Row): BenchmarkEvaluation["source_data"] {
+  const sourceData = row.source_data ?? row.eval_source_data
+  if (sourceData) {
+    return sourceData as BenchmarkEvaluation["source_data"]
+  }
+
+  return {
+    dataset_name: asString(row.eval_evaluation_name ?? row.evaluation_name ?? row.benchmark_id, "Unknown dataset"),
+  } satisfies SourceData
+}
+
+function scoreDetailsFromRow(row: Row): ScoreDetails {
+  const details = row.score_details && typeof row.score_details === "object"
+    ? row.score_details as Partial<ScoreDetails>
+    : {}
+  const score = asNumber(details.score ?? row.score)
+
+  return {
+    ...details,
+    score,
+  } as ScoreDetails
+}
+
+function metricConfigFromRow(row: Row): MetricConfig {
+  const config = (row.metric_config ?? row.eval_metric_config ?? {}) as Partial<MetricConfig>
+  const scoreType = config.score_type === "binary" || config.score_type === "discrete"
+    ? config.score_type
+    : "continuous"
+
+  return {
+    evaluation_description: asString(
+      config.evaluation_description ??
+        row.metric_description ??
+        row.metric_display_name ??
+        row.eval_evaluation_name ??
+        row.evaluation_name,
+      ""
+    ),
+    lower_is_better: Boolean(row.lower_is_better ?? config.lower_is_better ?? false),
+    score_type: scoreType,
+    min_score: optionalNumber(config.min_score ?? row.min_score),
+    max_score: optionalNumber(config.max_score ?? row.max_score),
+    unit: optionalString(row.metric_unit ?? config.unit),
+  }
+}
+
+function modelInfoFromModelRow(row: Row): ModelInfo {
+  return {
+    name: asString(row.model_name ?? row.model_family_name ?? row.model_id, "Unknown model"),
+    id: asString(row.model_id ?? row.id ?? row.route_id, "unknown-model"),
+    developer: optionalString(row.developer),
+    inference_platform: optionalString(row.inference_platform),
+    inference_engine: optionalString(row.inference_engine),
+    architecture: optionalString(row.architecture),
+    parameter_count: optionalString(row.params),
+    release_date: optionalString(row.release_date),
+    model_url: optionalString(row.model_url),
+    additional_details: {
+      params_billions: row.params_billions,
+    },
+    modalities: {
+      input: asArray<string>(row.input_modalities),
+      output: asArray<string>(row.output_modalities),
+    },
+  }
+}
+
+function resultFromCell(row: Row): EvaluationResult {
+  const scoreDetails = scoreDetailsFromRow(row)
+  const generationConfig = row.generation_config as GenerationConfig | undefined
+  const annotations = row.evalcards_annotations
+
+  return {
+    evaluation_name: asString(row.metric_display_name ?? row.eval_evaluation_name ?? row.metric_id, "Score"),
+    display_name: optionalString(row.metric_display_name),
+    canonical_display_name: optionalString(row.metric_display_name),
+    metric_summary_id: optionalString(row.metric_summary_id),
+    metric_key: optionalString(row.metric_id),
+    evaluation_timestamp: asString(row.evaluation_timestamp, ""),
+    source_data: sourceDataFromRow(row),
+    metric_config: metricConfigFromRow(row),
+    score_details: scoreDetails,
+    generation_config: generationConfig,
+    detailed_evaluation_results_url: optionalString(row.instance_file_path),
+    evalcards: annotations ? { annotations } : undefined,
+  }
+}
+
+function reshapeCellToModelResult(row: Row): ModelResultForBenchmark {
+  const scoreDetails = scoreDetailsFromRow(row)
+
+  return {
+    model_info: (row.model_info ?? modelInfoFromModelRow(row)) as ModelInfo,
+    model_route_id: optionalString(row.model_route_id),
+    score: scoreDetails.score,
+    score_details: scoreDetails,
+    evaluation_timestamp: asString(row.evaluation_timestamp, ""),
+    source_metadata: sourceMetadataFromRow(row),
+    source_data: sourceDataFromRow(row),
+    source_record_url: optionalString(row.source_record_url),
+    aggregate_components: asArray<NonNullable<ModelResultForBenchmark["aggregate_components"]>[number]>(
+      row.aggregate_components
+    ),
+    result: resultFromCell(row),
+  }
+}
+
+function reshapeCellToBenchmarkEvaluation(row: Row): BenchmarkEvaluation {
+  const result = resultFromCell(row)
+  const modelInfo = (row.model_info ?? modelInfoFromModelRow(row)) as ModelInfo
+
+  return {
+    schema_version: "1.0",
+    eval_summary_id: optionalString(row.evaluation_id),
+    evaluation_id: asString(row.evaluation_id ?? row.benchmark_id, "unknown-evaluation"),
+    retrieved_timestamp: asString(row.evaluation_timestamp, ""),
+    benchmark: optionalString(row.eval_evaluation_name ?? row.benchmark_id),
+    display_name: optionalString(row.eval_evaluation_name),
+    canonical_display_name: optionalString(row.eval_canonical_display_name),
+    category: normalizeCategory(row.eval_category ?? row.category),
+    benchmark_family_key: optionalString(row.eval_benchmark_family_key),
+    benchmark_family_name: optionalString(row.eval_composite_benchmark_name),
+    benchmark_parent_key: optionalString(row.eval_composite_benchmark_key),
+    benchmark_parent_name: optionalString(row.eval_composite_benchmark_name),
+    benchmark_leaf_key: optionalString(row.eval_benchmark_leaf_key),
+    benchmark_leaf_name: optionalString(row.eval_evaluation_name),
+    is_summary_score: Boolean(row.eval_is_summary_score ?? row.is_summary_score),
+    source_data: sourceDataFromRow(row),
+    source_metadata: sourceMetadataFromRow(row),
+    eval_library: row.eval_library,
+    model_info: modelInfo,
+    generation_config: row.generation_config,
+    evaluation_results: [result],
+  }
+}
+
+function modelSummaryFromRows(modelRow: Row, cellRows: Row[]): ModelEvaluationSummary {
+  const evaluationsByCategory = emptyEvaluationsByCategory()
+  for (const cellRow of cellRows) {
+    const evaluation = reshapeCellToBenchmarkEvaluation(cellRow)
+    const category = normalizeCategory(evaluation.category)
+    evaluationsByCategory[category].push(evaluation)
+  }
+
+  const categoriesCovered = asArray<CategoryType>(modelRow.categories).filter((category) =>
+    EVALUATION_CATEGORIES.includes(category)
+  )
+  const modelInfo = (modelRow.model_info ?? modelInfoFromModelRow(modelRow)) as ModelInfo
+  const totalEvaluations = asNumber(modelRow.total_evaluations ?? modelRow.evaluations_count)
+  const lastUpdated = asString(modelRow.last_updated ?? modelRow.latest_timestamp, "")
+  const rawModelIds = asArray<string>(modelRow.raw_model_ids)
+
+  const core = {
+    model_info: modelInfo,
+    evaluations_by_category: evaluationsByCategory,
+    total_evaluations: totalEvaluations,
+    last_updated: lastUpdated,
+    categories_covered: categoriesCovered.length > 0
+      ? categoriesCovered
+      : EVALUATION_CATEGORIES.filter((category) => evaluationsByCategory[category].length > 0),
+    reproducibility_summary: modelRow.reproducibility_summary,
+    provenance_summary: modelRow.provenance_summary,
+    comparability_summary: modelRow.comparability_summary,
+  }
+
+  const variants = asArray<Row>(modelRow.variants).map((variant, index) => ({
+    ...core,
+    ...variant,
+    variant_id: asString(variant.variant_id ?? variant.variant_key, `variant-${index}`),
+    variant_key: asString(variant.variant_key, `variant-${index}`),
+    variant_label: asString(variant.variant_label ?? variant.variant_display_name, "Default"),
+    variant_display_name: asString(variant.variant_display_name ?? variant.variant_label ?? modelRow.model_name, modelRow.model_name),
+    raw_model_ids: asArray<string>(variant.raw_model_ids),
+    family_id: asString(variant.family_id ?? modelRow.model_family_id, modelRow.model_family_id),
+    family_name: asString(variant.family_name ?? modelRow.model_family_name, modelRow.model_family_name),
+    total_evaluations: asNumber(variant.total_evaluations ?? totalEvaluations),
+    last_updated: asString(variant.last_updated ?? lastUpdated, lastUpdated),
+    categories_covered: asArray<CategoryType>(variant.categories_covered).length > 0
+      ? asArray<CategoryType>(variant.categories_covered)
+      : core.categories_covered,
+    model_info: {
+      ...modelInfo,
+      name: asString(variant.variant_display_name ?? variant.variant_label ?? modelInfo.name, modelInfo.name),
+    },
+  })) as ModelVariantSummary[]
+
+  return {
+    ...core,
+    model_family_id: asString(modelRow.model_family_id ?? modelRow.model_id, modelRow.model_id),
+    model_route_id: asString(modelRow.model_route_id ?? modelRow.route_id, modelRow.route_id),
+    model_family_name: asString(modelRow.model_family_name ?? modelRow.model_name, modelRow.model_name),
+    raw_model_ids: rawModelIds.length > 0 ? rawModelIds : [asString(modelRow.model_id, "")].filter(Boolean),
+    variants,
+  }
+}
+
+async function getModelEvaluationRows(modelId: string): Promise<Row[]> {
+  return readRows<Row>(
+    `SELECT ${CELL_JOIN_COLUMNS}
+     FROM eval_results_view r
+     LEFT JOIN evals_view e ON r.evaluation_id = e.evaluation_id
+     WHERE r.model_id = ?
+       AND r.score IS NOT NULL
+     ORDER BY r.category, r.percentile DESC NULLS LAST`,
+    [modelId]
+  )
+}
+
+export async function getModelCards(): Promise<EvaluationCardData[]> {
+  return readRows<EvaluationCardData>(
+    `SELECT ${MODEL_CARD_COLUMNS}
+     FROM models_view
+     ORDER BY latest_timestamp DESC NULLS LAST`
+  )
+}
+
+export async function getModelCardsLite(): Promise<EvaluationCardData[]> {
+  return readRows<EvaluationCardData>(
+    `SELECT ${MODEL_CARD_COLUMNS}
+     FROM models_view
+     ORDER BY benchmarks_count DESC NULLS LAST, evaluations_count DESC NULLS LAST, model_name ASC`
+  )
+}
+
+export async function getEvalListData(): Promise<{
+  evals: BenchmarkEvalListItem[]
+  totalModels: number
+}> {
+  const [evals, countRows] = await Promise.all([
+    readRows<BenchmarkEvalListItem>(
+      `SELECT ${EVAL_LIST_COLUMNS}
+       FROM evals_view
+       ORDER BY evaluation_name ASC`
+    ),
+    readRows<{ n: number }>("SELECT COUNT(*) AS n FROM models_view"),
+  ])
+
+  return {
+    evals,
+    totalModels: asNumber(countRows[0]?.n),
+  }
+}
+
+export async function getEvalListLiteData(): Promise<{
+  evals: BenchmarkEvalListItem[]
+  totalModels: number
+}> {
+  return getEvalListData()
+}
+
+export async function getEvalList() {
+  const { evals } = await getEvalListData()
+  return evals
+}
+
+export async function getDashboardData() {
+  const [models, evals] = await Promise.all([
+    getModelCards(),
+    getEvalList(),
+  ])
+  return { models, evals }
+}
+
+export async function getModelSummaryById(routeId: string): Promise<ModelEvaluationSummary | null> {
+  const rows = await readRows<Row>(
+    `SELECT *
+     FROM models_view
+     WHERE route_id = ? OR model_route_id = ? OR model_family_id = ? OR model_id = ?
+     LIMIT 1`,
+    [routeId, routeId, routeId, routeId]
+  )
+  const modelRow = rows[0]
+  if (!modelRow) return null
+
+  const cellRows = await getModelEvaluationRows(asString(modelRow.model_id, routeId))
+  return modelSummaryFromRows(modelRow, cellRows)
+}
+
+export async function getEvalSummaryById(evalId: string): Promise<BenchmarkEvalSummary | null> {
+  const evalRows = await readRows<Row>(
+    "SELECT * FROM evals_view WHERE evaluation_id = ? LIMIT 1",
+    [evalId]
+  )
+  const evalRow = evalRows[0]
+  if (!evalRow) return null
+
+  let cellRows = await readRows<Row>(
+    `SELECT ${CELL_JOIN_COLUMNS}
+     FROM eval_results_view r
+     LEFT JOIN evals_view e ON r.evaluation_id = e.evaluation_id
+     WHERE r.evaluation_id = ?
+       AND r.metric_id = (SELECT primary_metric_id FROM evals_view WHERE evaluation_id = ?)
+       AND r.score IS NOT NULL
+     ORDER BY r.position ASC NULLS LAST`,
+    [evalId, evalId]
+  )
+
+  if (cellRows.length === 0) {
+    cellRows = await readRows<Row>(
+      `SELECT ${CELL_JOIN_COLUMNS}
+       FROM eval_results_view r
+       LEFT JOIN evals_view e ON r.evaluation_id = e.evaluation_id
+       WHERE r.evaluation_id = ?
+         AND r.score IS NOT NULL
+       ORDER BY r.position ASC NULLS LAST`,
+      [evalId]
+    )
+  }
+
+  return {
+    ...evalRow,
+    model_results: cellRows.map(reshapeCellToModelResult),
+  } as BenchmarkEvalSummary
+}
+
+export async function getDeveloperList(): Promise<DeveloperListEntry[]> {
+  const headline = await fetchHeadline()
+  return [...(headline.developers ?? [])].sort((a, b) => a.developer.localeCompare(b.developer))
+}
+
+export async function getDeveloperSummaryById(routeId: string) {
+  const developers = await getDeveloperList()
+  const developer = developers.find((entry) => entry.route_id === routeId)
+  if (!developer) return null
+
+  const models = await readRows<EvaluationCardData>(
+    `SELECT ${MODEL_CARD_COLUMNS}
+     FROM models_view
+     WHERE developer = ?
+     ORDER BY benchmarks_count DESC NULLS LAST, evaluations_count DESC NULLS LAST, model_name ASC`,
+    [developer.developer]
+  )
+
+  return {
+    ...developer,
+    models,
+  }
+}
+
+export async function getBenchmarkMetadataMap(): Promise<Record<string, BenchmarkCard>> {
+  const rows = await readRows<Row>(
+    `SELECT evaluation_id, evaluation_name, composite_benchmark_key, benchmark_card
+     FROM evals_view
+     WHERE benchmark_card IS NOT NULL`
+  )
+  const result: Record<string, BenchmarkCard> = {}
+
+  for (const row of rows) {
+    const card = row.benchmark_card as BenchmarkCard | null | undefined
+    if (!card) continue
+
+    const keys = [
+      row.evaluation_id,
+      row.evaluation_name,
+      row.composite_benchmark_key,
+      card.benchmark_details?.name,
+    ].filter((key): key is string => typeof key === "string" && key.length > 0)
+
+    for (const key of keys) {
+      result[key] = card
+    }
+  }
+
+  return result
+}

scripts/cache-hf-data.mjs

@@ -18,6 +18,13 @@ import { promisify } from "util"
 const root = path.resolve(new URL(import.meta.url).pathname, "..", "..")
 const cacheDir = path.join(root, ".cache", "hf-data")
 const publicDir = path.join(root, "public")
+const dataBackend = process.env.DATA_BACKEND?.trim().toLowerCase()
+if (dataBackend === "v2" || dataBackend === "stage-j") {
+  await fs.mkdir(cacheDir, { recursive: true })
+  console.log("[cache-hf-data] DATA_BACKEND=v2: skipping legacy HF cache; runtime reads SNAPSHOT_URL")
+  process.exit(0)
+}
+
 const HF_DATASET_REPO = process.env.HF_DATASET_REPO?.trim()
   || "https://huggingface.co/datasets/evaleval/card_backend"
 const HF_RESOLVE_BASE = `${HF_DATASET_REPO}/resolve/main`

tests/duckdb-data.test.ts

@@ -12,27 +12,13 @@ function sqlString(value: string) {
 }
 
 async function writeParquetPayload(outputDir: string, fileName: string, payloads: unknown[]) {
-  const parquetDir = path.join(outputDir, "experimental", "parquet")
+  const parquetDir = path.join(outputDir, "duckdb", "v1")
   await mkdir(parquetDir, { recursive: true })
 
   const selects = payloads
-    .map((payload, index) => {
-      const record = payload as Record<string, unknown>
+    .map((payload) => {
       const payloadJson = JSON.stringify(payload)
-      return [
-        `SELECT 'model_card_lite' AS record_type`,
-        `${sqlString(String(record.model_route_id ?? index))} AS model_route_id`,
-        `${sqlString(String(record.model_family_id ?? ""))} AS model_family_id`,
-        `${sqlString(String(record.developer ?? ""))} AS developer`,
-        `NULL AS eval_summary_id`,
-        `NULL AS developer_route_id`,
-        `NULL AS category`,
-        `NULL AS benchmark_family_key`,
-        `${Number(record.benchmark_family_count ?? 0)} AS models_count`,
-        `${Number(record.total_evaluations ?? 0)} AS total_evaluations`,
-        `${sqlString(String(record.last_updated ?? ""))} AS last_updated`,
-        `${sqlString(payloadJson)} AS payload_json`,
-      ].join(", ")
+      return `SELECT ${sqlString(payloadJson)} AS payload_json`
     })
     .join(" UNION ALL ")
 
@@ -49,22 +35,36 @@ describe("DuckDB local data backend", () => {
       process.env.LOCAL_PIPELINE_OUTPUT = outputDir
       await writeParquetPayload(outputDir, "model_cards_lite.parquet", [
         {
-          model_family_id: "openai/gpt-5",
-          model_route_id: "openai__gpt-5",
-          model_family_name: "GPT 5",
-          developer: "openai",
+          id: "openai/gpt-5",
+          route_id: "openai__gpt-5",
+          model_name: "GPT 5",
+          model_id: "openai/gpt-5",
+          canonical_model_name: "GPT 5",
+          developer: "OpenAI",
+          evaluations_count: 3,
+          benchmarks_count: 2,
+          variant_count: 1,
+          categories: ["Reasoning"],
+          category_stats: { General: 0, Reasoning: 2, Agentic: 0, Safety: 0, Knowledge: 0 },
+          latest_timestamp: "2026-01-01T00:00:00Z",
+          evaluator_count: 1,
+          evaluator_names: ["OpenAI"],
+          source_type_count: 1,
+          source_types: ["documentation"],
+          evidence_count: 3,
+          missing_generation_config_count: 0,
+          third_party_eval_count: 0,
+          independent_verification_ratio: 0,
+          reproducibility_status: "complete",
+          eval_libraries: [],
           params_billions: 100,
-          total_evaluations: 3,
-          benchmark_count: 2,
-          benchmark_family_count: 2,
-          categories_covered: ["reasoning"],
-          last_updated: "2026-01-01T00:00:00Z",
-          variants: [],
           score_summary: { count: 1, min: 0.7, max: 0.9, average: 0.8 },
           benchmark_names: ["mmlu"],
-          top_benchmark_scores: [
+          top_scores: [
             { benchmark: "mmlu", score: 0.9, metric: "accuracy" },
           ],
+          source_urls: [],
+          detail_urls: [],
         },
       ])
 
@@ -93,7 +93,7 @@ describe("DuckDB local data backend", () => {
     try {
       process.env.LOCAL_PIPELINE_OUTPUT = outputDir
       await expect(getModelCardsLiteFromDuckDB()).rejects.toThrow(
-        /EXPORT_EXPERIMENTAL_PARQUET=1/
+        /duckdb\/v1\/model_cards_lite\.parquet/
       )
     } finally {
       if (previousOutput == null) {

tests/view-data.test.ts

@@ -0,0 +1,464 @@
+import { mkdir, mkdtemp, rm, writeFile } from "fs/promises"
+import os from "os"
+import path from "path"
+
+import { DuckDBConnection } from "@duckdb/node-api"
+import { describe, expect, it } from "vitest"
+
+function sqlString(value: string) {
+  return `'${value.replace(/'/g, "''")}'`
+}
+
+async function copyParquet(connection: DuckDBConnection, sql: string, outputPath: string) {
+  await connection.run(`COPY (${sql}) TO ${sqlString(outputPath)} (FORMAT parquet)`)
+}
+
+async function writeSyntheticStageJSnapshot(snapshotDir: string) {
+  await mkdir(snapshotDir, { recursive: true })
+  const connection = await DuckDBConnection.create()
+
+  await copyParquet(
+    connection,
+    `
+      SELECT
+        TIMESTAMP '2026-05-03 00:00:00' AS snapshot_id,
+        'openai/gpt-5' AS model_id,
+        'openai/gpt-5' AS id,
+        'openai%2Fgpt-5' AS route_id,
+        'openai%2Fgpt-5' AS model_route_id,
+        'openai/gpt-5' AS model_family_id,
+        'GPT 5' AS model_name,
+        'GPT 5' AS canonical_model_name,
+        'GPT 5' AS model_family_name,
+        'OpenAI' AS developer,
+        DATE '2026-01-01' AS release_date,
+        'https://example.test/model' AS model_url,
+        'transformer' AS architecture,
+        '100B' AS params,
+        100.0 AS params_billions,
+        ['text']::VARCHAR[] AS input_modalities,
+        ['text']::VARCHAR[] AS output_modalities,
+        'engine' AS inference_engine,
+        'platform' AS inference_platform,
+        1::BIGINT AS evaluations_count,
+        1::BIGINT AS benchmarks_count,
+        1::INTEGER AS variant_count,
+        1::BIGINT AS evaluator_count,
+        ['OpenAI']::VARCHAR[] AS evaluator_names,
+        1::INTEGER AS source_type_count,
+        ['documentation']::VARCHAR[] AS source_types,
+        0::BIGINT AS third_party_eval_count,
+        0.0 AS independent_verification_ratio,
+        1::BIGINT AS evidence_count,
+        0::INTEGER AS missing_generation_config_count,
+        TIMESTAMP '2026-05-03 00:00:00' AS latest_timestamp,
+        'OpenAI' AS latest_source_name,
+        ['MMLU']::VARCHAR[] AS benchmark_names,
+        ['Reasoning']::VARCHAR[] AS categories,
+        struct_pack("General" := 0, "Reasoning" := 1, "Agentic" := 0, "Safety" := 0, "Knowledge" := 0) AS category_stats,
+        'complete' AS reproducibility_status,
+        struct_pack(results_total := 1, has_reproducibility_gap_count := 0, populated_ratio_avg := 1.0) AS reproducibility_summary,
+        struct_pack(
+          total_results := 1,
+          total_groups := 1,
+          multi_source_groups := 0,
+          first_party_only_groups := 1,
+          source_type_distribution := struct_pack(first_party := 1, third_party := 0, collaborative := 0, unspecified := 0)
+        ) AS provenance_summary,
+        struct_pack(
+          total_groups := 1,
+          groups_with_variant_check := 0,
+          groups_with_cross_party_check := 0,
+          variant_divergent_count := 0,
+          cross_party_divergent_count := 0
+        ) AS comparability_summary,
+        [struct_pack(name := 'openai-evals', version := '1.0', fork := NULL::VARCHAR)] AS eval_libraries,
+        struct_pack(count := 1, min := 0.8, max := 0.8, average := 0.8) AS score_summary,
+        [struct_pack(benchmark := 'MMLU', benchmarkKey := 'mmlu', score := 0.8, metric := 'accuracy')] AS top_scores,
+        ['https://example.test/source']::VARCHAR[] AS source_urls,
+        []::VARCHAR[] AS detail_urls,
+        [struct_pack(
+          variant_id := 'default',
+          variant_key := 'default',
+          variant_label := 'Default',
+          variant_display_name := 'GPT 5',
+          raw_model_ids := ['openai/gpt-5']::VARCHAR[],
+          family_id := 'openai/gpt-5',
+          family_name := 'GPT 5',
+          version_date := NULL::VARCHAR,
+          version_qualifier := NULL::VARCHAR,
+          total_evaluations := 1,
+          last_updated := TIMESTAMP '2026-05-03 00:00:00',
+          categories_covered := ['Reasoning']::VARCHAR[]
+        )] AS variants,
+        ['openai/gpt-5']::VARCHAR[] AS raw_model_ids
+    `,
+    path.join(snapshotDir, "models_view.parquet")
+  )
+
+  await copyParquet(
+    connection,
+    `
+      SELECT
+        TIMESTAMP '2026-05-03 00:00:00' AS snapshot_id,
+        'mmlu' AS evaluation_id,
+        'mmlu' AS benchmark_id,
+        'accuracy' AS primary_metric_id,
+        'MMLU' AS evaluation_name,
+        'MMLU' AS canonical_display_name,
+        'mmlu' AS composite_benchmark_key,
+        'MMLU' AS composite_benchmark_name,
+        'mmlu' AS benchmark_family_key,
+        'mmlu' AS benchmark_leaf_key,
+        'Reasoning' AS category,
+        struct_pack(
+          evaluation_description := 'Accuracy on MMLU',
+          lower_is_better := false,
+          score_type := 'continuous',
+          min_score := 0.0,
+          max_score := 1.0,
+          unit := 'proportion'
+        ) AS metric_config,
+        1::BIGINT AS models_count,
+        ['OpenAI']::VARCHAR[] AS evaluator_names,
+        ['documentation']::VARCHAR[] AS source_types,
+        'OpenAI' AS latest_source_name,
+        0.0 AS third_party_ratio,
+        0::INTEGER AS missing_generation_config_count,
+        struct_pack(name := 'GPT 5', score := 0.8) AS best_model,
+        struct_pack(name := 'GPT 5', score := 0.8) AS worst_model,
+        0.8 AS avg_score,
+        0.8 AS avg_score_norm,
+        0.8 AS top_score,
+        false AS has_card,
+        NULL AS benchmark_card,
+        false AS is_aggregated,
+        [] AS aggregate_sources,
+        false AS is_summary_score,
+        []::VARCHAR[] AS summary_eval_ids,
+        struct_pack(domains := ['knowledge']::VARCHAR[], languages := ['en']::VARCHAR[], tasks := ['qa']::VARCHAR[]) AS tags,
+        struct_pack(
+          dataset_name := 'MMLU',
+          source_type := 'documentation',
+          hf_repo := NULL::VARCHAR,
+          hf_split := NULL::VARCHAR,
+          samples_number := 10,
+          url := ['https://example.test/mmlu']::VARCHAR[],
+          dataset_url := 'https://example.test/mmlu',
+          dataset_version := 'v1'
+        ) AS source_data,
+        struct_pack(results_total := 1, has_reproducibility_gap_count := 0, populated_ratio_avg := 1.0) AS reproducibility_summary,
+        struct_pack(
+          total_results := 1,
+          total_groups := 1,
+          multi_source_groups := 0,
+          first_party_only_groups := 1,
+          source_type_distribution := struct_pack(first_party := 1, third_party := 0, collaborative := 0, unspecified := 0)
+        ) AS provenance_summary,
+        struct_pack(
+          total_groups := 1,
+          groups_with_variant_check := 0,
+          groups_with_cross_party_check := 0,
+          variant_divergent_count := 0,
+          cross_party_divergent_count := 0
+        ) AS comparability_summary,
+        struct_pack(available := false, url_count := 0::BIGINT, sample_urls := []::VARCHAR[], models_with_loaded_instances := 0) AS instance_data,
+        1::INTEGER AS metrics_count,
+        ['Accuracy']::VARCHAR[] AS metric_names,
+        [struct_pack(
+          column_key := 'root:accuracy',
+          metric_summary_id := 'mmlu%3Aaccuracy',
+          metric_id := 'accuracy',
+          metric_name := 'accuracy',
+          display_name := 'Accuracy',
+          canonical_display_name := 'Accuracy',
+          lower_is_better := false,
+          unit := 'proportion',
+          scope := 'root',
+          subtask_key := NULL::VARCHAR,
+          subtask_name := NULL::VARCHAR
+        )] AS leaderboard_metrics,
+        [] AS leaderboard_rows,
+        [struct_pack(
+          metric_summary_id := 'mmlu%3Aaccuracy',
+          metric_name := 'accuracy',
+          display_name := 'Accuracy',
+          canonical_display_name := 'Accuracy',
+          metric_key := 'accuracy',
+          lower_is_better := false,
+          models_count := 1,
+          top_score := 0.8,
+          unit := 'proportion'
+        )] AS root_metrics,
+        [] AS subtasks,
+        0::INTEGER AS subtasks_count
+    `,
+    path.join(snapshotDir, "evals_view.parquet")
+  )
+
+  await copyParquet(
+    connection,
+    `
+      SELECT
+        TIMESTAMP '2026-05-03 00:00:00' AS snapshot_id,
+        'mmlu' AS evaluation_id,
+        'mmlu%3Aaccuracy' AS metric_summary_id,
+        'mmlu' AS benchmark_id,
+        'accuracy' AS metric_id,
+        'openai/gpt-5' AS model_id,
+        'openai%2Fgpt-5' AS model_route_id,
+        struct_pack(
+          name := 'GPT 5',
+          id := 'openai/gpt-5',
+          developer := 'OpenAI',
+          inference_platform := 'platform',
+          inference_engine := 'engine',
+          model_version := NULL::VARCHAR,
+          architecture := 'transformer',
+          parameter_count := '100B',
+          release_date := '2026-01-01',
+          model_url := 'https://example.test/model',
+          modalities := struct_pack(input := ['text']::VARCHAR[], output := ['text']::VARCHAR[])
+        ) AS model_info,
+        'Accuracy' AS metric_display_name,
+        'proportion' AS metric_unit,
+        false AS lower_is_better,
+        'Reasoning' AS category,
+        0.8 AS score,
+        struct_pack(
+          score := 0.8,
+          standard_error := 0.01,
+          sample_size := 10,
+          confidence_interval := struct_pack(lower := 0.7, upper := 0.9, confidence_level := 0.95)
+        ) AS score_details,
+        1::INTEGER AS fact_row_count,
+        1::INTEGER AS position,
+        1::INTEGER AS total,
+        1.0 AS percentile,
+        TIMESTAMP '2026-05-03 00:00:00' AS evaluation_timestamp,
+        struct_pack(
+          source_name := 'OpenAI report',
+          source_type := 'documentation',
+          source_organization_name := 'OpenAI',
+          source_organization_url := 'https://example.test',
+          evaluator_relationship := 'first_party',
+          source_url := 'https://example.test/report',
+          publication_date := DATE '2026-05-03'
+        ) AS source_metadata,
+        struct_pack(
+          dataset_name := 'MMLU',
+          source_type := 'documentation',
+          hf_repo := NULL::VARCHAR,
+          hf_split := NULL::VARCHAR,
+          samples_number := 10,
+          url := ['https://example.test/mmlu']::VARCHAR[],
+          dataset_url := 'https://example.test/mmlu',
+          dataset_version := 'v1'
+        ) AS source_data,
+        'https://example.test/record.json' AS source_record_url,
+        struct_pack(name := 'openai-evals', version := '1.0', fork := NULL::VARCHAR) AS eval_library,
+        ['first_party']::VARCHAR[] AS evaluator_relationships,
+        true AS has_first_party,
+        false AS has_third_party,
+        'self' AS coverage_cell,
+        ['OpenAI']::VARCHAR[] AS reporting_orgs,
+        map(['OpenAI'], [0.8]) AS scores_by_organization,
+        false AS is_summary_score,
+        NULL::VARCHAR AS summary_score_for,
+        [] AS aggregate_components,
+        false AS has_reproducibility_gap,
+        1.0 AS completeness_score,
+        false AS is_multi_source,
+        true AS first_party_only,
+        false AS has_variant_divergence,
+        false AS has_cross_party_divergence,
+        NULL AS evalcards_annotations,
+        NULL::VARCHAR AS instance_file_path,
+        NULL::VARCHAR AS instance_file_format,
+        0::INTEGER AS instance_rows
+    `,
+    path.join(snapshotDir, "eval_results_view.parquet")
+  )
+
+  await writeFile(
+    path.join(snapshotDir, "manifest.json"),
+    JSON.stringify({
+      generated_at: "2026-05-03T00:00:00Z",
+      config_version: 2,
+      skipped_configs: [],
+      model_count: 1,
+      eval_count: 1,
+      metric_eval_count: 1,
+      source_config_count: 1,
+      skipped_config_count: 0,
+      summary_artifacts: {
+        corpus_aggregates: "headline.json",
+        eval_hierarchy: "hierarchy.json",
+      },
+    })
+  )
+
+  const reproducibilityBlock = {
+    total_triples: 1,
+    triples_with_reproducibility_gap: 0,
+    reproducibility_gap_rate: 0,
+    agentic_triples: 0,
+    per_field_missingness: {
+      temperature: {
+        missing_count: 0,
+        missing_rate: 0,
+        denominator: "all_triples",
+        denominator_count: 1,
+      },
+    },
+  }
+  const completenessBlock = {
+    total_triples: 1,
+    completeness_avg: 0.75,
+    completeness_min: 0.75,
+    completeness_max: 0.75,
+  }
+  const provenanceBlock = {
+    total_triples: 1,
+    multi_source_triples: 0,
+    first_party_only_triples: 1,
+    source_type_distribution: {
+      first_party: 1,
+      third_party: 0,
+      collaborative: 0,
+      unspecified: 0,
+    },
+  }
+  const comparabilityBlock = {
+    total_triples: 1,
+    variant_divergent_count: 0,
+    cross_party_divergent_count: 0,
+    groups_with_variant_check: 1,
+    groups_with_cross_party_check: 0,
+  }
+  await writeFile(
+    path.join(snapshotDir, "headline.json"),
+    JSON.stringify({
+      generated_at: "2026-05-03T00:00:00Z",
+      signal_version: "1.0",
+      stratification_dimensions: ["category"],
+      reproducibility: {
+        overall: reproducibilityBlock,
+        by_category: { Reasoning: reproducibilityBlock },
+      },
+      completeness: {
+        overall: completenessBlock,
+        by_category: { Reasoning: completenessBlock },
+      },
+      provenance: {
+        overall: provenanceBlock,
+        by_category: { Reasoning: provenanceBlock },
+      },
+      comparability: {
+        overall: comparabilityBlock,
+        by_category: { Reasoning: comparabilityBlock },
+      },
+      developers: [
+        {
+          developer: "OpenAI",
+          route_id: "OpenAI",
+          model_count: 1,
+          benchmark_count: 1,
+          evaluation_count: 1,
+          popular_evals: [{ benchmark: "MMLU", model_count: 1 }],
+        },
+      ],
+    })
+  )
+
+  await writeFile(
+    path.join(snapshotDir, "hierarchy.json"),
+    JSON.stringify({
+      stats: {
+        family_count: 1,
+        composite_count: 0,
+        standalone_benchmark_count: 1,
+        single_benchmark_count: 1,
+        slice_count: 0,
+        metric_count: 1,
+        metric_rows_scanned: 1,
+      },
+      families: [],
+    })
+  )
+}
+
+describe("Stage J view-layer backend", () => {
+  it("reads a pinned snapshot through the v2 accessors", async () => {
+    const snapshotDir = await mkdtemp(path.join(os.tmpdir(), "eval-card-stage-j-"))
+    const previousBackend = process.env.DATA_BACKEND
+    const previousSnapshotUrl = process.env.SNAPSHOT_URL
+
+    try {
+      await writeSyntheticStageJSnapshot(snapshotDir)
+      process.env.DATA_BACKEND = "v2"
+      process.env.SNAPSHOT_URL = `file://${snapshotDir}`
+
+      const dataBackend = await import("../lib/data-backend")
+      const hfData = await import("../lib/hf-data")
+
+      const [models, evalListData, modelSummary, evalSummary, developers, developerSummary, manifest, hierarchy, aggregates] =
+        await Promise.all([
+          dataBackend.getModelCardsLite(),
+          dataBackend.getEvalListLiteData(),
+          dataBackend.getModelSummaryById("openai%2Fgpt-5"),
+          dataBackend.getEvalSummaryById("mmlu"),
+          dataBackend.getDeveloperList(),
+          dataBackend.getDeveloperSummaryById("OpenAI"),
+          dataBackend.getBackendManifestData(),
+          dataBackend.getEvalHierarchyData(),
+          hfData.fetchCorpusAggregates(),
+        ])
+
+      expect(models[0]).toMatchObject({
+        route_id: "openai%2Fgpt-5",
+        model_name: "GPT 5",
+        evaluations_count: 1,
+      })
+      expect(evalListData).toMatchObject({
+        totalModels: 1,
+        evals: [{ evaluation_id: "mmlu", evaluation_name: "MMLU", models_count: 1 }],
+      })
+      expect(modelSummary?.evaluations_by_category.Reasoning).toHaveLength(1)
+      expect(evalSummary?.model_results[0]).toMatchObject({
+        model_route_id: "openai%2Fgpt-5",
+        score: 0.8,
+        result: { metric_summary_id: "mmlu%3Aaccuracy" },
+      })
+      expect(developers[0]).toMatchObject({ developer: "OpenAI", route_id: "OpenAI" })
+      expect(developerSummary?.models).toHaveLength(1)
+      expect(manifest.model_count).toBe(1)
+      expect(hierarchy.stats?.metric_rows_scanned).toBe(1)
+      expect(aggregates?.completeness.overall).toMatchObject({
+        total_triples: 1,
+        completeness_avg: 0.75,
+      })
+      expect(aggregates?.provenance.overall).toMatchObject({
+        total_triples: 1,
+        first_party_only_triples: 1,
+      })
+      expect(aggregates?.comparability.overall).toMatchObject({
+        groups_with_variant_check: 1,
+        variant_divergent_count: 0,
+      })
+      expect(aggregates?.comparability.by_category.Reasoning).toBeDefined()
+    } finally {
+      if (previousBackend == null) {
+        delete process.env.DATA_BACKEND
+      } else {
+        process.env.DATA_BACKEND = previousBackend
+      }
+      if (previousSnapshotUrl == null) {
+        delete process.env.SNAPSHOT_URL
+      } else {
+        process.env.SNAPSHOT_URL = previousSnapshotUrl
+      }
+      await rm(snapshotDir, { recursive: true, force: true })
+    }
+  })
+})