feat(media hosting): disable unreachable providers

src/components/settings-modal/media-hosting-settings/__tests__/media-hosting-settings.test.tsx

@@ -17,11 +17,18 @@ vi.mock('@capacitor/core', () => ({
   Capacitor: { getPlatform: () => mockGetPlatform() },
 }));
 
+const providerAvailabilityRef = vi.hoisted(() => ({
+  value: {} as Record<string, 'unknown' | 'checking' | 'available' | 'unavailable'>,
+}));
+vi.mock('../../../../hooks/use-provider-availability', () => ({
+  useProviderAvailability: () => providerAvailabilityRef.value,
+}));
+
 const mockSetUploadMode = vi.fn();
 const mockSetPreferredProvider = vi.fn();
 const uploadModeRef = vi.hoisted(() => ({ value: 'random' as 'random' | 'preferred' | 'none' }));
 const preferredProviderRef = vi.hoisted(() => ({
-  value: 'catbox' as 'catbox' | 'imgur',
+  value: 'catbox' as 'catbox' | 'imgur' | 'imgbb',
 }));
 vi.mock('../../../../stores/use-media-hosting-store', async (importOriginal) => {
   const mod = await importOriginal<typeof import('../../../../stores/use-media-hosting-store')>();
@@ -51,6 +58,7 @@ describe('MediaHostingSettings', () => {
     vi.clearAllMocks();
     uploadModeRef.value = 'random';
     preferredProviderRef.value = 'catbox';
+    providerAvailabilityRef.value = {};
     mockGetPlatform.mockReturnValue('web');
     (window as unknown as { electronApi?: unknown }).electronApi = undefined;
     container = document.createElement('div');
@@ -99,18 +107,63 @@ describe('MediaHostingSettings', () => {
     expect(mockSetUploadMode).toHaveBeenCalledWith('none');
   });
 
-  it('clicking provider in preferred mode calls setPreferredProvider', async () => {
+  it('disables unsupported providers on Android', async () => {
     uploadModeRef.value = 'preferred';
     preferredProviderRef.value = 'catbox';
     mockGetPlatform.mockReturnValue('android');
     render();
     const imgurRadio = container.querySelector<HTMLInputElement>('input[value="imgur"]');
     expect(imgurRadio).not.toBeNull();
-    expect(imgurRadio?.disabled).toBe(false);
+    expect(imgurRadio?.disabled).toBe(true);
     await act(async () => {
       imgurRadio?.click();
     });
-    expect(mockSetPreferredProvider).toHaveBeenCalledWith('imgur');
+    expect(mockSetPreferredProvider).not.toHaveBeenCalled();
+  });
+
+  it('clicking supported provider in preferred mode calls setPreferredProvider', async () => {
+    uploadModeRef.value = 'preferred';
+    preferredProviderRef.value = 'imgur';
+    mockGetPlatform.mockReturnValue('android');
+    render();
+    const catboxRadio = container.querySelector<HTMLInputElement>('input[value="catbox"]');
+    expect(catboxRadio).not.toBeNull();
+    expect(catboxRadio?.disabled).toBe(false);
+    await act(async () => {
+      catboxRadio?.click();
+    });
+    expect(mockSetPreferredProvider).toHaveBeenCalledWith('catbox');
+  });
+
+  it('enables ImgBB on Android', async () => {
+    uploadModeRef.value = 'preferred';
+    preferredProviderRef.value = 'catbox';
+    mockGetPlatform.mockReturnValue('android');
+    render();
+    const imgbbRadio = container.querySelector<HTMLInputElement>('input[value="imgbb"]');
+    expect(imgbbRadio).not.toBeNull();
+    expect(imgbbRadio?.disabled).toBe(false);
+    await act(async () => {
+      imgbbRadio?.click();
+    });
+    expect(mockSetPreferredProvider).toHaveBeenCalledWith('imgbb');
+  });
+
+  it('disables providers that are unavailable from this network', async () => {
+    uploadModeRef.value = 'preferred';
+    preferredProviderRef.value = 'catbox';
+    providerAvailabilityRef.value = { imgbb: 'unavailable' };
+    mockGetPlatform.mockReturnValue('android');
+    render();
+    const imgbbRadio = container.querySelector<HTMLInputElement>('input[value="imgbb"]');
+    expect(imgbbRadio).not.toBeNull();
+    expect(imgbbRadio?.disabled).toBe(true);
+    expect(imgbbRadio?.closest('label')?.title).toBe('media_hosting_provider_unavailable');
+    expect(container.textContent).toContain('media_hosting_provider_unavailable');
+    await act(async () => {
+      imgbbRadio?.click();
+    });
+    expect(mockSetPreferredProvider).not.toHaveBeenCalled();
   });
 
   it('clicking Random updates store via setUploadMode', async () => {

src/components/settings-modal/media-hosting-settings/media-hosting-settings.tsx

@@ -2,7 +2,8 @@ import { memo } from 'react';
 import { useTranslation } from 'react-i18next';
 import useMediaHostingStore, { MEDIA_HOSTING_PROVIDERS } from '../../../stores/use-media-hosting-store';
 import type { ProviderId } from '../../../lib/media-hosting/types';
-import { isWebRuntime } from '../../../lib/media-hosting/show-upload-controls';
+import { getMediaHostingRuntime } from '../../../lib/media-hosting/show-upload-controls';
+import { useProviderAvailability } from '../../../hooks/use-provider-availability';
 import styles from '../interface-settings/interface-settings.module.css';
 
 const RADIO_NAME = 'media-hosting-provider';
@@ -14,7 +15,9 @@ const MediaHostingSettings = () => {
   const preferredProvider = useMediaHostingStore((state) => state.preferredProvider);
   const setUploadMode = useMediaHostingStore((state) => state.setUploadMode);
   const setPreferredProvider = useMediaHostingStore((state) => state.setPreferredProvider);
-  const isWeb = isWebRuntime();
+  const runtime = getMediaHostingRuntime();
+  const isWeb = runtime === 'web';
+  const availability = useProviderAvailability(runtime);
 
   return (
     <div className={styles.interfaceSettings}>
@@ -40,25 +43,30 @@ const MediaHostingSettings = () => {
           </label>
           {uploadMode === 'preferred' && (
             <div role='radiogroup' aria-label={t('media_hosting_preferred_provider_label')}>
-              {MEDIA_HOSTING_PROVIDERS.map((provider) => (
-                <div key={provider.id} className={styles.setting}>
-                  <label>
-                    <input
-                      type='radio'
-                      name={`${RADIO_NAME}-provider`}
-                      value={provider.id}
-                      checked={preferredProvider === provider.id}
-                      onChange={() => setPreferredProvider(provider.id as ProviderId)}
-                      disabled={isWeb}
-                    />
-                    {provider.label} (
-                    <a href={provider.homepageUrl} target='_blank' rel='noopener noreferrer'>
-                      {provider.homepageUrl}
-                    </a>
-                    )
-                  </label>
-                </div>
-              ))}
+              {MEDIA_HOSTING_PROVIDERS.map((provider) => {
+                const providerUnavailable = availability[provider.id] === 'unavailable';
+                const providerDisabled = isWeb || !provider.supportedRuntimes.includes(runtime) || providerUnavailable;
+                return (
+                  <div key={provider.id} className={styles.setting}>
+                    <label title={providerUnavailable ? t('media_hosting_provider_unavailable') : undefined}>
+                      <input
+                        type='radio'
+                        name={`${RADIO_NAME}-provider`}
+                        value={provider.id}
+                        checked={preferredProvider === provider.id}
+                        onChange={() => setPreferredProvider(provider.id as ProviderId)}
+                        disabled={providerDisabled}
+                      />
+                      {provider.label} (
+                      <a href={provider.homepageUrl} target='_blank' rel='noopener noreferrer'>
+                        {provider.homepageUrl}
+                      </a>
+                      )
+                    </label>
+                    {providerUnavailable && <div className={styles.settingTip}>{t('media_hosting_provider_unavailable')}</div>}
+                  </div>
+                );
+              })}
             </div>
           )}
         </div>

src/hooks/__tests__/use-file-upload.test.ts

@@ -31,16 +31,28 @@ vi.mock('../../lib/media-hosting/upload-orchestrator', () => ({
   orchestrateElectronUpload: vi.fn(),
 }));
 
+const providerAvailabilityRef = vi.hoisted(() => ({
+  value: {} as Record<string, 'unknown' | 'checking' | 'available' | 'unavailable'>,
+}));
+vi.mock('../../lib/media-hosting/provider-availability', () => ({
+  ensureProviderAvailability: vi.fn(async () => providerAvailabilityRef.value),
+}));
+
 vi.mock('../../lib/media-hosting/provider-order', () => ({
-  getProviderOrder: vi.fn((opts: { mode: string; preferredProvider: string; runtime: string }) => {
+  getProviderOrder: vi.fn((opts: { mode: string; preferredProvider: string; runtime: string; availability?: Record<string, string> }) => {
+    const filterAvailable = (providers: string[]) => providers.filter((provider) => opts.availability?.[provider] !== 'unavailable');
     if (opts.mode === 'none') return [];
-    if (opts.runtime === 'web') return opts.preferredProvider === 'catbox' ? ['catbox'] : [];
-    return opts.mode === 'preferred' ? [opts.preferredProvider] : ['catbox', 'imgur'];
+    if (opts.runtime === 'web') return filterAvailable(opts.preferredProvider === 'catbox' ? ['catbox'] : []);
+    if (opts.runtime === 'android') {
+      if (opts.mode === 'preferred') return filterAvailable(opts.preferredProvider === 'catbox' || opts.preferredProvider === 'imgbb' ? [opts.preferredProvider] : []);
+      return filterAvailable(['catbox', 'imgbb']);
+    }
+    return filterAvailable(opts.mode === 'preferred' ? [opts.preferredProvider] : ['catbox', 'imgur', 'imgbb']);
   }),
 }));
 
 const uploadModeRef = vi.hoisted(() => ({ value: 'random' as 'random' | 'preferred' | 'none' }));
-const preferredProviderRef = vi.hoisted(() => ({ value: 'catbox' as 'catbox' | 'imgur' }));
+const preferredProviderRef = vi.hoisted(() => ({ value: 'catbox' as 'catbox' | 'imgur' | 'imgbb' }));
 vi.mock('../../stores/use-media-hosting-store', () => ({
   default: (selector: (s: { uploadMode: string; preferredProvider: string }) => unknown) =>
     selector({ uploadMode: uploadModeRef.value, preferredProvider: preferredProviderRef.value }),
@@ -89,6 +101,7 @@ describe('useFileUpload', () => {
     vi.clearAllMocks();
     uploadModeRef.value = 'random';
     preferredProviderRef.value = 'catbox';
+    providerAvailabilityRef.value = {};
     latestHook = null;
     container = document.createElement('div');
     document.body.append(container);
@@ -268,7 +281,7 @@ describe('useFileUpload', () => {
     capacitorRejection.data = {
       attempts: [
         { provider: 'catbox', error: 'timeout' },
-        { provider: 'imgur', error: 'rate limit' },
+        { provider: 'imgbb', error: 'rate limit' },
       ],
     };
     vi.mocked(FileUploader.pickAndUploadMedia).mockRejectedValue(capacitorRejection);
@@ -278,7 +291,7 @@ describe('useFileUpload', () => {
       await hook().handleUpload();
     });
 
-    expect(window.alert).toHaveBeenCalledWith('upload_failed. upload_failed_all_providers: catbox: timeout; imgur: rate limit');
+    expect(window.alert).toHaveBeenCalledWith('upload_failed. upload_failed_all_providers: catbox: timeout; imgbb: rate limit');
     expect(onUploadComplete).not.toHaveBeenCalled();
     expect(hook().isUploading).toBe(false);
   });
@@ -319,6 +332,75 @@ describe('useFileUpload', () => {
     expect(hook().isUploading).toBe(false);
   });
 
+  it('does not call Android plugin when preferred provider is unsupported', async () => {
+    uploadModeRef.value = 'preferred';
+    preferredProviderRef.value = 'imgur';
+    vi.mocked(Capacitor.getPlatform).mockReturnValue('android');
+    const { onUploadComplete, hook } = mountHook();
+
+    await act(async () => {
+      await hook().handleUpload();
+    });
+
+    expect(FileUploader.pickAndUploadMedia).not.toHaveBeenCalled();
+    expect(window.alert).toHaveBeenCalledWith('upload_failed: imgur is not supported on android. upload_failed_preferred_guidance');
+    expect(onUploadComplete).not.toHaveBeenCalled();
+    expect(hook().isUploading).toBe(false);
+  });
+
+  it('does not call Android plugin when preferred provider is unavailable from this network', async () => {
+    uploadModeRef.value = 'preferred';
+    preferredProviderRef.value = 'imgbb';
+    providerAvailabilityRef.value = { imgbb: 'unavailable' };
+    vi.mocked(Capacitor.getPlatform).mockReturnValue('android');
+    const { onUploadComplete, hook } = mountHook();
+
+    await act(async () => {
+      await hook().handleUpload();
+    });
+
+    expect(FileUploader.pickAndUploadMedia).not.toHaveBeenCalled();
+    expect(window.alert).toHaveBeenCalledWith('upload_failed: imgbb is unavailable from this network. upload_failed_preferred_guidance');
+    expect(onUploadComplete).not.toHaveBeenCalled();
+    expect(hook().isUploading).toBe(false);
+  });
+
+  it('does not call Android plugin when random mode has no reachable providers', async () => {
+    uploadModeRef.value = 'random';
+    preferredProviderRef.value = 'catbox';
+    providerAvailabilityRef.value = { catbox: 'unavailable', imgbb: 'unavailable' };
+    vi.mocked(Capacitor.getPlatform).mockReturnValue('android');
+    const { onUploadComplete, hook } = mountHook();
+
+    await act(async () => {
+      await hook().handleUpload();
+    });
+
+    expect(FileUploader.pickAndUploadMedia).not.toHaveBeenCalled();
+    expect(window.alert).toHaveBeenCalledWith('upload_failed: No reachable upload providers are available from this network');
+    expect(onUploadComplete).not.toHaveBeenCalled();
+    expect(hook().isUploading).toBe(false);
+  });
+
+  it('calls Android plugin with only ImgBB when ImgBB is chosen', async () => {
+    uploadModeRef.value = 'preferred';
+    preferredProviderRef.value = 'imgbb';
+    vi.mocked(Capacitor.getPlatform).mockReturnValue('android');
+    vi.mocked(FileUploader.pickAndUploadMedia).mockResolvedValue({
+      url: 'https://i.ibb.co/example/android.png',
+      fileName: 'android.png',
+      provider: 'imgbb',
+    });
+    const { onUploadComplete, hook } = mountHook();
+
+    await act(async () => {
+      await hook().handleUpload();
+    });
+
+    expect(FileUploader.pickAndUploadMedia).toHaveBeenCalledWith({ providerOrder: ['imgbb'] });
+    expect(onUploadComplete).toHaveBeenCalledWith('https://i.ibb.co/example/android.png', 'android.png');
+  });
+
   it('Android call includes provider order payload', async () => {
     uploadModeRef.value = 'random';
     preferredProviderRef.value = 'catbox';
@@ -340,6 +422,7 @@ describe('useFileUpload', () => {
     });
     const call = vi.mocked(FileUploader.pickAndUploadMedia).mock.calls[0][0];
     expect(call?.providerOrder).toEqual(expect.arrayContaining(['catbox']));
+    expect(call?.providerOrder).toEqual(expect.arrayContaining(['imgbb']));
     expect(onUploadComplete).toHaveBeenCalledWith('https://files.catbox.moe/random.jpg', 'random.jpg');
   });
 
@@ -376,6 +459,7 @@ describe('useFileUpload', () => {
     err.attempts = [
       { provider: 'catbox', error: 'timeout' },
       { provider: 'imgur', error: 'rate limit' },
+      { provider: 'imgbb', error: 'blocked' },
     ];
     vi.mocked(orchestrateElectronUpload).mockRejectedValue(err);
 
@@ -391,7 +475,7 @@ describe('useFileUpload', () => {
       await uploadPromise;
     });
 
-    expect(window.alert).toHaveBeenCalledWith('upload_failed. upload_failed_all_providers: catbox: timeout; imgur: rate limit');
+    expect(window.alert).toHaveBeenCalledWith('upload_failed. upload_failed_all_providers: catbox: timeout; imgur: rate limit; imgbb: blocked');
     expect(onUploadComplete).not.toHaveBeenCalled();
     expect(hook().isUploading).toBe(false);
   });

src/hooks/use-file-upload.ts

@@ -1,10 +1,11 @@
 import { useCallback, useState } from 'react';
-import { Capacitor } from '@capacitor/core';
 import { useTranslation } from 'react-i18next';
 import FileUploader from '../plugins/file-uploader';
 import { formatAggregatedError, formatPreferredModeError, type ProviderAttempt } from '../lib/media-hosting/error-format';
 import { getProviderOrder } from '../lib/media-hosting/provider-order';
+import { getMediaHostingRuntime, isElectronRuntime } from '../lib/media-hosting/show-upload-controls';
 import { orchestrateElectronUpload } from '../lib/media-hosting/upload-orchestrator';
+import { ensureProviderAvailability } from '../lib/media-hosting/provider-availability';
 import useMediaHostingStore from '../stores/use-media-hosting-store';
 import type { ProviderId, UploadAttemptStage } from '../lib/media-hosting/types';
 
@@ -26,7 +27,7 @@ const ANDROID_STAGE_MAP: Record<string, UploadAttemptStage> = {
 
 const FILE_SELECTION_CANCELLED_ERROR = 'File selection cancelled';
 
-const VALID_PROVIDERS: ProviderId[] = ['catbox', 'imgur'];
+const VALID_PROVIDERS: ProviderId[] = ['catbox', 'imgur', 'imgbb'];
 
 /** Raw attempt shape from Android plugin rejection payload */
 interface RawAttempt {
@@ -82,16 +83,6 @@ function normalizeAndroidRejection(error: unknown): Error & { attempts?: Provide
   return err as Error & { attempts?: ProviderAttempt[] };
 }
 
-function isElectronRuntime(): boolean {
-  return window.electronApi?.isElectron === true || window.isElectron === true;
-}
-
-function getRuntime(): 'web' | 'electron' | 'android' {
-  if (Capacitor.getPlatform() === 'android') return 'android';
-  if (isElectronRuntime()) return 'electron';
-  return 'web';
-}
-
 interface UseFileUploadOptions {
   onUploadComplete: (url: string, fileName: string) => void;
 }
@@ -162,14 +153,30 @@ export function useFileUpload(options: UseFileUploadOptions) {
   const handleUpload = useCallback(async () => {
     if (uploadMode === 'none') return;
 
-    const runtime = getRuntime();
-    const order = getProviderOrder({ mode: uploadMode, preferredProvider, runtime });
-
+    const runtime = getMediaHostingRuntime();
     try {
       setIsUploading(true);
       setUploadedFileName(null);
+      const supportedOrder = getProviderOrder({ mode: uploadMode, preferredProvider, runtime });
+      const availability = await ensureProviderAvailability(runtime);
+      const order = getProviderOrder({ mode: uploadMode, preferredProvider, runtime, availability });
 
-      if (Capacitor.getPlatform() === 'android') {
+      if (order.length === 0) {
+        if (runtime === 'web') {
+          window.alert(t('upload_not_supported_web'));
+          return;
+        }
+        if (supportedOrder.length > 0) {
+          const message =
+            uploadMode === 'preferred' && availability[preferredProvider] === 'unavailable'
+              ? `${preferredProvider} is unavailable from this network`
+              : 'No reachable upload providers are available from this network';
+          throw new Error(message);
+        }
+        throw new Error(`${preferredProvider} is not supported on ${runtime}`);
+      }
+
+      if (runtime === 'android') {
         const result = await FileUploader.pickAndUploadMedia({ providerOrder: order });
         if (result.url) {
           if (result.fileName) setUploadedFileName(result.fileName);

src/hooks/use-provider-availability.ts

@@ -0,0 +1,7 @@
+import { useSyncExternalStore } from 'react';
+import type { MediaHostingRuntime } from '../lib/media-hosting/types';
+import { getProviderAvailabilitySnapshot, subscribeProviderAvailability } from '../lib/media-hosting/provider-availability';
+
+export function useProviderAvailability(runtime: MediaHostingRuntime) {
+  return useSyncExternalStore((listener) => subscribeProviderAvailability(listener, runtime), getProviderAvailabilitySnapshot, getProviderAvailabilitySnapshot);
+}

src/lib/media-hosting/__tests__/provider-availability.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ensureProviderAvailability, getProviderAvailabilitySnapshot, probeProviderAvailability, resetProviderAvailabilityForTests } from '../provider-availability';
+
+class MockImage {
+  static failedUrlPart = '';
+
+  onload: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  referrerPolicy = '';
+
+  set src(value: string) {
+    queueMicrotask(() => {
+      if (MockImage.failedUrlPart && value.includes(MockImage.failedUrlPart)) {
+        this.onerror?.();
+        return;
+      }
+      this.onload?.();
+    });
+  }
+}
+
+describe('provider-availability', () => {
+  beforeEach(() => {
+    resetProviderAvailabilityForTests();
+    MockImage.failedUrlPart = '';
+    vi.stubGlobal('Image', MockImage);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    resetProviderAvailabilityForTests();
+  });
+
+  it('marks runtime-supported providers available when probes load', async () => {
+    const snapshot = await ensureProviderAvailability('android');
+
+    expect(snapshot.catbox).toBe('available');
+    expect(snapshot.imgbb).toBe('available');
+    expect(snapshot.imgur).toBe('unknown');
+  });
+
+  it('marks a provider unavailable when one of its media probes fails', async () => {
+    MockImage.failedUrlPart = 'i.ibb.co';
+
+    const status = await probeProviderAvailability('imgbb');
+
+    expect(status).toBe('unavailable');
+    expect(getProviderAvailabilitySnapshot().imgbb).toBe('unavailable');
+  });
+
+  it('leaves providers unknown when image probing is unavailable', async () => {
+    vi.stubGlobal('Image', undefined);
+
+    const status = await probeProviderAvailability('catbox');
+
+    expect(status).toBe('unknown');
+    expect(getProviderAvailabilitySnapshot().catbox).toBe('unknown');
+  });
+});

src/lib/media-hosting/__tests__/provider-order.test.ts

@@ -6,24 +6,25 @@ describe('provider-order', () => {
     it('returns single-element array with preferred provider', () => {
       expect(getPreferredOrder('catbox')).toEqual(['catbox']);
       expect(getPreferredOrder('imgur')).toEqual(['imgur']);
+      expect(getPreferredOrder('imgbb')).toEqual(['imgbb']);
     });
   });
 
   describe('getRandomOrder', () => {
     it('returns shuffled copy (Fisher-Yates) with default rng', () => {
-      const providers = ['catbox', 'imgur'] as const;
+      const providers = ['catbox', 'imgur', 'imgbb'] as const;
       const result = getRandomOrder(providers);
-      expect(result).toHaveLength(2);
-      expect([...result].sort()).toEqual(['catbox', 'imgur']);
+      expect(result).toHaveLength(3);
+      expect([...result].sort()).toEqual(['catbox', 'imgbb', 'imgur']);
       expect(result).not.toBe(providers);
     });
 
     it('uses provided rng for deterministic shuffle', () => {
-      const providers = ['catbox', 'imgur'] as const;
+      const providers = ['catbox', 'imgur', 'imgbb'] as const;
       const rng = vi.fn().mockReturnValue(0.5);
       const result = getRandomOrder(providers, rng);
       expect(rng).toHaveBeenCalled();
-      expect(result).toHaveLength(2);
+      expect(result).toHaveLength(3);
     });
 
     it('handles empty array', () => {
@@ -61,6 +62,13 @@ describe('provider-order', () => {
           runtime: 'electron',
         }),
       ).toEqual(['imgur']);
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgbb',
+          runtime: 'android',
+        }),
+      ).toEqual(['imgbb']);
     });
 
     it('returns empty when preferred provider not supported on runtime', () => {
@@ -71,6 +79,20 @@ describe('provider-order', () => {
           runtime: 'web',
         }),
       ).toEqual([]);
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgur',
+          runtime: 'android',
+        }),
+      ).toEqual([]);
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgbb',
+          runtime: 'web',
+        }),
+      ).toEqual([]);
     });
 
     it('returns shuffled list when mode is random', () => {
@@ -79,8 +101,30 @@ describe('provider-order', () => {
         preferredProvider: 'catbox',
         runtime: 'electron',
       });
+      expect(order).toHaveLength(3);
+      expect([...order].sort()).toEqual(['catbox', 'imgbb', 'imgur']);
+    });
+
+    it('filters unavailable providers from random mode', () => {
+      const order = getProviderOrder({
+        mode: 'random',
+        preferredProvider: 'catbox',
+        runtime: 'electron',
+        availability: { imgur: 'unavailable' },
+      });
       expect(order).toHaveLength(2);
-      expect([...order].sort()).toEqual(['catbox', 'imgur']);
+      expect([...order].sort()).toEqual(['catbox', 'imgbb']);
+    });
+
+    it('returns empty when preferred provider is unavailable', () => {
+      expect(
+        getProviderOrder({
+          mode: 'preferred',
+          preferredProvider: 'imgbb',
+          runtime: 'android',
+          availability: { imgbb: 'unavailable' },
+        }),
+      ).toEqual([]);
     });
 
     it('filters by runtime for random mode', () => {
@@ -92,5 +136,15 @@ describe('provider-order', () => {
       expect(order).toHaveLength(1);
       expect(order).toEqual(['catbox']);
     });
+
+    it('uses catbox and imgbb for android random mode', () => {
+      const order = getProviderOrder({
+        mode: 'random',
+        preferredProvider: 'catbox',
+        runtime: 'android',
+      });
+      expect(order).toHaveLength(2);
+      expect([...order].sort()).toEqual(['catbox', 'imgbb']);
+    });
   });
 });

src/lib/media-hosting/provider-availability.ts

@@ -0,0 +1,147 @@
+import { MEDIA_HOSTING_PROVIDERS } from './providers';
+import type { MediaHostingRuntime, ProviderId } from './types';
+
+export type ProviderAvailabilityStatus = 'unknown' | 'checking' | 'available' | 'unavailable';
+export type ProviderAvailabilitySnapshot = Partial<Record<ProviderId, ProviderAvailabilityStatus>>;
+
+const PROBE_TIMEOUT_MS = 5_000;
+const PROBE_CACHE_MS = 10 * 60_000;
+
+type Listener = () => void;
+
+interface ProviderAvailabilityEntry {
+  status: ProviderAvailabilityStatus;
+  checkedAt: number;
+}
+
+const providerById = new Map(MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, provider]));
+let entries: Record<ProviderId, ProviderAvailabilityEntry> = Object.fromEntries(
+  MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, { status: 'unknown', checkedAt: 0 }]),
+) as Record<ProviderId, ProviderAvailabilityEntry>;
+let snapshot: ProviderAvailabilitySnapshot = buildSnapshot();
+const listeners = new Set<Listener>();
+const inFlight = new Map<ProviderId, Promise<ProviderAvailabilityStatus>>();
+
+function buildSnapshot(): ProviderAvailabilitySnapshot {
+  return Object.fromEntries(MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, entries[provider.id]?.status ?? 'unknown'])) as ProviderAvailabilitySnapshot;
+}
+
+function emit() {
+  snapshot = buildSnapshot();
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
+function setProviderStatus(provider: ProviderId, status: ProviderAvailabilityStatus) {
+  entries = {
+    ...entries,
+    [provider]: {
+      status,
+      checkedAt: status === 'checking' ? entries[provider].checkedAt : Date.now(),
+    },
+  };
+  emit();
+}
+
+function getRuntimeSupportedProviders(runtime: MediaHostingRuntime): ProviderId[] {
+  return MEDIA_HOSTING_PROVIDERS.filter((provider) => provider.supportedRuntimes.includes(runtime)).map((provider) => provider.id);
+}
+
+function shouldProbeProvider(provider: ProviderId): boolean {
+  if (inFlight.has(provider)) return false;
+  const entry = entries[provider];
+  return entry.status === 'unknown' || Date.now() - entry.checkedAt > PROBE_CACHE_MS;
+}
+
+function probeImageUrl(url: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const image = new Image();
+    let settled = false;
+    const timeoutId = window.setTimeout(() => settle(false), PROBE_TIMEOUT_MS);
+
+    const settle = (available: boolean) => {
+      if (settled) return;
+      settled = true;
+      window.clearTimeout(timeoutId);
+      image.onload = null;
+      image.onerror = null;
+      resolve(available);
+    };
+
+    image.onload = () => settle(true);
+    image.onerror = () => settle(false);
+    image.referrerPolicy = 'no-referrer';
+    image.src = url;
+  });
+}
+
+export function getProviderAvailabilitySnapshot(): ProviderAvailabilitySnapshot {
+  return snapshot;
+}
+
+export function subscribeProviderAvailability(listener: Listener, runtime?: MediaHostingRuntime): () => void {
+  listeners.add(listener);
+  if (runtime) {
+    startProviderAvailabilityProbes(runtime);
+  }
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+function startProviderAvailabilityProbes(runtime: MediaHostingRuntime) {
+  for (const provider of getRuntimeSupportedProviders(runtime)) {
+    if (shouldProbeProvider(provider)) {
+      void probeProviderAvailability(provider);
+    }
+  }
+}
+
+export async function probeProviderAvailability(provider: ProviderId): Promise<ProviderAvailabilityStatus> {
+  const running = inFlight.get(provider);
+  if (running) return running;
+
+  const definition = providerById.get(provider);
+  if (!definition) return 'unavailable';
+  if (!shouldProbeProvider(provider)) return entries[provider].status;
+
+  const promise = (async () => {
+    setProviderStatus(provider, 'checking');
+
+    if (!definition.availabilityProbeUrls.length) {
+      setProviderStatus(provider, 'available');
+      return 'available' as const;
+    }
+    if (typeof window === 'undefined' || typeof Image === 'undefined') {
+      setProviderStatus(provider, 'unknown');
+      return 'unknown' as const;
+    }
+
+    const results = await Promise.all(definition.availabilityProbeUrls.map((url) => probeImageUrl(url)));
+    const status: ProviderAvailabilityStatus = results.every(Boolean) ? 'available' : 'unavailable';
+    setProviderStatus(provider, status);
+    return status;
+  })();
+
+  inFlight.set(provider, promise);
+  try {
+    return await promise;
+  } finally {
+    inFlight.delete(provider);
+  }
+}
+
+export async function ensureProviderAvailability(runtime: MediaHostingRuntime): Promise<ProviderAvailabilitySnapshot> {
+  await Promise.all(getRuntimeSupportedProviders(runtime).map((provider) => probeProviderAvailability(provider)));
+  return getProviderAvailabilitySnapshot();
+}
+
+export function resetProviderAvailabilityForTests() {
+  entries = Object.fromEntries(MEDIA_HOSTING_PROVIDERS.map((provider) => [provider.id, { status: 'unknown', checkedAt: 0 }])) as Record<
+    ProviderId,
+    ProviderAvailabilityEntry
+  >;
+  inFlight.clear();
+  emit();
+}

src/lib/media-hosting/provider-order.ts

@@ -1,5 +1,6 @@
 import type { MediaHostingRuntime, ProviderId, UploadMode } from './types';
 import { MEDIA_HOSTING_PROVIDERS } from './providers';
+import type { ProviderAvailabilitySnapshot } from './provider-availability';
 
 /** Returns [preferredProvider] for preferred mode */
 export function getPreferredOrder(preferredProvider: ProviderId): ProviderId[] {
@@ -22,9 +23,14 @@ function getSupportedProviders(runtime: MediaHostingRuntime): ProviderId[] {
 }
 
 /** Get ordered provider list for an upload attempt */
-export function getProviderOrder(options: { mode: UploadMode; preferredProvider: ProviderId; runtime: MediaHostingRuntime }): ProviderId[] {
-  const { mode, preferredProvider, runtime } = options;
-  const supported = getSupportedProviders(runtime);
+export function getProviderOrder(options: {
+  mode: UploadMode;
+  preferredProvider: ProviderId;
+  runtime: MediaHostingRuntime;
+  availability?: ProviderAvailabilitySnapshot;
+}): ProviderId[] {
+  const { mode, preferredProvider, runtime, availability } = options;
+  const supported = getSupportedProviders(runtime).filter((provider) => availability?.[provider] !== 'unavailable');
 
   if (mode === 'none') return [];
   if (mode === 'preferred') {

src/lib/media-hosting/show-upload-controls.ts

@@ -1,13 +1,19 @@
 import { Capacitor } from '@capacitor/core';
-import type { UploadMode } from './types';
+import type { MediaHostingRuntime, UploadMode } from './types';
 
-function isElectronRuntime(): boolean {
+export function isElectronRuntime(): boolean {
   return window.electronApi?.isElectron === true || window.isElectron === true;
 }
 
+export function getMediaHostingRuntime(): MediaHostingRuntime {
+  if (Capacitor.getPlatform() === 'android') return 'android';
+  if (isElectronRuntime()) return 'electron';
+  return 'web';
+}
+
 /** Web runtime = web browser, not Electron */
 export function isWebRuntime(): boolean {
-  return Capacitor.getPlatform() === 'web' && !isElectronRuntime();
+  return getMediaHostingRuntime() === 'web';
 }
 
 /**