diff --git a/public/images/game_selection/placeholder.webp b/public/images/game_selection/placeholder.webp
new file mode 100644
index 000000000..a87083d47
Binary files /dev/null and b/public/images/game_selection/placeholder.webp differ
diff --git a/public/images/game_selection/thunderstore-beta.webp b/public/images/game_selection/thunderstore-beta.webp
deleted file mode 100644
index 7284eb280..000000000
Binary files a/public/images/game_selection/thunderstore-beta.webp and /dev/null differ
diff --git a/quasar.config.ts b/quasar.config.ts
index e9d7b21c7..d9f477a22 100644
--- a/quasar.config.ts
+++ b/quasar.config.ts
@@ -100,6 +100,15 @@ export default defineConfig((ctx) => {
             https: false,
             port: 9020,
             open: true, // opens browser window automatically
+            proxy: {
+                // Proxy for a local ecosystem-schema deployment.
+                // https://github.com/thunderstore-io/ecosystem-schema
+                '/_local': {
+                    target: 'http://localhost:1337',
+                    changeOrigin: true,
+                    rewrite: (path) => path.replace(/^\/_local/, ''),
+                },
+            },
         },
 
         // https://v2.quasar.dev/quasar-cli-vite/quasar-config-file#framework
diff --git a/scripts/sync.ts b/scripts/sync.ts
index 49493c4cb..025f94fdc 100644
--- a/scripts/sync.ts
+++ b/scripts/sync.ts
@@ -1,12 +1,23 @@
 import fs from "fs";
+import path from "path";
 
 import {FetchingJSONSchemaStore, InputData, JSONSchemaInput, quicktype} from "quicktype-core";
 
-const ECOSYSTEM_DATA_URL = "https://thunderstore.io/api/experimental/schema/dev/latest/";
-const ECOSYSTEM_JSON_SCHEMA_URL = "https://thunderstore.io/api/experimental/schema/ecosystem-json-schema/latest/";
+const REMOTE_SOURCE = {
+    ecosystemDataUrl: "https://thunderstore.io/api/experimental/schema/dev/latest/",
+    ecosystemJsonSchemaUrl: "https://thunderstore.io/api/experimental/schema/ecosystem-json-schema/latest/",
+    gameImageBaseUrl: "https://gcdn.thunderstore.io/assets",
+};
+const LOCAL_SOURCE = {
+    ecosystemDataUrl: "http://localhost:1337/latest.json",
+    ecosystemJsonSchemaUrl: "http://localhost:1337/latest.schema.json",
+    gameImageBaseUrl: "http://localhost:1337/assets",
+};
+
 const ECOSYSTEM_DATA_PATH = "./src/assets/data/ecosystem.json";
 const ECOSYSTEM_JSON_SCHEMA_PATH = "./src/assets/data/ecosystemJsonSchema.json";
 const ECOSYSTEM_DATA_TYPES_PATH = "./src/assets/data/ecosystemTypes.ts";
+const GAME_IMAGE_DIR_PATH = "./public/images/game_selection";
 
 /**
  * This script synchronizes the in-repo ecosystem schema JSON to the latest
@@ -22,16 +33,21 @@ async function updateSchema() {
         console.log("Skipping API update, reading JSON schema from disk...");
         schema = fs.readFileSync(ECOSYSTEM_JSON_SCHEMA_PATH);
     } else {
+        const source = await isReachable("http://localhost:1337/healthz") ? LOCAL_SOURCE : REMOTE_SOURCE;
+        console.log(`Syncing from ${new URL(source.ecosystemDataUrl).origin}...`);
+
         console.log("Updating ecosystem.json...");
-        const response = await fetch(ECOSYSTEM_DATA_URL);
+        const response = await fetch(source.ecosystemDataUrl);
         if (response.status !== 200) {
             throw new Error(`Received non-200 status from schema API: ${response.status}`);
         }
         const data = Buffer.from(await response.arrayBuffer());
         fs.writeFileSync(ECOSYSTEM_DATA_PATH, data);
 
+        await updateGameImages(data, source.gameImageBaseUrl);
+
         console.log("Updating ecosystemJsonSchema.json...");
-        const schemaResponse = await fetch(ECOSYSTEM_JSON_SCHEMA_URL);
+        const schemaResponse = await fetch(source.ecosystemJsonSchemaUrl);
         if (schemaResponse.status !== 200) {
             throw new Error(`Received non-200 status from schema API: ${schemaResponse.status}`);
         }
@@ -58,6 +74,53 @@ async function updateSchema() {
 
 updateSchema();
 
+async function updateGameImages(ecosystemData: Buffer, baseUrl: string): Promise<void> {
+    const ecosystem = JSON.parse(ecosystemData.toString());
+    const iconUrls = new Set<string>();
+    for (const game of Object.values<any>(ecosystem.games ?? {})) {
+        for (const entry of game?.r2modman ?? []) {
+            const iconUrl = entry?.meta?.iconUrl;
+            if (typeof iconUrl === "string" && iconUrl) {
+                iconUrls.add(iconUrl);
+            }
+        }
+    }
+
+    console.log(`Updating ${iconUrls.size} game images...`);
+    let failures = 0;
+    for (const iconUrl of iconUrls) {
+        try {
+            await fetchGameImage(baseUrl, iconUrl);
+        } catch (e) {
+            console.warn(`  ${(e as Error).message}`);
+            failures += 1;
+        }
+    }
+    if (failures > 0) {
+        console.warn(`Failed to fetch ${failures} of ${iconUrls.size} game images.`);
+    }
+}
+
+async function isReachable(url: string): Promise<boolean> {
+    try {
+        await fetch(url);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+async function fetchGameImage(baseUrl: string, iconUrl: string): Promise<void> {
+    const response = await fetch(`${baseUrl}/${iconUrl}`);
+    if (response.status !== 200) {
+        throw new Error(`Received non-200 status fetching ${iconUrl}: ${response.status}`);
+    }
+    const data = Buffer.from(await response.arrayBuffer());
+    const outPath = path.join(GAME_IMAGE_DIR_PATH, iconUrl);
+    fs.mkdirSync(path.dirname(outPath), {recursive: true});
+    fs.writeFileSync(outPath, data);
+}
+
 function enumKeysToUpperSnakeCase(tsCode: string): string {
     const enumRegex = /export enum (\w+) \{([\s\S]*?)\}/g;
     const enumKeyValueRegex = /(\w+) = "(.*?)"/g;
diff --git a/src-electron/electron-main.ts b/src-electron/electron-main.ts
index 80ce37c70..d407246f2 100644
--- a/src-electron/electron-main.ts
+++ b/src-electron/electron-main.ts
@@ -135,8 +135,15 @@ app.whenReady().then(() => {
         if (filePath.endsWith(path.sep)) {
             filePath = filePath.substring(0, filePath.length - 1);
         }
-        const fileContent = await fs.promises.readFile(path.join(publicFolder, filePath))
-        return new Response(fileContent);
+        try {
+            const fileContent = await fs.promises.readFile(path.join(publicFolder, filePath));
+            return new Response(fileContent);
+        } catch (e: any) {
+            if (e?.code === 'ENOENT') {
+                return new Response(null, { status: 404 });
+            }
+            throw e;
+        }
     })
 });
 
diff --git a/src/App.vue b/src/App.vue
index e0c7d499e..9f05d700b 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -57,6 +57,8 @@ import { NodeFsImplementation } from './providers/node/fs/NodeFsImplementation';
 import { useRouter } from 'vue-router';
 import { ProtocolProviderImplementation } from './providers/generic/protocol/ProtocolProviderImplementation';
 import { provideProtocolImplementation } from './providers/generic/protocol/ProtocolProvider';
+import GameImageProvider, { provideGameImageImplementation } from './providers/generic/image/GameImageProvider';
+import { GameImageProviderImplementation } from './r2mm/image/GameImageProviderImpl';
 import BreadcrumbNavigator from 'components/breadcrumbs/BreadcrumbNavigator.vue';
 
 const store = baseStore;
@@ -100,6 +102,7 @@ DataFolderProvider.provide(() => new DataFolderProviderImpl());
 PlatformInterceptorProvider.provide(() => new PlatformInterceptorImpl());
 
 provideProtocolImplementation(() => ProtocolProviderImplementation)
+provideGameImageImplementation(() => GameImageProviderImplementation);
 
 BindLoaderImpl.bind();
 
@@ -133,6 +136,8 @@ onMounted(async () => {
 
         await FileUtils.ensureDirectory(PathResolver.APPDATA_DIR);
 
+        await GameImageProvider.init();
+
         await ThemeManager.apply();
 
         window.app.isApplicationPortable().then((isPortable: boolean) => {
diff --git a/src/components/composables/GameImageComposable.ts b/src/components/composables/GameImageComposable.ts
new file mode 100644
index 000000000..ba90e8048
--- /dev/null
+++ b/src/components/composables/GameImageComposable.ts
@@ -0,0 +1,12 @@
+import { ref } from 'vue';
+import GameImageProvider from '../../providers/generic/image/GameImageProvider';
+
+export function useGameImageComposable() {
+    const imageSrc = ref<string>(GameImageProvider.placeholderUrl);
+
+    async function setIcon(iconUrl: string) {
+        imageSrc.value = await GameImageProvider.resolve(iconUrl);
+    }
+
+    return { imageSrc, setIcon };
+}
diff --git a/src/components/game-selection/GameSelectionCard.vue b/src/components/game-selection/GameSelectionCard.vue
index b867f5d25..0926788dd 100644
--- a/src/components/game-selection/GameSelectionCard.vue
+++ b/src/components/game-selection/GameSelectionCard.vue
@@ -3,7 +3,7 @@
         <div class="game-card">
             <div class="game-card__image">
                 <template v-if="activeTab === GameInstanceType.GAME">
-                    <img :src="getImageHref(`/images/game_selection/${game.gameImage}`)" alt="Game Logo" class="game-card__thumbnail"/>
+                    <img :src="imageSrc" alt="Game Logo" class="game-card__thumbnail"/>
                 </template>
                 <template v-else>
                     <div class="game-card__placeholder">{{ game.displayName }}</div>
@@ -34,9 +34,10 @@
 </template>
 
 <script lang="ts" setup>
+import { watch } from 'vue';
 import Game from '../../model/game/Game';
 import { GameInstanceType } from '../../model/schema/ThunderstoreSchema';
-import ProtocolProvider from '../../providers/generic/protocol/ProtocolProvider';
+import { useGameImageComposable } from '../composables/GameImageComposable';
 
 type Props = {
     game: Game;
@@ -53,9 +54,8 @@ const emit = defineEmits<{
     'toggle-favourite': [game: Game];
 }>();
 
-function getImageHref(image: string) {
-    return ProtocolProvider.getPublicAssetUrl(image);
-}
+const { imageSrc, setIcon } = useGameImageComposable();
+watch(() => props.game.iconUrl, setIcon, { immediate: true });
 </script>
 
 <style scoped lang="scss">
@@ -80,7 +80,6 @@ function getImageHref(image: string) {
 
 .game-card__image {
     display: block;
-    background-color: black;
 }
 
 .game-card__thumbnail {
diff --git a/src/components/navigation/ManagerActivityBar.vue b/src/components/navigation/ManagerActivityBar.vue
index fbd41b079..8e973e5fb 100644
--- a/src/components/navigation/ManagerActivityBar.vue
+++ b/src/components/navigation/ManagerActivityBar.vue
@@ -3,7 +3,7 @@
         <div class="activity-bar--left">
             <div class="activity-bar__group">
                 <button class="activity-bar__context-item" id="game-switch-button" @click.prevent.stop="changeGame">
-                    <img class="game-icon" :src="ProtocolProvider.getPublicAssetUrl(`/images/game_selection/${activeGame.gameImage}`)" alt="Game icon"/>
+                    <img class="game-icon" :src="imageSrc" alt="Game icon"/>
                     <span>{{ activeGame.displayName }}</span>
                 </button>
                 <span class="activity-bar__item-label non-selectable activity-bar__item-divider">/</span>
@@ -32,12 +32,12 @@
 </template>
 
 <script lang="ts" setup>
-import { computed } from 'vue';
+import { computed, watch } from 'vue';
 import { useRouter } from 'vue-router';
 import { getStore } from '../../providers/generic/store/StoreProvider';
 import { State } from '../../store';
 import { ActivityDropdown } from '../all';
-import ProtocolProvider from '../../providers/generic/protocol/ProtocolProvider';
+import { useGameImageComposable } from '../composables/GameImageComposable';
 
 const store = getStore<State>();
 const router = useRouter();
@@ -45,6 +45,9 @@ const router = useRouter();
 const activeGame = computed(() => store.state.activeGame);
 const profile = computed(() => store.getters['profile/activeProfile']);
 
+const { imageSrc, setIcon } = useGameImageComposable();
+watch(() => activeGame.value.iconUrl, setIcon, { immediate: true });
+
 function changeGame() {
     router.push('/');
 }
diff --git a/src/model/game/Game.ts b/src/model/game/Game.ts
index 7122f578e..57895b6c8 100644
--- a/src/model/game/Game.ts
+++ b/src/model/game/Game.ts
@@ -13,7 +13,7 @@ export default class Game {
     private readonly _thunderstoreUrl: string;
     private readonly _thunderstoreIdentifier: string;
     private readonly _storePlatformMetadata: StorePlatformMetadata[];
-    private readonly _gameImage: string;
+    private readonly _iconUrl: string;
     private readonly _displayMode: GameSelectionDisplayMode;
     private readonly _instanceType: GameInstanceType;
     private readonly _packageLoader: PackageLoader;
@@ -32,7 +32,7 @@ export default class Game {
         tsUrl: string,
         tsIdentifier: string,
         platforms: StorePlatformMetadata[],
-        gameImage: string,
+        iconUrl: string,
         displayMode: GameSelectionDisplayMode,
         instanceType: GameInstanceType,
         packageLoader: PackageLoader,
@@ -49,7 +49,7 @@ export default class Game {
         this._thunderstoreIdentifier = tsIdentifier;
         this._storePlatformMetadata = platforms;
         this._activePlatform = platforms[0];
-        this._gameImage = gameImage;
+        this._iconUrl = iconUrl;
         this._displayMode = displayMode;
         this._instanceType = instanceType;
         this._packageLoader = packageLoader;
@@ -109,8 +109,8 @@ export default class Game {
         this._activePlatform = platform;
     }
 
-    get gameImage(): string {
-        return this._gameImage;
+    get iconUrl(): string {
+        return this._iconUrl;
     }
 
     get displayMode(): GameSelectionDisplayMode {
diff --git a/src/model/game/GameManager.ts b/src/model/game/GameManager.ts
index 8f5196163..78cb0e699 100644
--- a/src/model/game/GameManager.ts
+++ b/src/model/game/GameManager.ts
@@ -35,7 +35,7 @@ export default class GameManager {
             game.distributions.map(
                 (x) => new StorePlatformMetadata(x.platform, x.identifier || undefined)
             ),
-            game.meta.iconUrl || "thunderstore-beta.webp",
+            game.meta.iconUrl ?? "",
             game.gameSelectionDisplayMode,
             game.gameInstanceType,
             game.packageLoader,
diff --git a/src/pages/GameSelectionScreen.vue b/src/pages/GameSelectionScreen.vue
index 28ecfc381..71b5fc06a 100644
--- a/src/pages/GameSelectionScreen.vue
+++ b/src/pages/GameSelectionScreen.vue
@@ -98,7 +98,10 @@ import Game from '../model/game/Game';
 import { capitalize } from '../utils/StringUtils';
 import { StorePlatform as platformLabels } from '../model/platform/StorePlatform';
 import EcosystemUpdateIndicator from '../components/navigation/EcosystemUpdateIndicator.vue';
+import { getStore } from '../providers/generic/store/StoreProvider';
+import { State } from '../store';
 
+const store = getStore<State>();
 
 const gameSelection = useGameSelectionComposable();
 provide(gameSelectionKey, gameSelection);
@@ -159,6 +162,7 @@ function selectPlatform() {
 onMounted(async () => {
     window.app.checkForApplicationUpdates();
     await initialize();
+    void store.dispatch('ecosystemUpdate/updateEcosystemSchema');
 });
 </script>
 
diff --git a/src/providers/generic/image/GameImageProvider.ts b/src/providers/generic/image/GameImageProvider.ts
new file mode 100644
index 000000000..15c5d5295
--- /dev/null
+++ b/src/providers/generic/image/GameImageProvider.ts
@@ -0,0 +1,28 @@
+import ProviderUtils from '../ProviderUtils';
+
+export type GameImageProvider = {
+    init(): Promise<void>;
+    readonly placeholderUrl: string;
+    resolve(iconUrl: string): Promise<string>;
+};
+
+let implementation: (() => GameImageProvider) | undefined;
+
+function getImplementation(): GameImageProvider {
+    if (!implementation) {
+        ProviderUtils.throwNotProvidedError("GameImageProvider");
+    }
+    return implementation!();
+}
+
+export function provideGameImageImplementation(provider: () => GameImageProvider) {
+    implementation = provider;
+}
+
+const gameImage: GameImageProvider = {
+    init: () => getImplementation().init(),
+    get placeholderUrl() { return getImplementation().placeholderUrl; },
+    resolve: (iconUrl) => getImplementation().resolve(iconUrl),
+};
+
+export default gameImage;
diff --git a/src/r2mm/ecosystem/EcosystemSchema.ts b/src/r2mm/ecosystem/EcosystemSchema.ts
index 7764f6d87..9be3884c4 100644
--- a/src/r2mm/ecosystem/EcosystemSchema.ts
+++ b/src/r2mm/ecosystem/EcosystemSchema.ts
@@ -12,37 +12,44 @@ import ManagerInformation from "../../_managerinf/ManagerInformation";
 import {EcosystemModloaderPackages, EcosystemSupportedGames} from "../../model/schema/ThunderstoreSchema";
 import {updateModLoaderExports} from "../installing/profile_installers/ModLoaderVariantRecord";
 import LoggerProvider, {LogSeverity} from "../../providers/ror2/logging/LoggerProvider";
+import {getAxiosWithTimeouts} from "../../utils/HttpUtils";
+import {retry} from "../../utils/Common";
 
-export type VersionedThunderstoreEcosystem = ThunderstoreEcosystem & {version: string};
+export type VersionedThunderstoreEcosystem = ThunderstoreEcosystem & {
+    version: string;
+    lastModified?: string;
+};
 
-async function getMergedEcosystemPath(): Promise<string> {
-    return path.join(PathResolver.ROOT, "latest-ecosystem-schema.json");
-}
+type LatestSchemaFetchResult =
+    | {kind: "not-modified"}
+    | {kind: "fetched", schema: ThunderstoreEcosystem, lastModified?: string}
+    | {kind: "failed"};
 
-export async function updateLatestEcosystemSchema(): Promise<void> {
-    const latestSchema = await fetchLatestSchema();
-    await writeLatestEcosystemSchema(latestSchema);
-    await internalUpdateEcosystemReactives(latestSchema);
+const REMOTE_ECOSYSTEM_DATA_URL = "https://thunderstore.io/api/experimental/schema/dev/latest/";
+const LOCAL_ECOSYSTEM_DATA_URL = "/_local/latest.json";
+const LOCAL_HEALTHZ_URL = "/_local/healthz";
+
+async function isLocalSchemaReachable(): Promise<boolean> {
+    try {
+        const res = await fetch(LOCAL_HEALTHZ_URL);
+        return res.ok;
+    } catch {
+        return false;
+    }
 }
 
-async function writeLatestEcosystemSchema(schema: ThunderstoreEcosystem): Promise<void> {
-    const asMergedSchema: VersionedThunderstoreEcosystem = {
-        ...schema,
-        version: ManagerInformation.VERSION.toString(),
-    };
-    const writable = JSON.stringify(asMergedSchema);
-    return FsProvider.instance.writeFile(await getMergedEcosystemPath(), writable);
+async function resolveEcosystemDataUrl(): Promise<string> {
+    if (import.meta.env.MODE === "development" && await isLocalSchemaReachable()) {
+        return LOCAL_ECOSYSTEM_DATA_URL;
+    }
+    return REMOTE_ECOSYSTEM_DATA_URL;
 }
 
-async function getLastSavedEcosystemSchema(): Promise<VersionedThunderstoreEcosystem> {
-    const contentBuffer = await FsProvider.instance.readFile(await getMergedEcosystemPath());
-    const content = contentBuffer.toString("utf8");
-    const parsedContent = JSON.parse(content);
-    await validateSchema(parsedContent);
-    return parsedContent;
+async function getMergedEcosystemPath(): Promise<string> {
+    return path.join(PathResolver.ROOT, "latest-ecosystem-schema.json");
 }
 
-async function validateSchema(schema: any): Promise<void> {
+function validateSchema(schema: unknown): ThunderstoreEcosystem {
     const ajv = new Ajv();
     addFormats(ajv);
 
@@ -52,15 +59,15 @@ async function validateSchema(schema: any): Promise<void> {
     if (!isOk) {
         throw new R2Error("Schema validation error", ajv.errorsText(validate.errors));
     }
+
+    return schema as ThunderstoreEcosystem;
 }
 
-async function loadBundledSchema(): Promise<ThunderstoreEcosystem> {
-    await validateSchema(bundledEcosystem);
-    return bundledEcosystem as ThunderstoreEcosystem;
+function loadBundledSchema(): ThunderstoreEcosystem {
+    return validateSchema(bundledEcosystem);
 }
 
-async function fetchLatestSchema(): Promise<ThunderstoreEcosystem> {
-    // TODO - Implement fetching of latest resource
+function createEmptySchema(): ThunderstoreEcosystem {
     return {
         schemaVersion: "",
         communities: {},
@@ -70,16 +77,129 @@ async function fetchLatestSchema(): Promise<ThunderstoreEcosystem> {
     };
 }
 
-async function resolveCachedEcosystemSchema(): Promise<VersionedThunderstoreEcosystem> {
+function mergeSchemas(
+    bundledSchema: ThunderstoreEcosystem,
+    latestSchema: ThunderstoreEcosystem
+): ThunderstoreEcosystem {
+    const modloaderMap = new Map(
+        [...bundledSchema.modloaderPackages, ...latestSchema.modloaderPackages]
+            .map(pkg => [pkg.packageId, pkg])
+    );
+
+    return {
+        schemaVersion: latestSchema.schemaVersion,
+        communities: {
+            ...bundledSchema.communities,
+            ...latestSchema.communities,
+        },
+        games: {
+            ...bundledSchema.games,
+            ...latestSchema.games,
+        },
+        modloaderPackages: [...modloaderMap.values()],
+        packageInstallers: {
+            ...bundledSchema.packageInstallers,
+            ...latestSchema.packageInstallers,
+        },
+    };
+}
+
+async function fetchLatestSchema(
+    currentSchema: VersionedThunderstoreEcosystem | null
+): Promise<LatestSchemaFetchResult> {
+    const timeout = 5000;
+    const requestConfig = {
+        validateStatus: (status: number) => {
+            if (status === 304) {
+                return true;
+            }
+            return status >= 200 && status < 300;
+        },
+        ...(currentSchema?.lastModified ? {headers: {"If-Modified-Since": currentSchema.lastModified}} : {}),
+    };
+
+    try {
+        const url = await resolveEcosystemDataUrl();
+        const axios = getAxiosWithTimeouts(timeout, timeout * 2);
+        const response = await retry(
+            () => axios.get(url, requestConfig),
+            {attempts: 3, interval: 1000, throwLastErrorAsIs: true}
+        );
+        const lastModified = typeof response.headers["last-modified"] === "string"
+            ? response.headers["last-modified"]
+            : undefined;
+
+        if (response.status === 304) {
+            return {kind: "not-modified"};
+        }
+
+        return {
+            kind: "fetched",
+            schema: validateSchema(response.data),
+            ...(lastModified ? {lastModified} : {}),
+        };
+    } catch (e) {
+        console.error(e);
+        return {kind: "failed"};
+    }
+}
+
+export async function updateLatestEcosystemSchema(): Promise<void> {
+    const bundledSchema = loadBundledSchema();
+    const currentSchema = await loadSavedEcosystemSchema();
+    const result = await fetchLatestSchema(currentSchema);
+
+    if (result.kind === "not-modified") {
+        return;
+    }
+
+    if (result.kind === "failed") {
+        if (currentSchema == null) {
+            await writeLatestEcosystemSchema(bundledSchema);
+            await internalUpdateEcosystemReactives(bundledSchema);
+        }
+        throw new Error("Failed to update game list");
+    }
+
+    const mergedSchema = mergeSchemas(bundledSchema, result.schema);
+    await writeLatestEcosystemSchema(mergedSchema, result.lastModified);
+    await internalUpdateEcosystemReactives(mergedSchema);
+}
+
+async function writeLatestEcosystemSchema(
+    schema: ThunderstoreEcosystem,
+    lastModified?: string
+): Promise<void> {
+    const asMergedSchema: VersionedThunderstoreEcosystem = {
+        ...schema,
+        version: ManagerInformation.VERSION.toString(),
+        ...(lastModified != null ? {lastModified} : {}),
+    };
+    const writable = JSON.stringify(asMergedSchema);
+    return FsProvider.instance.writeFile(await getMergedEcosystemPath(), writable);
+}
+
+async function readSavedEcosystemSchema(): Promise<VersionedThunderstoreEcosystem> {
+    const contentBuffer = await FsProvider.instance.readFile(await getMergedEcosystemPath());
+    const content = contentBuffer.toString("utf8");
+    const parsedContent = JSON.parse(content);
+    const {version, lastModified, ...schemaContent} = parsedContent as VersionedThunderstoreEcosystem;
+    void version;
+    void lastModified;
+    validateSchema(schemaContent);
+    return parsedContent as VersionedThunderstoreEcosystem;
+}
+
+async function loadSavedEcosystemSchema(): Promise<VersionedThunderstoreEcosystem | null> {
     const mergeFilePath = await getMergedEcosystemPath();
-    const bundledSchema = async () => ({...(await loadBundledSchema()), version: ManagerInformation.VERSION.toString()});
     if (!(await FsProvider.instance.exists(mergeFilePath))) {
-        return bundledSchema();
+        return null;
     }
+
     try {
-        let content = await getLastSavedEcosystemSchema();
+        const content = await readSavedEcosystemSchema();
         if (!new VersionNumber(content.version).isEqualTo(ManagerInformation.VERSION)) {
-            return bundledSchema();
+            return null;
         }
         return content;
     } catch (e) {
@@ -88,8 +208,16 @@ async function resolveCachedEcosystemSchema(): Promise<VersionedThunderstoreEcos
             LogSeverity.ERROR,
             `Failed to load cached ecosystem schema, falling back to bundled schema\n${err.message}`
         );
-        return bundledSchema();
+        return null;
+    }
+}
+
+async function resolveCachedEcosystemSchema(): Promise<ThunderstoreEcosystem> {
+    const content = await loadSavedEcosystemSchema();
+    if (content != null) {
+        return content;
     }
+    return loadBundledSchema();
 }
 
 async function internalUpdateEcosystemReactives(schema: ThunderstoreEcosystem): Promise<void> {
diff --git a/src/r2mm/image/GameImageProviderImpl.ts b/src/r2mm/image/GameImageProviderImpl.ts
new file mode 100644
index 000000000..59788b5e9
--- /dev/null
+++ b/src/r2mm/image/GameImageProviderImpl.ts
@@ -0,0 +1,137 @@
+import buffer from '../../providers/node/buffer/buffer';
+import path from '../../providers/node/path/path';
+import CdnProvider from '../../providers/generic/connection/CdnProvider';
+import FsProvider from '../../providers/generic/file/FsProvider';
+import { GameImageProvider } from '../../providers/generic/image/GameImageProvider';
+import LoggerProvider, { LogSeverity } from '../../providers/ror2/logging/LoggerProvider';
+import PathResolver from '../manager/PathResolver';
+import ProtocolProvider from '../../providers/generic/protocol/ProtocolProvider';
+
+const BUNDLED_ASSET_DIR = "/images/game_selection";
+const PLACEHOLDER_FILE = "placeholder.webp";
+const CDN_ASSET_BASE = "https://gcdn.thunderstore.io/assets";
+const LOCAL_DEV_ASSET_BASE = "/_local/assets";
+const CDN_FETCH_TIMEOUT_MS = 10000;
+const CDN_BREAKER_THRESHOLD = 3;
+const CACHE_SUBDIR = "image-cache";
+
+class GameImageProviderImpl implements GameImageProvider {
+
+    private cacheRoot: string | undefined;
+    private cdnConsecutiveFailures = 0;
+    private cdnBreakerTripped = false;
+
+    public async init(): Promise<void> {
+        if (PathResolver.APPDATA_DIR) {
+            const root = path.join(PathResolver.APPDATA_DIR, CACHE_SUBDIR);
+            await FsProvider.instance.mkdirs(root);
+            this.cacheRoot = root;
+        }
+    }
+
+    public get placeholderUrl(): string {
+        return this.bundledUrlFor(PLACEHOLDER_FILE);
+    }
+
+    public async resolve(iconUrl: string): Promise<string> {
+        if (!iconUrl) {
+            return this.placeholderUrl;
+        }
+
+        const bundledUrl = this.bundledUrlFor(iconUrl);
+        if (await this.urlReachable(bundledUrl)) {
+            return bundledUrl;
+        }
+
+        if (import.meta.env.MODE === "development") {
+            const localUrl = `${LOCAL_DEV_ASSET_BASE}/${iconUrl}`;
+            if (await this.urlReachable(localUrl)) {
+                return localUrl;
+            }
+        }
+
+        const cachePath = this.cachePathFor(iconUrl);
+        if (cachePath && await FsProvider.instance.exists(cachePath)) {
+            return await this.dataUrlFromFile(cachePath);
+        }
+
+        if (cachePath && !this.cdnBreakerTripped) {
+            const cached = await this.fetchFromCdnAndCache(iconUrl, cachePath);
+            if (cached) {
+                return cached;
+            }
+        }
+
+        return this.placeholderUrl;
+    }
+
+    private bundledUrlFor(iconUrl: string): string {
+        return ProtocolProvider.getPublicAssetUrl(`${BUNDLED_ASSET_DIR}/${iconUrl}`);
+    }
+
+    private async urlReachable(url: string): Promise<boolean> {
+        return fetch(url).then(res => res.ok).catch(() => false);
+    }
+
+    private cachePathFor(iconUrl: string): string | undefined {
+        if (!this.cacheRoot) {
+            return undefined;
+        }
+        if (iconUrl.includes("..") || iconUrl.startsWith("/") || iconUrl.includes("\\")) {
+            return undefined;
+        }
+        return path.join(this.cacheRoot, ...iconUrl.split("/"));
+    }
+
+    private async dataUrlFromFile(filePath: string): Promise<string> {
+        const content = await FsProvider.instance.base64FromZip(filePath);
+        return `data:image/webp;base64,${content}`;
+    }
+
+    private async fetchFromCdnAndCache(iconUrl: string, cachePath: string): Promise<string | undefined> {
+        const cdnUrl = CdnProvider.replaceCdnHost(`${CDN_ASSET_BASE}/${iconUrl}`);
+
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), CDN_FETCH_TIMEOUT_MS);
+        let res: Response;
+        try {
+            res = await fetch(cdnUrl, { signal: controller.signal });
+        } catch (e) {
+            this.recordCdnFailure(`fetch threw for ${cdnUrl}: ${(e as Error).message}`);
+            return undefined;
+        } finally {
+            clearTimeout(timer);
+        }
+
+        if (res.status === 404 || res.status === 403) {
+            this.cdnConsecutiveFailures = 0;
+            return undefined;
+        }
+        if (!res.ok) {
+            this.recordCdnFailure(`${res.status} ${res.statusText} on ${cdnUrl}`);
+            return undefined;
+        }
+
+        try {
+            const arrayBuffer = await res.arrayBuffer();
+            await FsProvider.instance.mkdirs(path.dirname(cachePath));
+            await FsProvider.instance.writeFile(cachePath, buffer.from(arrayBuffer));
+            this.cdnConsecutiveFailures = 0;
+            return await this.dataUrlFromFile(cachePath);
+        } catch (e) {
+            this.recordCdnFailure(`Failed to cache ${cdnUrl}: ${(e as Error).message}`);
+            return undefined;
+        }
+    }
+
+    private recordCdnFailure(detail: string): void {
+        this.cdnConsecutiveFailures += 1;
+        LoggerProvider.instance.Log(LogSeverity.ERROR, `GameImage CDN fetch failed: ${detail}`);
+        if (this.cdnConsecutiveFailures >= CDN_BREAKER_THRESHOLD) {
+            this.cdnBreakerTripped = true;
+        }
+    }
+
+}
+
+export const GameImageProviderImplementation: GameImageProvider = new GameImageProviderImpl();
diff --git a/src/store/modules/EcosystemUpdateModule.ts b/src/store/modules/EcosystemUpdateModule.ts
index 95e995d69..525027800 100644
--- a/src/store/modules/EcosystemUpdateModule.ts
+++ b/src/store/modules/EcosystemUpdateModule.ts
@@ -1,7 +1,7 @@
 import { ActionTree, GetterTree, MutationTree } from 'vuex';
 
 import { State as RootState } from '../../store';
-import { EcosystemSupportedGames } from '../../model/schema/ThunderstoreSchema';
+import { updateLatestEcosystemSchema } from '../../r2mm/ecosystem/EcosystemSchema';
 
 export interface EcosystemUpdateState {
     isInProgress: boolean;
@@ -47,9 +47,7 @@ export const EcosystemUpdateModule = {
             commit('startUpdate');
 
             try {
-                // Re-evaluate the ecosystem schema. Future remote refresh
-                // logic should be plugged in here.
-                void EcosystemSupportedGames.value;
+                await updateLatestEcosystemSchema();
             } catch (e) {
                 commit('setError', e instanceof Error ? e : new Error(String(e)));
             } finally {
diff --git a/test/vitest/tests/unit/EcosystemSchema/EcosystemSchema.spec.ts b/test/vitest/tests/unit/EcosystemSchema/EcosystemSchema.spec.ts
index 6ffab811f..351d94056 100644
--- a/test/vitest/tests/unit/EcosystemSchema/EcosystemSchema.spec.ts
+++ b/test/vitest/tests/unit/EcosystemSchema/EcosystemSchema.spec.ts
@@ -6,6 +6,7 @@ vi.mock('../../../../../src/assets/data/ecosystemJsonSchema.json', () => ({
     get default() { return mockJsonSchema; }
 }));
 
+import type {ThunderstoreEcosystem} from '../../../../../src/assets/data/ecosystemTypes';
 import {VersionedThunderstoreEcosystem, updateEcosystemReactives, updateLatestEcosystemSchema} from '../../../../../src/r2mm/ecosystem/EcosystemSchema';
 import {EcosystemModloaderPackages, EcosystemSupportedGames} from '../../../../../src/model/schema/ThunderstoreSchema';
 import {MODLOADER_PACKAGES, MOD_LOADER_VARIANTS, updateModLoaderExports} from '../../../../../src/r2mm/installing/profile_installers/ModLoaderVariantRecord';
@@ -18,16 +19,32 @@ import ManagerInformation from '../../../../../src/_managerinf/ManagerInformatio
 import LoggerProvider from '../../../../../src/providers/ror2/logging/LoggerProvider';
 import StubLoggerProvider from '../../../stubs/providers/stub.LoggerProvider';
 
+const mockAxiosGet = vi.fn();
+
+vi.mock('../../../../../src/utils/HttpUtils', () => ({
+    getAxiosWithTimeouts: () => ({get: mockAxiosGet}),
+}));
+
+vi.mock('../../../../../src/utils/Common', () => ({
+    retry: (fn: () => Promise<any>) => fn(),
+}));
+
 const TEST_ROOT = 'TEST_ROOT';
 const latestSchemaFilePath = path.join(TEST_ROOT, 'latest-ecosystem-schema.json');
 
-async function writeCacheFile(schema: Partial<VersionedThunderstoreEcosystem>) {
-    const full: VersionedThunderstoreEcosystem = {
+function createMinimalSchema(): ThunderstoreEcosystem {
+    return {
         schemaVersion: '0.0.0',
         communities: {},
         games: {},
         modloaderPackages: [],
         packageInstallers: {},
+    };
+}
+
+async function writeCacheFile(schema: Partial<VersionedThunderstoreEcosystem>) {
+    const full: VersionedThunderstoreEcosystem = {
+        ...createMinimalSchema(),
         version: ManagerInformation.VERSION.toString(),
         ...schema,
     };
@@ -50,6 +67,7 @@ describe('EcosystemSchema', () => {
         LoggerProvider.provide(() => loggerImpl);
         spyLogger = vi.spyOn(LoggerProvider.instance, 'Log').mockImplementation(() => {});
         updateModLoaderExports();
+        mockAxiosGet.mockReset();
         await FsProvider.instance.mkdirs(TEST_ROOT);
     });
 
@@ -115,16 +133,24 @@ describe('EcosystemSchema', () => {
 
     describe('updateLatestEcosystemSchema', () => {
 
-        test('writes file to disk', async () => {
-            expect(await FsProvider.instance.exists(latestSchemaFilePath)).toBe(false);
+        test('writes file to disk when fetch succeeds', async () => {
+            mockAxiosGet.mockResolvedValue({
+                status: 200,
+                data: createMinimalSchema(),
+                headers: {},
+            });
 
+            expect(await FsProvider.instance.exists(latestSchemaFilePath)).toBe(false);
             await updateLatestEcosystemSchema();
-
             expect(await FsProvider.instance.exists(latestSchemaFilePath)).toBe(true);
         });
 
         test('written file contains current version', async () => {
-            expect(await FsProvider.instance.exists(latestSchemaFilePath)).toBe(false);
+            mockAxiosGet.mockResolvedValue({
+                status: 200,
+                data: createMinimalSchema(),
+                headers: {},
+            });
 
             await updateLatestEcosystemSchema();
 
@@ -133,6 +159,131 @@ describe('EcosystemSchema', () => {
             expect(parsed.version).toBe(ManagerInformation.VERSION.toString());
         });
 
+        test('stores lastModified from response header', async () => {
+            const lastModified = 'Tue, 15 Apr 2026 12:00:00 GMT';
+            mockAxiosGet.mockResolvedValue({
+                status: 200,
+                data: createMinimalSchema(),
+                headers: {'last-modified': lastModified},
+            });
+
+            await updateLatestEcosystemSchema();
+
+            const content = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+            const parsed: VersionedThunderstoreEcosystem = JSON.parse(content);
+            expect(parsed.lastModified).toBe(lastModified);
+        });
+
+        test('sends If-Modified-Since header when cache has lastModified', async () => {
+            const cachedLastModified = 'Mon, 14 Apr 2026 12:00:00 GMT';
+            await writeCacheFile({lastModified: cachedLastModified});
+
+            mockAxiosGet.mockResolvedValue({
+                status: 304,
+                data: null,
+                headers: {},
+            });
+
+            await updateLatestEcosystemSchema();
+
+            expect(mockAxiosGet).toHaveBeenCalledWith(
+                expect.any(String),
+                expect.objectContaining({
+                    headers: {'If-Modified-Since': cachedLastModified},
+                })
+            );
+        });
+
+        test('does nothing on 304 Not Modified', async () => {
+            await writeCacheFile({});
+            const originalContent = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+
+            mockAxiosGet.mockResolvedValue({
+                status: 304,
+                data: null,
+                headers: {},
+            });
+
+            await updateLatestEcosystemSchema();
+
+            const afterContent = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+            expect(afterContent).toBe(originalContent);
+        });
+
+        test('writes bundled schema and throws when fetch fails with no cache', async () => {
+            mockAxiosGet.mockRejectedValue(new Error('Network error'));
+
+            expect(await FsProvider.instance.exists(latestSchemaFilePath)).toBe(false);
+            await expect(updateLatestEcosystemSchema()).rejects.toThrow();
+            expect(await FsProvider.instance.exists(latestSchemaFilePath)).toBe(true);
+
+            const content = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+            const parsed: VersionedThunderstoreEcosystem = JSON.parse(content);
+            expect(parsed.schemaVersion).not.toBe('');
+            expect(EcosystemSupportedGames.value.length).toBeGreaterThan(0);
+        });
+
+        test('keeps existing cache and throws when fetch fails with existing cache', async () => {
+            await writeCacheFile({});
+            const originalContent = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+
+            mockAxiosGet.mockRejectedValue(new Error('Network error'));
+
+            await expect(updateLatestEcosystemSchema()).rejects.toThrow();
+
+            const afterContent = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+            expect(afterContent).toBe(originalContent);
+        });
+
+        test('merges fetched data with bundled schema', async () => {
+            mockAxiosGet.mockResolvedValue({
+                status: 200,
+                data: {
+                    ...createMinimalSchema(),
+                    communities: {
+                        'test-added': {
+                            displayName: 'Added Community',
+                            categories: {},
+                            sections: {'default': {name: 'Default'}},
+                        },
+                    },
+                },
+                headers: {},
+            });
+
+            await updateLatestEcosystemSchema();
+
+            const content = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+            const parsed: VersionedThunderstoreEcosystem = JSON.parse(content);
+            expect(parsed.communities['test-added']).toBeDefined();
+            // Bundled games are preserved through the merge
+            expect(EcosystemSupportedGames.value.length).toBeGreaterThan(0);
+        });
+
+        test('deduplicates modloader packages during merge', async () => {
+            mockAxiosGet.mockResolvedValue({
+                status: 200,
+                data: {
+                    ...createMinimalSchema(),
+                    modloaderPackages: [
+                        {packageId: 'test-unique-loader', rootFolder: 'test', loader: 'bepinex'},
+                        {packageId: 'test-unique-loader', rootFolder: 'test-updated', loader: 'bepinex'},
+                    ],
+                },
+                headers: {},
+            });
+
+            await updateLatestEcosystemSchema();
+
+            const content = (await FsProvider.instance.readFile(latestSchemaFilePath)).toString('utf8');
+            const parsed: VersionedThunderstoreEcosystem = JSON.parse(content);
+            const testLoaders = parsed.modloaderPackages.filter(
+                (p: any) => p.packageId === 'test-unique-loader'
+            );
+            expect(testLoaders).toHaveLength(1);
+            expect(testLoaders[0]!.rootFolder).toBe('test-updated');
+        });
+
     });
 
 });
diff --git a/test/vitest/tests/unit/GameImageProvider/GameImageProvider.spec.ts b/test/vitest/tests/unit/GameImageProvider/GameImageProvider.spec.ts
new file mode 100644
index 000000000..28a420623
--- /dev/null
+++ b/test/vitest/tests/unit/GameImageProvider/GameImageProvider.spec.ts
@@ -0,0 +1,251 @@
+/**
+ * Targeted vitest spec for GameImageProviderImpl.
+ *
+ * Covers every branch of resolve() and placeholderUrl:
+ *   - placeholder return paths (empty / no cache / CDN tripped / 404)
+ *   - bundled-URL fast path
+ *   - local-dev proxy fast path (only valid in dev mode)
+ *   - disk-cache hit returns data: URL
+ *   - CDN fetch + cache + return data: URL
+ *   - CDN failure accumulation -> breaker trips after threshold
+ *   - CDN 404 does NOT count as failure
+ *
+ * Mocks the provider singletons rather than using the real implementations.
+ */
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+
+import nodePath from 'path';
+
+import FsProvider from '../../../../../src/providers/generic/file/FsProvider';
+import InMemoryFsProvider from '../../../stubs/providers/InMemory.FsProvider';
+import LoggerProvider from '../../../../../src/providers/ror2/logging/LoggerProvider';
+import StubLoggerProvider from '../../../stubs/providers/stub.LoggerProvider';
+import PathResolver from '../../../../../src/r2mm/manager/PathResolver';
+import { providePathImplementation } from '../../../../../src/providers/node/path/path';
+import { TestPathProvider } from '../../../stubs/providers/node/Node.Path.Provider';
+import { provideProtocolImplementation } from '../../../../../src/providers/generic/protocol/ProtocolProvider';
+import { provideBufferImplementation } from '../../../../../src/providers/node/buffer/buffer';
+
+// Stub the CdnProvider statics - replaceCdnHost is a pass-through for tests.
+vi.mock('../../../../../src/providers/generic/connection/CdnProvider', () => ({
+    default: {
+        replaceCdnHost: (url: string) => url,
+    },
+}));
+
+// Buffer stub - tests don't read the bytes after passing them to writeFile.
+const fakeBufferImpl = {
+    from: (data: any, encoding?: 'utf8' | 'base64') => {
+        if (data instanceof ArrayBuffer) return Buffer.from(data);
+        return Buffer.from(data, encoding);
+    },
+};
+
+const fakeProtocolImpl = {
+    getPublicAssetUrl: (relPath: string) => `app://./${relPath.replace(/^\//, '')}`,
+};
+
+// Import AFTER mocks are set up.
+import { GameImageProviderImplementation } from '../../../../../src/r2mm/image/GameImageProviderImpl';
+
+const PLACEHOLDER_URL = 'app://./images/game_selection/placeholder.webp';
+const TEST_APPDATA = 'TEST_APPDATA';
+const CACHE_ROOT = nodePath.join(TEST_APPDATA, 'image-cache');
+
+function cachePathFor(iconUrl: string): string {
+    return nodePath.join(CACHE_ROOT, ...iconUrl.split('/'));
+}
+
+function makeFetchResponse(body: ArrayBuffer | string, status = 200, statusText = 'OK'): Response {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        statusText,
+        async arrayBuffer() { return typeof body === 'string' ? new TextEncoder().encode(body).buffer : body; },
+    } as unknown as Response;
+}
+
+describe('GameImageProviderImpl', () => {
+    let mockFetch: ReturnType<typeof vi.fn>;
+
+    beforeEach(async () => {
+        providePathImplementation(() => TestPathProvider);
+        InMemoryFsProvider.clear();
+        FsProvider.provide(() => new InMemoryFsProvider());
+        const loggerImpl = new StubLoggerProvider();
+        LoggerProvider.provide(() => loggerImpl);
+        vi.spyOn(loggerImpl, 'Log').mockImplementation(() => {});
+        provideProtocolImplementation(() => fakeProtocolImpl);
+        provideBufferImplementation(() => fakeBufferImpl);
+
+        PathResolver.APPDATA_DIR = TEST_APPDATA;
+
+        // Reset breaker state on the singleton (privates set via any-cast).
+        const inst: any = GameImageProviderImplementation;
+        inst.cacheRoot = undefined;
+        inst.cdnConsecutiveFailures = 0;
+        inst.cdnBreakerTripped = false;
+
+        mockFetch = vi.fn();
+        vi.stubGlobal('fetch', mockFetch);
+    });
+
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+
+    describe('placeholderUrl', () => {
+        test('returns the bundled placeholder URL', () => {
+            expect(GameImageProviderImplementation.placeholderUrl).toBe(PLACEHOLDER_URL);
+        });
+    });
+
+    describe('init()', () => {
+        test('creates the image-cache directory under APPDATA_DIR', async () => {
+            expect(await FsProvider.instance.exists(CACHE_ROOT)).toBe(false);
+            await GameImageProviderImplementation.init();
+            expect(await FsProvider.instance.exists(CACHE_ROOT)).toBe(true);
+        });
+
+        test('does nothing when APPDATA_DIR is unset', async () => {
+            PathResolver.APPDATA_DIR = '' as any;
+            await GameImageProviderImplementation.init();
+            expect(await FsProvider.instance.exists(CACHE_ROOT)).toBe(false);
+        });
+    });
+
+    describe('resolve()', () => {
+        test('returns placeholder for empty iconUrl without fetching', async () => {
+            const result = await GameImageProviderImplementation.resolve('');
+            expect(result).toBe(PLACEHOLDER_URL);
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
+
+        test('returns bundled URL when bundled asset is reachable', async () => {
+            await GameImageProviderImplementation.init();
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('OK'));
+
+            const result = await GameImageProviderImplementation.resolve('test-game/test-game-cover-360x480.webp');
+            expect(result).toBe('app://./images/game_selection/test-game/test-game-cover-360x480.webp');
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+
+        test('returns disk-cached data URL when bundled is unreachable but cache exists', async () => {
+            await GameImageProviderImplementation.init();
+            // Pre-seed cache.
+            const cachePath = cachePathFor('test-game/test-game-cover-360x480.webp');
+            await FsProvider.instance.mkdirs(nodePath.dirname(cachePath));
+            await FsProvider.instance.writeFile(cachePath, Buffer.from('fake-cached-bytes'));
+
+            // bundled URL fetch fails; local-dev (only in dev) also misses; cache hit short-circuits before CDN.
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404));
+
+            const result = await GameImageProviderImplementation.resolve('test-game/test-game-cover-360x480.webp');
+            expect(result.startsWith('data:image/webp;base64,')).toBe(true);
+            // Cache hit means at most one fetch (the bundled check) — CDN was NOT called.
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+
+        test('fetches from CDN, caches, and returns data URL on first cache miss', async () => {
+            await GameImageProviderImplementation.init();
+            const cdnBody = new Uint8Array([0x52, 0x49, 0x46, 0x46]).buffer; // "RIFF"
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // bundled miss
+            mockFetch.mockResolvedValueOnce(makeFetchResponse(cdnBody, 200)); // CDN hit
+
+            const iconUrl = 'fresh-game/fresh-game-cover-360x480.webp';
+            const result = await GameImageProviderImplementation.resolve(iconUrl);
+
+            expect(result.startsWith('data:image/webp;base64,')).toBe(true);
+            // Should now exist in cache.
+            expect(await FsProvider.instance.exists(cachePathFor('fresh-game/fresh-game-cover-360x480.webp'))).toBe(true);
+        });
+
+        test('CDN 404 returns placeholder and does NOT increment failure counter', async () => {
+            await GameImageProviderImplementation.init();
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // bundled miss
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // CDN 404
+
+            const result = await GameImageProviderImplementation.resolve('missing-game/missing-game-cover-360x480.webp');
+            expect(result).toBe(PLACEHOLDER_URL);
+            expect((GameImageProviderImplementation as any).cdnConsecutiveFailures ?? 0).toBe(0);
+            expect((GameImageProviderImplementation as any).cdnBreakerTripped).toBe(false);
+        });
+
+        test('CDN 403 returns placeholder and does NOT increment failure counter', async () => {
+            await GameImageProviderImplementation.init();
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404));
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 403));
+
+            const result = await GameImageProviderImplementation.resolve('missing-game/missing-game-cover-360x480.webp');
+            expect(result).toBe(PLACEHOLDER_URL);
+            expect((GameImageProviderImplementation as any).cdnConsecutiveFailures ?? 0).toBe(0);
+            expect((GameImageProviderImplementation as any).cdnBreakerTripped).toBe(false);
+        });
+
+        test.each([
+            '../../etc/passwd.webp',
+            '/etc/passwd.webp',
+            'game\\..\\..\\secret.webp',
+        ])('rejects path-traversal iconUrl %s and falls back to placeholder', async (iconUrl) => {
+            await GameImageProviderImplementation.init();
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404));
+
+            const result = await GameImageProviderImplementation.resolve(iconUrl);
+            expect(result).toBe(PLACEHOLDER_URL);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+
+        test('CDN non-404 errors accumulate; breaker trips at threshold (3)', async () => {
+            await GameImageProviderImplementation.init();
+            // Six fetches for three resolves: 3x (bundled-miss + CDN-error).
+            for (let i = 0; i < 3; i++) {
+                mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // bundled
+                mockFetch.mockResolvedValueOnce(makeFetchResponse('', 500, 'ISE')); // CDN
+            }
+
+            for (let i = 0; i < 3; i++) {
+                const result = await GameImageProviderImplementation.resolve(`g${i}/g${i}-cover-360x480.webp`);
+                expect(result).toBe(PLACEHOLDER_URL);
+            }
+            expect((GameImageProviderImplementation as any).cdnBreakerTripped).toBe(true);
+
+            // 4th resolve should NOT invoke CDN at all — bundled miss then placeholder.
+            const fetchCallsBefore = mockFetch.mock.calls.length;
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // only the bundled check
+            const result = await GameImageProviderImplementation.resolve('g3/g3-cover-360x480.webp');
+            expect(result).toBe(PLACEHOLDER_URL);
+            expect(mockFetch.mock.calls.length - fetchCallsBefore).toBe(1); // only bundled probe, NO CDN
+        });
+
+        test('successful CDN response after failures resets the failure counter', async () => {
+            await GameImageProviderImplementation.init();
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // bundled miss
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 500, 'ISE')); // CDN err -> counter=1
+            await GameImageProviderImplementation.resolve('g0/g0-cover-360x480.webp');
+            expect((GameImageProviderImplementation as any).cdnConsecutiveFailures).toBe(1);
+
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // bundled miss
+            mockFetch.mockResolvedValueOnce(makeFetchResponse(new Uint8Array([1,2,3]).buffer, 200)); // CDN ok
+            await GameImageProviderImplementation.resolve('g1/g1-cover-360x480.webp');
+            expect((GameImageProviderImplementation as any).cdnConsecutiveFailures).toBe(0);
+        });
+
+        test('fetch throw on CDN counts as failure', async () => {
+            await GameImageProviderImplementation.init();
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // bundled
+            mockFetch.mockRejectedValueOnce(new Error('AbortError'));      // CDN throws
+            const result = await GameImageProviderImplementation.resolve('g/g-cover-360x480.webp');
+            expect(result).toBe(PLACEHOLDER_URL);
+            expect((GameImageProviderImplementation as any).cdnConsecutiveFailures).toBe(1);
+        });
+
+        test('without init() (no cacheRoot), still falls back to placeholder without crashing', async () => {
+            // Intentionally skip init().
+            mockFetch.mockResolvedValueOnce(makeFetchResponse('', 404)); // bundled miss
+            // resolve should NOT try CDN (no cachePath), should return placeholder.
+            const result = await GameImageProviderImplementation.resolve('foo/foo-cover-360x480.webp');
+            expect(result).toBe(PLACEHOLDER_URL);
+        });
+    });
+});