feat(compare): filter index, sitemap, and SSG params by real benchmark coverage

Only emit /compare/<model>-<a>-vs-<b> URLs where both GPUs actually have
benchmark rows for that model in Neon. Avoids 156 empty pair cards in the
index and ~123 unreachable sitemap entries (288 -> 165).

- compare-availability.ts: cached server-side helper using getAvailabilityData
- compare/page.tsx: async, filtered modelsWithPairs, per-model card sections
- sitemap.ts: async, only canonical (model, pair) combos with data
- [slug]/page.tsx + opengraph-image.tsx: generateStaticParams now async + filtered
- compare-slug.ts: kimi-k26 / glm-5-1 / minimax-m27 dbKeys now include both
  point releases so the canonical slug pulls existing data while staying
  forward-compatible with the newer DB key when it arrives

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: functionstackx

packages/app/src/app/compare/[slug]/opengraph-image.tsx

@@ -7,12 +7,8 @@ import { join } from 'node:path';
 import { notFound } from 'next/navigation';
 import { ImageResponse } from 'next/og';
 
-import {
-  allCanonicalCompareSlugs,
-  canonicalCompareSlug,
-  compareDisplayLabel,
-  parseCompareSlug,
-} from '@/lib/compare-slug';
+import { getAllComparableCompareSlugs } from '@/lib/compare-availability';
+import { canonicalCompareSlug, compareDisplayLabel, parseCompareSlug } from '@/lib/compare-slug';
 
 export const alt = 'GPU inference benchmark comparison';
 export const size = { width: 1200, height: 630 };
@@ -38,10 +34,12 @@ const TILE_GRID: ({ file: string; rotate?: number } | null)[] = [
   { file: 'teal-organic.png', rotate: 180 },
 ];
 
-export function generateStaticParams() {
-  return allCanonicalCompareSlugs().map(({ modelSlug, a, b }) => ({
-    slug: canonicalCompareSlug(modelSlug, a, b),
-  }));
+export async function generateStaticParams() {
+  // Mirror the SSR page's static params — only emit (model, pair) combos
+  // with benchmark data on both sides so we don't generate OG images for
+  // empty pages.
+  const slugs = await getAllComparableCompareSlugs();
+  return slugs.map(({ modelSlug, a, b }) => ({ slug: canonicalCompareSlug(modelSlug, a, b) }));
 }
 
 // Read once at module load; a missing asset must not 500 every OG route.

packages/app/src/app/compare/[slug]/page.tsx

@@ -20,9 +20,9 @@ import { cachedQuery } from '@/lib/api-cache';
 import { rowToAggDataEntry } from '@/lib/benchmark-transform';
 import { loadFixture } from '@/lib/test-fixtures';
 import { getHardwareKey } from '@/lib/chart-utils';
+import { getAllComparableCompareSlugs } from '@/lib/compare-availability';
 import { pickPairDefaults } from '@/lib/compare-pair-defaults';
 import {
-  allCanonicalCompareSlugs,
   canonicalCompareSlug,
   compareDisplayLabel,
   compareModelDisplayLabel,
@@ -71,10 +71,12 @@ const getCachedBenchmarks = cachedQuery(
   { blobOnly: true },
 );
 
-export function generateStaticParams() {
-  return allCanonicalCompareSlugs().map(({ modelSlug, a, b }) => ({
-    slug: canonicalCompareSlug(modelSlug, a, b),
-  }));
+export async function generateStaticParams() {
+  // Only enumerate (model, pair) combos with benchmark data on both sides.
+  // Direct URL hits to non-enumerated combos still render via the dynamic
+  // SSR path (with the empty-state fallback).
+  const slugs = await getAllComparableCompareSlugs();
+  return slugs.map(({ modelSlug, a, b }) => ({ slug: canonicalCompareSlug(modelSlug, a, b) }));
 }
 
 export async function generateMetadata({ params }: Props): Promise<Metadata> {

packages/app/src/app/compare/page.tsx

@@ -5,14 +5,17 @@ import { HW_REGISTRY, SITE_NAME, SITE_URL } from '@semianalysisai/inferencex-con
 import { ComparePairCardLink } from '@/components/compare/compare-pair-card-link';
 import { JsonLd } from '@/components/json-ld';
 import { Card } from '@/components/ui/card';
+import { getComparablePairsByModelSlug } from '@/lib/compare-availability';
 import {
-  allCanonicalComparePairs,
   canonicalCompareSlug,
   compareDisplayLabel,
+  type ComparePair,
   COMPARE_MODEL_SLUGS,
   type CompareModelSlug,
 } from '@/lib/compare-slug';
 
+export const dynamic = 'force-dynamic';
+
 const DESCRIPTION =
   'Browse head-to-head GPU inference benchmark comparisons across every model and hardware pair we test. Latency, throughput, and cost for DeepSeek R1, Kimi K2.6, GLM 5.1, Qwen 3.5, and more.';
 
@@ -39,14 +42,15 @@ interface VendorGroup {
   pairs: { a: string; b: string; slug: string; label: string }[];
 }
 
-function groupPairsByVendorForModel(model: CompareModelSlug): VendorGroup[] {
-  const all = allCanonicalComparePairs();
-
+function groupPairsByVendorForModel(
+  model: CompareModelSlug,
+  comparablePairs: ComparePair[],
+): VendorGroup[] {
   const nvidia: VendorGroup['pairs'] = [];
   const amd: VendorGroup['pairs'] = [];
   const cross: VendorGroup['pairs'] = [];
 
-  for (const { a, b } of all) {
+  for (const { a, b } of comparablePairs) {
     const entry = {
       a,
       b,
@@ -95,9 +99,17 @@ const jsonLd = {
   url: `${SITE_URL}/compare`,
 };
 
-export default function CompareIndexPage() {
-  const pairsPerModel = allCanonicalComparePairs().length;
-  const totalUrls = COMPARE_MODEL_SLUGS.length * pairsPerModel;
+export default async function CompareIndexPage() {
+  // Server-side filter: only show (model, pair) combinations where both GPUs
+  // have benchmark data for that model. Avoids cards that would link to an
+  // empty-state page. The page-level handler at /compare/[slug] still renders
+  // the empty-state for direct URL hits, so this is purely a navigation
+  // hygiene concern.
+  const comparablePairsByModel = await getComparablePairsByModelSlug();
+  const totalUrls = [...comparablePairsByModel.values()].reduce((s, p) => s + p.length, 0);
+  const modelsWithPairs = COMPARE_MODEL_SLUGS.filter(
+    (m) => (comparablePairsByModel.get(m.slug)?.length ?? 0) > 0,
+  );
 
   return (
     <>
@@ -106,23 +118,24 @@ export default function CompareIndexPage() {
         <Card>
           <h1 className="text-2xl lg:text-4xl font-bold tracking-tight">GPU Comparisons</h1>
           <p className="mt-3 text-base lg:text-lg text-muted-foreground max-w-3xl">
-            {totalUrls.toLocaleString()} head-to-head inference benchmark comparisons —{' '}
-            {pairsPerModel} GPU pairs × {COMPARE_MODEL_SLUGS.length} models. Each page includes
-            interactive charts for latency, throughput, and cost metrics, plus an interpolated
-            comparison table.
+            {totalUrls.toLocaleString()} head-to-head inference benchmark comparisons across{' '}
+            {modelsWithPairs.length} models. Each page includes interactive charts for latency,
+            throughput, and cost metrics, plus an interpolated comparison table.
           </p>
         </Card>
       </section>
 
-      {COMPARE_MODEL_SLUGS.map((model) => {
-        const groups = groupPairsByVendorForModel(model);
+      {modelsWithPairs.map((model) => {
+        const pairs = comparablePairsByModel.get(model.slug) ?? [];
+        const groups = groupPairsByVendorForModel(model, pairs);
         return (
           <section key={model.slug} id={model.slug}>
             <Card className="flex flex-col gap-4">
               <div>
                 <h2 className="text-xl lg:text-2xl font-bold tracking-tight">{model.label}</h2>
                 <p className="text-sm text-muted-foreground mt-1">
-                  Compare any GPU pair on {model.label}.
+                  {pairs.length} GPU pair{pairs.length === 1 ? '' : 's'} with benchmark data on{' '}
+                  {model.label}.
                 </p>
               </div>
               {groups.map((group) => (

packages/app/src/app/sitemap.ts

@@ -1,7 +1,8 @@
 import type { MetadataRoute } from 'next';
 
 import { getAllPosts } from '@/lib/blog';
-import { allCanonicalCompareSlugs, canonicalCompareSlug } from '@/lib/compare-slug';
+import { getAllComparableCompareSlugs } from '@/lib/compare-availability';
+import { canonicalCompareSlug } from '@/lib/compare-slug';
 import { SITE_URL as BASE_URL } from '@semianalysisai/inferencex-constants';
 
 const TABS = [
@@ -13,8 +14,11 @@ const TABS = [
   'gpu-metrics',
 ] as const;
 
-export default function sitemap(): MetadataRoute.Sitemap {
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
   const now = new Date().toISOString();
+  // Only emit (model, pair) URLs that have benchmark data on both sides —
+  // avoids polluting the sitemap with empty pages that hurt crawl budget.
+  const compareSlugs = await getAllComparableCompareSlugs();
 
   return [
     {
@@ -59,7 +63,7 @@ export default function sitemap(): MetadataRoute.Sitemap {
       changeFrequency: 'monthly' as const,
       priority: 0.7,
     })),
-    ...allCanonicalCompareSlugs().map(({ modelSlug, a, b }) => ({
+    ...compareSlugs.map(({ modelSlug, a, b }) => ({
       url: `${BASE_URL}/compare/${canonicalCompareSlug(modelSlug, a, b)}`,
       lastModified: now,
       changeFrequency: 'daily' as const,

packages/app/src/lib/compare-availability.ts

@@ -0,0 +1,84 @@
+/**
+ * Server-side helper: for each canonical compare model slug, returns the list
+ * of GPU pairs that actually have benchmark data on both sides.
+ *
+ * Used by the /compare index, the sitemap, and the [slug] generateStaticParams
+ * to avoid emitting cards / URLs for (model, pair) combinations where one or
+ * both GPUs have no rows for that model. A pair is "comparable" if both GPU
+ * keys appear in the availability table for any of the model's dbKeys.
+ *
+ * The page-level handler at /compare/[slug] still renders the empty-state
+ * fallback if a user reaches a filtered-out URL directly, so this filtering
+ * is purely an indexing/navigation concern, not a hard gate.
+ */
+
+import { FIXTURES_MODE, JSON_MODE, getDb } from '@semianalysisai/inferencex-db/connection';
+import * as jsonProvider from '@semianalysisai/inferencex-db/json-provider';
+import {
+  type AvailabilityRow,
+  getAvailabilityData,
+} from '@semianalysisai/inferencex-db/queries/workflow-info';
+
+import { cachedQuery } from '@/lib/api-cache';
+import { loadFixture } from '@/lib/test-fixtures';
+import {
+  allCanonicalComparePairs,
+  type ComparePair,
+  COMPARE_MODEL_SLUGS,
+} from '@/lib/compare-slug';
+
+const getCachedAvailability = cachedQuery(() => {
+  if (FIXTURES_MODE) return Promise.resolve(loadFixture<AvailabilityRow[]>('availability'));
+  if (JSON_MODE) return Promise.resolve(jsonProvider.getAvailabilityData());
+  return getAvailabilityData(getDb());
+}, 'availability');
+
+/** Map from canonical model slug → set of GPU keys that have benchmark rows
+ *  for any of the model's dbKeys. */
+async function getHardwareByModelSlug(): Promise<Map<string, Set<string>>> {
+  const rows = await getCachedAvailability();
+  // Build a quick dbKey → modelSlug index so each row maps to at most one slug.
+  const dbKeyToSlug = new Map<string, string>();
+  for (const m of COMPARE_MODEL_SLUGS) {
+    for (const dbKey of m.dbKeys) dbKeyToSlug.set(dbKey, m.slug);
+  }
+  const out = new Map<string, Set<string>>();
+  for (const m of COMPARE_MODEL_SLUGS) out.set(m.slug, new Set());
+  for (const row of rows) {
+    const slug = dbKeyToSlug.get(row.model);
+    if (!slug) continue;
+    out.get(slug)!.add(row.hardware);
+  }
+  return out;
+}
+
+/** For each canonical model slug, return the GPU pairs where both GPUs have
+ *  benchmark data for that model. Pairs are alphabetical (a < b), matching
+ *  the canonical slug ordering. Returns empty list for models with fewer than
+ *  2 GPUs that have data. */
+export async function getComparablePairsByModelSlug(): Promise<Map<string, ComparePair[]>> {
+  const hwByModel = await getHardwareByModelSlug();
+  const allPairs = allCanonicalComparePairs();
+  const out = new Map<string, ComparePair[]>();
+  for (const m of COMPARE_MODEL_SLUGS) {
+    const hw = hwByModel.get(m.slug) ?? new Set();
+    out.set(
+      m.slug,
+      allPairs.filter((p) => hw.has(p.a) && hw.has(p.b)),
+    );
+  }
+  return out;
+}
+
+/** Flattened cross-product of (model, comparable pair). Used by the sitemap
+ *  and by `generateStaticParams` so neither emits URLs for empty pairs. */
+export async function getAllComparableCompareSlugs(): Promise<
+  { modelSlug: string; a: string; b: string }[]
+> {
+  const byModel = await getComparablePairsByModelSlug();
+  const out: { modelSlug: string; a: string; b: string }[] = [];
+  for (const [modelSlug, pairs] of byModel.entries()) {
+    for (const p of pairs) out.push({ modelSlug, a: p.a, b: p.b });
+  }
+  return out;
+}

packages/app/src/lib/compare-slug.ts

@@ -46,7 +46,11 @@ export const COMPARE_MODEL_SLUGS: CompareModelSlug[] = [
   {
     slug: 'kimi-k26',
     displayName: 'Kimi-K2.5',
-    dbKeys: ['kimik2.6'],
+    // Both K2.5 and K2.6 point releases share an architecture (mirroring
+    // DISPLAY_MODEL_TO_DB in packages/constants/src/models.ts). The slug uses
+    // the newer version name; the dbKey list pulls data from both DB buckets
+    // so the slug is populated today and stays populated when K2.6 data lands.
+    dbKeys: ['kimik2.6', 'kimik2.5'],
     label: 'Kimi K2.6',
   },
   {
@@ -58,13 +62,16 @@ export const COMPARE_MODEL_SLUGS: CompareModelSlug[] = [
   {
     slug: 'glm-5-1',
     displayName: 'GLM-5',
-    dbKeys: ['glm5.1'],
+    // GLM-5.0 and GLM-5.1 share an architecture per the model card; the slug
+    // uses the newer version name but the data pull covers both DB buckets.
+    dbKeys: ['glm5.1', 'glm5'],
     label: 'GLM 5.1',
   },
   {
     slug: 'minimax-m27',
     displayName: 'MiniMax-M2.5',
-    dbKeys: ['minimaxm2.7'],
+    // Same point-release grouping pattern as Kimi and GLM.
+    dbKeys: ['minimaxm2.7', 'minimaxm2.5'],
     label: 'MiniMax M2.7',
   },
   {