show inherited changelog entries by walking backwards for uncovered GPUs

Author: adibarra

packages/app/src/components/inference/ui/ChartDisplay.tsx

@@ -130,12 +130,7 @@ export default function ChartDisplay() {
     intermediateDates,
     loading: changelogsLoading,
     totalDatesQueried,
-  } = useComparisonChangelogs(
-    selectedGPUs,
-    selectedPrecisions,
-    selectedDateRange,
-    dateRangeAvailableDates,
-  );
+  } = useComparisonChangelogs(selectedGPUs, selectedDateRange, dateRangeAvailableDates);
 
   const { unofficialRunInfo, getOverlayData, isUnofficialRun } = useUnofficialRun();
 

packages/app/src/components/inference/ui/ComparisonChangelog.tsx

@@ -30,32 +30,73 @@ export default function ComparisonChangelog({
 }: ComparisonChangelogProps) {
   const [isExpanded, setIsExpanded] = useState(false);
 
-  // Filter changelog entries to only show those matching selected GPUs and precisions
+  // Filter changelog entries to only show those matching selected GPUs and precisions.
+  // For GPUs without a direct entry on a date, walk backwards to the most recent prior changelog.
   const filteredChangelogs = useMemo(() => {
     const precSet = new Set(selectedPrecisions);
+    const sorted = [...changelogs].sort(
+      (a, b) => new Date(a.date).getTime() - new Date(b.date).getTime(),
+    );
 
-    return changelogs
-      .map((item) => ({
-        ...item,
-        entries: item.entries.filter((entry) =>
-          entry.config_keys.some((key) => {
-            const precision = key.split('-')[1];
-            return (
-              precSet.has(precision) && selectedGPUs.some((gpu) => configKeyMatchesHwKey(key, gpu))
+    const matchesGpu = (key: string) => {
+      const precision = key.split('-')[1];
+      return precSet.has(precision) && selectedGPUs.some((gpu) => configKeyMatchesHwKey(key, gpu));
+    };
+
+    return sorted
+      .map((item) => {
+        // Direct entries matching selected GPUs/precisions
+        const directEntries = item.entries.filter((entry) => entry.config_keys.some(matchesGpu));
+
+        // Find GPUs that have direct entries on this date
+        const coveredGPUs = new Set<string>();
+        for (const entry of directEntries) {
+          for (const key of entry.config_keys) {
+            if (!matchesGpu(key)) continue;
+            for (const gpu of selectedGPUs) {
+              if (configKeyMatchesHwKey(key, gpu)) coveredGPUs.add(gpu);
+            }
+          }
+        }
+
+        // For uncovered GPUs, walk backwards through earlier dates
+        const inheritedEntries: {
+          config_keys: string[];
+          description: string;
+          pr_link: string | null;
+          inheritedFromDate: string;
+        }[] = [];
+
+        for (const gpu of selectedGPUs) {
+          if (coveredGPUs.has(gpu)) continue;
+          // Walk backwards through sorted changelogs before this date
+          for (let i = sorted.indexOf(item) - 1; i >= 0; i--) {
+            const prior = sorted[i];
+            const match = prior.entries.find((entry) =>
+              entry.config_keys.some((key) => matchesGpu(key) && configKeyMatchesHwKey(key, gpu)),
             );
-          }),
-        ),
-      }))
-      .filter((item) => item.entries.length > 0);
-  }, [changelogs, selectedGPUs, selectedPrecisions]);
+            if (match) {
+              // Avoid duplicates if same entry covers multiple uncovered GPUs
+              if (
+                !inheritedEntries.some(
+                  (e) => e.inheritedFromDate === prior.date && e.description === match.description,
+                )
+              ) {
+                inheritedEntries.push({ ...match, inheritedFromDate: prior.date });
+              }
+              break;
+            }
+          }
+        }
 
-  const sortedChangelogs = useMemo(
-    () =>
-      [...filteredChangelogs].sort(
-        (a, b) => new Date(a.date).getTime() - new Date(b.date).getTime(),
-      ),
-    [filteredChangelogs],
-  );
+        return {
+          ...item,
+          entries: directEntries,
+          inheritedEntries,
+        };
+      })
+      .filter((item) => item.entries.length > 0 || item.inheritedEntries.length > 0);
+  }, [changelogs, selectedGPUs, selectedPrecisions]);
 
   const handleToggle = () => {
     const newState = !isExpanded;
@@ -95,13 +136,13 @@ export default function ComparisonChangelog({
         }`}
       >
         <div className="px-4 pt-2 pb-4 flex flex-col gap-3">
-          {sortedChangelogs.length === 0 ? (
+          {filteredChangelogs.length === 0 ? (
             <p className="text-sm text-muted-foreground">
               No config changelog data matching the selected GPUs and precisions for this date
               range. Changelog tracking began Dec 30, 2025.
             </p>
           ) : (
-            sortedChangelogs.map((item) => (
+            filteredChangelogs.map((item) => (
               <div key={item.date} className="flex flex-col gap-1">
                 <div className="flex items-center gap-2 flex-wrap">
                   <span className="text-sm font-semibold">{item.date}</span>
@@ -144,6 +185,15 @@ export default function ComparisonChangelog({
                     {formatChangelogDescription(entry.description)}
                   </div>
                 ))}
+                {item.inheritedEntries.map((entry, entryIndex) => (
+                  <div
+                    key={`inherited-${entryIndex}`}
+                    className="text-sm text-muted-foreground pl-5 italic"
+                  >
+                    <span className="text-xs opacity-70">(from {entry.inheritedFromDate})</span>{' '}
+                    {formatChangelogDescription(entry.description)}
+                  </div>
+                ))}
               </div>
             ))
           )}

packages/app/src/hooks/api/use-comparison-changelogs.ts

@@ -2,7 +2,6 @@ import { useQueries } from '@tanstack/react-query';
 import { useMemo } from 'react';
 
 import { fetchWorkflowInfo, type ChangelogRow, type WorkflowInfoResponse } from '@/lib/api';
-import { configKeyMatchesHwKey } from '@/components/inference/utils/changelogFormatters';
 
 export interface ComparisonChangelog {
   date: string;
@@ -17,7 +16,6 @@ export interface ComparisonChangelog {
 
 export function useComparisonChangelogs(
   selectedGPUs: string[],
-  selectedPrecisions: string[],
   selectedDateRange: { startDate: string; endDate: string },
   availableDates: string[],
 ) {
@@ -68,35 +66,14 @@ export function useComparisonChangelogs(
     return results;
   }, [isComparisonMode, datesInRange, queries]);
 
-  // Intermediate dates with changelog entries matching selected GPUs/precisions (excluding start/end)
+  // Intermediate dates with any changelog entries (excluding start/end)
   const intermediateDates = useMemo(() => {
     if (!isComparisonMode) return [];
-    const precSet = new Set(selectedPrecisions);
     return changelogs
-      .filter(
-        (c) =>
-          c.date !== selectedDateRange.startDate &&
-          c.date !== selectedDateRange.endDate &&
-          c.entries.some((entry) =>
-            entry.config_keys.some((key) => {
-              const precision = key.split('-')[1];
-              return (
-                precSet.has(precision) &&
-                selectedGPUs.some((gpu) => configKeyMatchesHwKey(key, gpu))
-              );
-            }),
-          ),
-      )
+      .filter((c) => c.date !== selectedDateRange.startDate && c.date !== selectedDateRange.endDate)
       .map((c) => c.date)
       .sort();
-  }, [
-    isComparisonMode,
-    changelogs,
-    selectedGPUs,
-    selectedPrecisions,
-    selectedDateRange.startDate,
-    selectedDateRange.endDate,
-  ]);
+  }, [isComparisonMode, changelogs, selectedDateRange.startDate, selectedDateRange.endDate]);
 
   const loading = queries.some((q) => q.isLoading);