fix: address CodeRabbit review feedback

- githubRepoService: add 10s fetch timeout via AbortController and dedupe
  concurrent in-flight requests
- settingsConfig/setup: align ANIMATION_SPEEDS test mock with production
  values (5000/3000/1500/700/350)
- worker: preserve ASSETS response status for /llms.txt
- VisualizerApp: show algorithm tip for the target algorithm when
  navigating via favorites (was showing stale key)
- VisualizerApp.test: render seek controls only when steps are available
- Add coverage for non-OK repo responses, fetch timeout signal, in-flight
  dedup, and /llms.txt status passthrough

Author: ayoub3bidi

AGENTS.md

@@ -113,13 +113,13 @@ See reference doc for full checklists (JS, Python, pseudocode, sound, insight, t
 - **Anonymous tier (no account):**
   - 18 of 45 algorithms (curated starter set across all 5 categories; see `src/constants/algorithmEntitlements.js`)
   - 12 visualizations per session (localStorage counter `anon_viz_count`, resets on sign-in)
-  - Autoplay only, default speed (MEDIUM: 4800ms)
+  - Autoplay only, default speed (MEDIUM: 3000ms)
   - Complexity panel: 2 views per completion (localStorage `anon_complexity_views`), then blur overlay + sign-in gate
   - No manual controls, speed adjustment, or category-specific controls (grid size locked to MEDIUM, sort order locked to ascending, graph scenarios disabled)
   - No Code Panel, Insight Panel, Video Export, Sound, or Fullscreen
 - **Free tier (Google sign-in):**
   - All 45 algorithms, unlimited visualizations
-  - Manual controls, all 4 speed presets
+  - Manual controls, all 5 speed presets
   - Full complexity panel access, all category-specific controls
   - Code Panel, Insight Panel (with My Notes tab), Sound, Fullscreen
   - Favorite algorithms: up to 20 slots (`FREE_TIER_FAVORITE_SLOT_LIMIT` in `src/constants/personalLearning.js`); stored in Supabase `favorite_algorithms`

src/config/settingsConfig.test.jsx

@@ -62,15 +62,15 @@ describe('useSettingsConfig', () => {
     });
   });
 
-  it('speed values should match ANIMATION_SPEEDS (from mocked constants: 2000, 1000, 500, 250, 125)', () => {
+  it('speed values should match ANIMATION_SPEEDS (5000, 3000, 1500, 700, 350)', () => {
     const { result } = renderHook(() => useSettingsConfig(), { wrapper });
 
     const values = result.current.speedOptions.map(o => o.value);
-    expect(values).toContain(2000);
-    expect(values).toContain(1000);
-    expect(values).toContain(500);
-    expect(values).toContain(250);
-    expect(values).toContain(125);
+    expect(values).toContain(5000);
+    expect(values).toContain(3000);
+    expect(values).toContain(1500);
+    expect(values).toContain(700);
+    expect(values).toContain(350);
   });
 
   it('should use translated labels for grid sizes', () => {
@@ -86,7 +86,7 @@ describe('useSettingsConfig', () => {
   it('should use translated labels for speeds', () => {
     const { result } = renderHook(() => useSettingsConfig(), { wrapper });
 
-    const slowOption = result.current.speedOptions.find(o => o.value === 2000);
+    const slowOption = result.current.speedOptions.find(o => o.value === 5000);
     expect(slowOption).toBeDefined();
     expect(i18n.t('speeds.slow')).toBe(slowOption.label);
   });

src/pages/VisualizerApp.jsx

@@ -634,7 +634,10 @@ function App() {
     applyCategorySwitch(newType);
   };
 
-  const applyCategorySwitch = newType => {
+  const applyCategorySwitch = (
+    newType,
+    tipKey = selectedAlgorithms[newType]
+  ) => {
     const cfg = CATEGORY_CONFIG[newType];
     if (cfg.sizeBinding === 'array') {
       const searchingKey = selectedAlgorithms[ALGORITHM_TYPES.SEARCHING];
@@ -652,12 +655,12 @@ function App() {
     }
     setAlgorithmType(newType);
     visualizationMap[newType]?.reset();
-    maybeShowAlgorithmTip(selectedAlgorithms[newType]);
+    maybeShowAlgorithmTip(tipKey);
   };
 
   const handleFavoriteNavigate = (category, algorithmKey) => {
     if (category !== algorithmType) {
-      applyCategorySwitch(category);
+      applyCategorySwitch(category, algorithmKey);
     }
     setSelectedAlgorithms(prev => ({
       ...prev,

src/pages/VisualizerApp.test.jsx

@@ -325,12 +325,12 @@ vi.mock('../components/ControlPanel', () => ({
       <button type="button" onClick={onToggleFullScreen}>
         toggle-fullscreen
       </button>
-      {onSeek && (
+      {onSeek && totalSteps > 0 && (
         <button type="button" onClick={() => onSeek(2)}>
           seek-to-step-2
         </button>
       )}
-      {isGated && (
+      {isGated && totalSteps > 0 && (
         <button
           type="button"
           onClick={() => onGatedFeatureClick('timeline_scrub')}
@@ -819,10 +819,11 @@ describe('VisualizerApp', () => {
   it('forwards timeline seeks to the active visualization', async () => {
     await renderApp();
 
+    fireEvent.click(screen.getByText('pathfinding'));
     fireEvent.click(screen.getByText('seek-to-step-2'));
 
     await waitFor(() => {
-      expect(sortingVisualization.seekToStep).toHaveBeenCalledWith(2);
+      expect(pathfindingVisualization.seekToStep).toHaveBeenCalledWith(2);
     });
   });
 
@@ -886,6 +887,7 @@ describe('VisualizerApp', () => {
       authMock.isAuthenticated = false;
       await renderApp();
 
+      fireEvent.click(screen.getByText('pathfinding'));
       fireEvent.click(screen.getByText('gated-seek'));
 
       expectGatedFeatureModal('timeline_scrub');

src/services/githubRepoService.js

@@ -13,9 +13,23 @@ import {
 
 export const GITHUB_REPO_CACHE_KEY = 'bayan-flow:github-repo';
 export const GITHUB_REPO_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+export const GITHUB_REPO_FETCH_TIMEOUT_MS = 10000;
 
 const GITHUB_REPO_ENDPOINT = `https://api.github.com/repos/${GITHUB_REPO_OWNER}/${GITHUB_REPO_NAME}`;
 
+async function fetchWithTimeout(url) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(
+    () => controller.abort(),
+    GITHUB_REPO_FETCH_TIMEOUT_MS
+  );
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
 const parseReleaseTag = tagName => {
   if (typeof tagName !== 'string' || !tagName.trim()) {
     return null;
@@ -75,12 +89,14 @@ export function cacheGitHubRepo(data) {
   }
 }
 
+let inFlightGitHubRepoPromise = null;
+
 export async function fetchGitHubRepo() {
   const fallback = createFallbackGitHubRepo();
 
   const [repoResponse, releaseResponse] = await Promise.all([
-    fetch(GITHUB_REPO_ENDPOINT),
-    fetch(`${GITHUB_REPO_ENDPOINT}/releases/latest`),
+    fetchWithTimeout(GITHUB_REPO_ENDPOINT),
+    fetchWithTimeout(`${GITHUB_REPO_ENDPOINT}/releases/latest`),
   ]);
 
   let next = { ...fallback };
@@ -107,22 +123,29 @@ export async function fetchGitHubRepo() {
   return next;
 }
 
-export async function loadGitHubRepoData() {
+export function loadGitHubRepoData() {
   const cached = readCachedGitHubRepo();
   if (cached && !cached.isStale) {
-    return { data: cached.data, fromCache: true };
+    return Promise.resolve({ data: cached.data, fromCache: true });
   }
-  try {
-    const data = await fetchGitHubRepo();
-    cacheGitHubRepo(data);
-    return { data, fromCache: false };
-  } catch (error) {
-    if (cached) {
-      return { data: cached.data, fromCache: true, error };
-    }
-    console.error('Failed to fetch GitHub data:', error);
-    return { data: createFallbackGitHubRepo(), fromCache: false, error };
+  if (!inFlightGitHubRepoPromise) {
+    inFlightGitHubRepoPromise = (async () => {
+      try {
+        const data = await fetchGitHubRepo();
+        cacheGitHubRepo(data);
+        return { data, fromCache: false };
+      } catch (error) {
+        if (cached) {
+          return { data: cached.data, fromCache: true, error };
+        }
+        console.error('Failed to fetch GitHub data:', error);
+        return { data: createFallbackGitHubRepo(), fromCache: false, error };
+      } finally {
+        inFlightGitHubRepoPromise = null;
+      }
+    })();
   }
+  return inFlightGitHubRepoPromise;
 }
 
 export function runWhenIdle(task) {

src/services/githubRepoService.test.js

@@ -157,4 +157,67 @@ describe('githubRepoService', () => {
 
     expect(data.versionTag).toBe('0.6.0');
   });
+
+  it('falls back to defaults when repo endpoint returns non-OK', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async url => {
+        if (String(url).includes('/releases/latest')) {
+          return {
+            ok: true,
+            json: async () => ({ tag_name: 'v0.6.0' }),
+          };
+        }
+        return { ok: false, status: 404, json: async () => ({}) };
+      })
+    );
+
+    const data = await fetchGitHubRepo();
+
+    expect(data).toMatchObject({
+      url: GITHUB_REPO_URL,
+      fullName: GITHUB_REPO_FULL_NAME,
+      stars: 0,
+      forks: 0,
+      versionTag: '0.6.0',
+    });
+  });
+
+  it('aborts pending fetches after the timeout', async () => {
+    let signalSeen = null;
+    vi.stubGlobal(
+      'fetch',
+      vi.fn(async (url, init) => {
+        signalSeen = init.signal;
+        return { ok: false, json: async () => ({}) };
+      })
+    );
+
+    const data = await fetchGitHubRepo();
+
+    expect(signalSeen).toBeInstanceOf(AbortSignal);
+    expect(signalSeen.aborted).toBe(false);
+    expect(data.versionTag).toBe(GITHUB_REPO_PACKAGE_VERSION);
+  });
+
+  it('deduplicates concurrent in-flight fetches', async () => {
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({
+        html_url: GITHUB_REPO_URL,
+        full_name: GITHUB_REPO_FULL_NAME,
+        stargazers_count: 42,
+        forks_count: 7,
+      }),
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    const [first, second] = await Promise.all([
+      loadGitHubRepoData(),
+      loadGitHubRepoData(),
+    ]);
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(first.data).toEqual(second.data);
+  });
 });

src/test/setup.js

@@ -66,11 +66,11 @@ const constantsMockValue = {
     cycle: '#ef4444',
   },
   ANIMATION_SPEEDS: {
-    SLOW: 2000,
-    MEDIUM: 1000,
-    FAST: 500,
-    VERY_FAST: 250,
-    ULTRA_FAST: 125,
+    SLOW: 5000,
+    MEDIUM: 3000,
+    FAST: 1500,
+    VERY_FAST: 700,
+    ULTRA_FAST: 350,
   },
   VISUALIZATION_MODES: {
     MANUAL: 'manual',

worker/index.js

@@ -68,6 +68,7 @@ export default {
           new Request(new URL('/llms.txt', request.url).toString())
         );
         return new Response(llmsResponse.body, {
+          status: llmsResponse.status,
           headers: {
             'Content-Type': 'text/markdown; charset=utf-8',
             'Access-Control-Allow-Origin': '*',

worker/index.test.js

@@ -25,6 +25,7 @@ describe('Worker markdown negotiation', () => {
 
   beforeEach(() => {
     env = createFetchHandler({
+      '/llms.txt': '# Bayan Flow\n\nTest content',
       '/markdown/index.md': '# Bayan Flow\n\nTest content',
       '/markdown/app.md': '# Algorithm Visualizer\n\nTest',
       '/markdown/_fallback.md': '# Bayan Flow\n\nFallback',
@@ -97,4 +98,26 @@ describe('Worker markdown negotiation', () => {
       'text/markdown; charset=utf-8'
     );
   });
+
+  it('serves /llms.txt as markdown when the asset exists', async () => {
+    const req = makeRequest('https://bayanflow.com/llms.txt', 'text/markdown');
+    const res = await worker.fetch(req, env);
+
+    expect(res.status).toBe(200);
+    expect(res.headers.get('Content-Type')).toBe(
+      'text/markdown; charset=utf-8'
+    );
+    expect(res.headers.get('Access-Control-Allow-Origin')).toBe('*');
+    expect(await res.text()).toBe('# Bayan Flow\n\nTest content');
+  });
+
+  it('preserves the asset status when /llms.txt is missing', async () => {
+    const missingEnv = createFetchHandler({
+      '/markdown/index.md': '# Bayan Flow\n\nTest content',
+    });
+    const req = makeRequest('https://bayanflow.com/llms.txt', 'text/markdown');
+    const res = await worker.fetch(req, missingEnv);
+
+    expect(res.status).toBe(404);
+  });
 });