test

fix: custom assets not being showed in library page

.github/workflows/build.yml

@@ -2,6 +2,9 @@ name: Build
 
 on:
   pull_request:
+  push:
+    branches:
+      - main
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

src/locales/en/translation.json

@@ -197,6 +197,7 @@
     "download_in_progress": "Download in progress",
     "download_paused": "Download paused",
     "last_downloaded_option": "Last downloaded option",
+    "new_download_option": "New",
     "create_steam_shortcut": "Create Steam shortcut",
     "create_shortcut_success": "Shortcut created successfully",
     "you_might_need_to_restart_steam": "You might need to restart Steam to see the changes",
@@ -558,6 +559,15 @@
     "platinum": "Platinum",
     "hidden": "Hidden",
     "test_notification": "Test notification",
+    "achievement_sound_volume": "Achievement sound volume",
+    "select_achievement_sound": "Select achievement sound",
+    "change_achievement_sound": "Change achievement sound",
+    "remove_achievement_sound": "Remove achievement sound",
+    "preview_sound": "Preview sound",
+    "select": "Select",
+    "preview": "Preview",
+    "remove": "Remove",
+    "no_sound_file_selected": "No sound file selected",
     "notification_preview": "Achievement Notification Preview",
     "enable_friend_start_game_notifications": "When a friend starts playing a game",
     "autoplay_trailers_on_game_page": "Automatically start playing trailers on game page",

src/locales/es/translation.json

@@ -193,6 +193,7 @@
     "download_in_progress": "Descarga en progreso",
     "download_paused": "Descarga pausada",
     "last_downloaded_option": "Última opción de descarga",
+    "new_download_option": "Nuevo",
     "create_steam_shortcut": "Crear atajo de Steam",
     "create_shortcut_success": "Atajo creado con éxito",
     "you_might_need_to_restart_steam": "Probablemente necesités reiniciar Steam para ver cambios",
@@ -543,6 +544,12 @@
     "platinum": "Platino",
     "hidden": "Oculto",
     "test_notification": "Probar notificación",
+    "achievement_sound_volume": "Volumen del sonido de logro",
+    "select_achievement_sound": "Seleccionar sonido de logro",
+    "select": "Seleccionar",
+    "preview": "Vista previa",
+    "remove": "Remover",
+    "no_sound_file_selected": "No se seleccionó ningún archivo de sonido",
     "notification_preview": "Probar notificación de logro",
     "debrid": "Debrid",
     "debrid_description": "Los servicios Debrid son descargadores premium sin restricciones que te dejan descargar más rápido archivos alojados en servicios de alojamiento siendo que la única limitación es tu velocidad de internet.",

src/locales/pt-BR/translation.json

@@ -183,6 +183,7 @@
     "download_in_progress": "Download em andamento",
     "download_paused": "Download pausado",
     "last_downloaded_option": "Última opção baixada",
+    "new_download_option": "Novo",
     "create_steam_shortcut": "Criar atalho na Steam",
     "create_shortcut_success": "Atalho criado com sucesso",
     "you_might_need_to_restart_steam": "Você pode precisar reiniciar a Steam para ver as alterações",
@@ -542,6 +543,12 @@
     "platinum": "Platina",
     "hidden": "Oculta",
     "test_notification": "Testar notificação",
+    "achievement_sound_volume": "Volume do som de conquista",
+    "select_achievement_sound": "Selecionar som de conquista",
+    "select": "Selecionar",
+    "preview": "Reproduzir",
+    "remove": "Remover",
+    "no_sound_file_selected": "Nenhum arquivo de som selecionado",
     "notification_preview": "Prévia da Notificação de Conquistas",
     "enable_friend_start_game_notifications": "Quando um amigo iniciar um jogo",
     "autoplay_trailers_on_game_page": "Reproduzir trailers automaticamente na página do jogo",

src/locales/ru/translation.json

@@ -195,6 +195,7 @@
     "download_in_progress": "Идёт загрузка",
     "download_paused": "Загрузка приостановлена",
     "last_downloaded_option": "Последний вариант загрузки",
+    "new_download_option": "Новый",
     "create_steam_shortcut": "Создать ярлык Steam",
     "create_shortcut_success": "Ярлык создан",
     "you_might_need_to_restart_steam": "Возможно, вам потребуется перезапустить Steam, чтобы увидеть изменения",
@@ -556,6 +557,12 @@
     "platinum": "Платиновый",
     "hidden": "Скрытый",
     "test_notification": "Тестовое уведомление",
+    "achievement_sound_volume": "Громкость звука достижения",
+    "select_achievement_sound": "Выбрать звук достижения",
+    "select": "Выбрать",
+    "preview": "Предпросмотр",
+    "remove": "Удалить",
+    "no_sound_file_selected": "Файл звука не выбран",
     "notification_preview": "Предварительный просмотр уведомления о достижении",
     "enable_friend_start_game_notifications": "Когда друг начинает играть в игру",
     "autoplay_trailers_on_game_page": "Автоматически начинать воспроизведение трейлеров на странице игры",

src/main/constants.ts

@@ -41,8 +41,12 @@ export const appVersion = app.getVersion() + (isStaging ? "-staging" : "");
 
 export const ASSETS_PATH = path.join(SystemPath.getPath("userData"), "Assets");
 
+export const THEMES_PATH = path.join(SystemPath.getPath("userData"), "themes");
+
 export const MAIN_LOOP_INTERVAL = 2000;
 
+export const DEFAULT_ACHIEVEMENT_SOUND_VOLUME = 0.15;
+
 export const DECKY_PLUGINS_LOCATION = path.join(
   SystemPath.getPath("home"),
   "homebrew",

src/main/events/download-sources/get-download-sources-check-baseline.ts

@@ -0,0 +1,13 @@
+import { getDownloadSourcesCheckBaseline } from "@main/level";
+import { registerEvent } from "../register-event";
+
+const getDownloadSourcesCheckBaselineHandler = async (
+  _event: Electron.IpcMainInvokeEvent
+) => {
+  return await getDownloadSourcesCheckBaseline();
+};
+
+registerEvent(
+  "getDownloadSourcesCheckBaseline",
+  getDownloadSourcesCheckBaselineHandler
+);

src/main/events/download-sources/get-download-sources-since-value.ts

@@ -0,0 +1,13 @@
+import { getDownloadSourcesSinceValue } from "@main/level";
+import { registerEvent } from "../register-event";
+
+const getDownloadSourcesSinceValueHandler = async (
+  _event: Electron.IpcMainInvokeEvent
+) => {
+  return await getDownloadSourcesSinceValue();
+};
+
+registerEvent(
+  "getDownloadSourcesSinceValue",
+  getDownloadSourcesSinceValueHandler
+);

src/main/events/index.ts

@@ -20,6 +20,7 @@ import "./library/get-game-by-object-id";
 import "./library/get-library";
 import "./library/refresh-library-assets";
 import "./library/extract-game-download";
+import "./library/clear-new-download-options";
 import "./library/open-game";
 import "./library/open-game-executable-path";
 import "./library/open-game-installer";
@@ -65,6 +66,8 @@ import "./user-preferences/authenticate-real-debrid";
 import "./user-preferences/authenticate-torbox";
 import "./download-sources/add-download-source";
 import "./download-sources/sync-download-sources";
+import "./download-sources/get-download-sources-check-baseline";
+import "./download-sources/get-download-sources-since-value";
 import "./auth/sign-out";
 import "./auth/open-auth-window";
 import "./auth/get-session-hash";
@@ -92,6 +95,11 @@ import "./themes/get-custom-theme-by-id";
 import "./themes/get-active-custom-theme";
 import "./themes/close-editor-window";
 import "./themes/toggle-custom-theme";
+import "./themes/copy-theme-achievement-sound";
+import "./themes/remove-theme-achievement-sound";
+import "./themes/get-theme-sound-path";
+import "./themes/get-theme-sound-data-url";
+import "./themes/import-theme-sound-from-store";
 import "./download-sources/remove-download-source";
 import "./download-sources/get-download-sources";
 import { isPortableVersion } from "@main/helpers";

src/main/events/library/clear-new-download-options.ts

@@ -0,0 +1,27 @@
+import { registerEvent } from "../register-event";
+import { gamesSublevel, levelKeys } from "@main/level";
+import { logger } from "@main/services";
+import type { GameShop } from "@types";
+
+const clearNewDownloadOptions = async (
+  _event: Electron.IpcMainInvokeEvent,
+  shop: GameShop,
+  objectId: string
+) => {
+  const gameKey = levelKeys.game(shop, objectId);
+
+  const game = await gamesSublevel.get(gameKey);
+  if (!game) return;
+
+  try {
+    await gamesSublevel.put(gameKey, {
+      ...game,
+      newDownloadOptionsCount: undefined,
+    });
+    logger.info(`Cleared newDownloadOptionsCount for game ${gameKey}`);
+  } catch (error) {
+    logger.error(`Failed to clear newDownloadOptionsCount: ${error}`);
+  }
+};
+
+registerEvent("clearNewDownloadOptions", clearNewDownloadOptions);

src/main/events/library/get-library.ts

@@ -4,7 +4,6 @@ import {
   downloadsSublevel,
   gamesShopAssetsSublevel,
   gamesSublevel,
-  gameAchievementsSublevel,
 } from "@main/level";
 
 const getLibrary = async (): Promise<LibraryGame[]> => {
@@ -19,33 +18,19 @@ const getLibrary = async (): Promise<LibraryGame[]> => {
             const download = await downloadsSublevel.get(key);
             const gameAssets = await gamesShopAssetsSublevel.get(key);
 
-            let unlockedAchievementCount = 0;
-            let achievementCount = 0;
-
-            try {
-              const achievements = await gameAchievementsSublevel.get(key);
-              if (achievements) {
-                achievementCount = achievements.achievements.length;
-                unlockedAchievementCount =
-                  achievements.unlockedAchievements.length;
-              }
-            } catch {
-              // No achievements data for this game
-            }
-
             return {
               id: key,
               ...game,
               download: download ?? null,
-              unlockedAchievementCount,
-              achievementCount,
+              unlockedAchievementCount: game.unlockedAchievementCount ?? 0,
+              achievementCount: game.achievementCount ?? 0,
               // Spread gameAssets last to ensure all image URLs are properly set
               ...gameAssets,
               // Preserve custom image URLs from game if they exist
               customIconUrl: game.customIconUrl,
               customLogoImageUrl: game.customLogoImageUrl,
               customHeroImageUrl: game.customHeroImageUrl,
-            } as LibraryGame;
+            };
           })
       );
     });

src/main/events/themes/copy-theme-achievement-sound.ts

@@ -0,0 +1,40 @@
+import { registerEvent } from "../register-event";
+import fs from "node:fs";
+import path from "node:path";
+import { getThemePath } from "@main/helpers";
+import { themesSublevel } from "@main/level";
+
+const copyThemeAchievementSound = async (
+  _event: Electron.IpcMainInvokeEvent,
+  themeId: string,
+  sourcePath: string
+): Promise<void> => {
+  if (!sourcePath || !fs.existsSync(sourcePath)) {
+    throw new Error("Source file does not exist");
+  }
+
+  const theme = await themesSublevel.get(themeId);
+  if (!theme) {
+    throw new Error("Theme not found");
+  }
+
+  const themeDir = getThemePath(themeId, theme.name);
+
+  if (!fs.existsSync(themeDir)) {
+    fs.mkdirSync(themeDir, { recursive: true });
+  }
+
+  const fileExtension = path.extname(sourcePath);
+  const destinationPath = path.join(themeDir, `achievement${fileExtension}`);
+
+  await fs.promises.copyFile(sourcePath, destinationPath);
+
+  await themesSublevel.put(themeId, {
+    ...theme,
+    hasCustomSound: true,
+    originalSoundPath: sourcePath,
+    updatedAt: new Date(),
+  });
+};
+
+registerEvent("copyThemeAchievementSound", copyThemeAchievementSound);

src/main/events/themes/get-theme-sound-data-url.ts

@@ -0,0 +1,40 @@
+import { registerEvent } from "../register-event";
+import { getThemeSoundPath } from "@main/helpers";
+import { themesSublevel } from "@main/level";
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "@main/services";
+
+const getThemeSoundDataUrl = async (
+  _event: Electron.IpcMainInvokeEvent,
+  themeId: string
+): Promise<string | null> => {
+  try {
+    const theme = await themesSublevel.get(themeId);
+    const soundPath = getThemeSoundPath(themeId, theme?.name);
+
+    if (!soundPath || !fs.existsSync(soundPath)) {
+      return null;
+    }
+
+    const buffer = await fs.promises.readFile(soundPath);
+    const ext = path.extname(soundPath).toLowerCase().slice(1);
+
+    const mimeTypes: Record<string, string> = {
+      mp3: "audio/mpeg",
+      wav: "audio/wav",
+      ogg: "audio/ogg",
+      m4a: "audio/mp4",
+    };
+
+    const mimeType = mimeTypes[ext] || "audio/mpeg";
+    const base64 = buffer.toString("base64");
+
+    return `data:${mimeType};base64,${base64}`;
+  } catch (error) {
+    logger.error("Failed to get theme sound data URL", error);
+    return null;
+  }
+};
+
+registerEvent("getThemeSoundDataUrl", getThemeSoundDataUrl);

src/main/events/themes/get-theme-sound-path.ts

@@ -0,0 +1,13 @@
+import { registerEvent } from "../register-event";
+import { getThemeSoundPath } from "@main/helpers";
+import { themesSublevel } from "@main/level";
+
+const getThemeSoundPathEvent = async (
+  _event: Electron.IpcMainInvokeEvent,
+  themeId: string
+): Promise<string | null> => {
+  const theme = await themesSublevel.get(themeId);
+  return getThemeSoundPath(themeId, theme?.name);
+};
+
+registerEvent("getThemeSoundPath", getThemeSoundPathEvent);

src/main/events/themes/import-theme-sound-from-store.ts

@@ -0,0 +1,60 @@
+import { registerEvent } from "../register-event";
+import fs from "node:fs";
+import path from "node:path";
+import axios from "axios";
+import { getThemePath } from "@main/helpers";
+import { themesSublevel } from "@main/level";
+import { logger } from "@main/services";
+
+const importThemeSoundFromStore = async (
+  _event: Electron.IpcMainInvokeEvent,
+  themeId: string,
+  themeName: string,
+  storeUrl: string
+): Promise<void> => {
+  const theme = await themesSublevel.get(themeId);
+  if (!theme) {
+    throw new Error("Theme not found");
+  }
+
+  const formats = ["wav", "mp3", "ogg", "m4a"];
+
+  for (const format of formats) {
+    try {
+      const soundUrl = `${storeUrl}/themes/${themeName.toLowerCase()}/achievement.${format}`;
+
+      const response = await axios.get(soundUrl, {
+        responseType: "arraybuffer",
+        timeout: 10000,
+      });
+
+      const themeDir = getThemePath(themeId, theme.name);
+
+      if (!fs.existsSync(themeDir)) {
+        fs.mkdirSync(themeDir, { recursive: true });
+      }
+
+      const destinationPath = path.join(themeDir, `achievement.${format}`);
+      await fs.promises.writeFile(destinationPath, response.data);
+
+      await themesSublevel.put(themeId, {
+        ...theme,
+        hasCustomSound: true,
+        updatedAt: new Date(),
+      });
+
+      logger.log(`Successfully imported sound for theme ${themeName}`);
+      return;
+    } catch (error) {
+      logger.error(
+        `Failed to import ${format} sound for theme ${themeName}`,
+        error
+      );
+      continue;
+    }
+  }
+
+  logger.log(`No sound file found for theme ${themeName} in store`);
+};
+
+registerEvent("importThemeSoundFromStore", importThemeSoundFromStore);

src/main/events/themes/remove-theme-achievement-sound.ts

@@ -0,0 +1,48 @@
+import { registerEvent } from "../register-event";
+import fs from "node:fs";
+import { getThemePath } from "@main/helpers";
+import { themesSublevel } from "@main/level";
+import { THEMES_PATH } from "@main/constants";
+import path from "node:path";
+
+const removeThemeAchievementSound = async (
+  _event: Electron.IpcMainInvokeEvent,
+  themeId: string
+): Promise<void> => {
+  const theme = await themesSublevel.get(themeId);
+  if (!theme) {
+    throw new Error("Theme not found");
+  }
+
+  const themeDir = getThemePath(themeId, theme.name);
+  const legacyThemeDir = path.join(THEMES_PATH, themeId);
+
+  const removeFromDir = async (dir: string) => {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+
+    const formats = ["wav", "mp3", "ogg", "m4a"];
+
+    for (const format of formats) {
+      const soundPath = path.join(dir, `achievement.${format}`);
+      if (fs.existsSync(soundPath)) {
+        await fs.promises.unlink(soundPath);
+      }
+    }
+  };
+
+  await removeFromDir(themeDir);
+  if (themeDir !== legacyThemeDir) {
+    await removeFromDir(legacyThemeDir);
+  }
+
+  await themesSublevel.put(themeId, {
+    ...theme,
+    hasCustomSound: false,
+    originalSoundPath: undefined,
+    updatedAt: new Date(),
+  });
+};
+
+registerEvent("removeThemeAchievementSound", removeThemeAchievementSound);

src/main/helpers/index.ts

@@ -2,6 +2,8 @@ import axios from "axios";
 import { JSDOM } from "jsdom";
 import UserAgent from "user-agents";
 import path from "node:path";
+import fs from "node:fs";
+import { THEMES_PATH } from "@main/constants";
 
 export const getFileBuffer = async (url: string) =>
   fetch(url, { method: "GET" }).then((response) =>
@@ -31,9 +33,64 @@ export const isPortableVersion = () => {
 };
 
 export const normalizePath = (str: string) =>
-  path.posix.normalize(str).replace(/\\/g, "/");
+  path.posix.normalize(str).replaceAll("\\", "/");
 
 export const addTrailingSlash = (str: string) =>
   str.endsWith("/") ? str : `${str}/`;
 
+const sanitizeFolderName = (name: string): string => {
+  return name
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9-_\s]/g, "")
+    .replaceAll(/\s+/g, "-")
+    .replaceAll(/-+/g, "-")
+    .replaceAll(/(^-|-$)/g, "");
+};
+
+export const getThemePath = (themeId: string, themeName?: string): string => {
+  if (themeName) {
+    const sanitizedName = sanitizeFolderName(themeName);
+    if (sanitizedName) {
+      return path.join(THEMES_PATH, sanitizedName);
+    }
+  }
+  return path.join(THEMES_PATH, themeId);
+};
+
+export const getThemeSoundPath = (
+  themeId: string,
+  themeName?: string
+): string | null => {
+  const themeDir = getThemePath(themeId, themeName);
+  const legacyThemeDir = themeName ? path.join(THEMES_PATH, themeId) : null;
+
+  const checkDir = (dir: string): string | null => {
+    if (!fs.existsSync(dir)) {
+      return null;
+    }
+
+    const formats = ["wav", "mp3", "ogg", "m4a"];
+
+    for (const format of formats) {
+      const soundPath = path.join(dir, `achievement.${format}`);
+      if (fs.existsSync(soundPath)) {
+        return soundPath;
+      }
+    }
+
+    return null;
+  };
+
+  const soundPath = checkDir(themeDir);
+  if (soundPath) {
+    return soundPath;
+  }
+
+  if (legacyThemeDir) {
+    return checkDir(legacyThemeDir);
+  }
+
+  return null;
+};
+
 export * from "./reg-parser";

src/main/level/sublevels/downloadSourcesCheckTimestamp.ts

@@ -0,0 +1,59 @@
+import { levelKeys } from "./keys";
+import { db } from "../level";
+import { logger } from "@main/services";
+
+// Gets when we last started the app (for next API call's 'since')
+export const getDownloadSourcesCheckBaseline = async (): Promise<
+  string | null
+> => {
+  try {
+    const timestamp = await db.get(levelKeys.downloadSourcesCheckBaseline);
+    return timestamp;
+  } catch (error) {
+    if (error instanceof Error && error.name === "NotFoundError") {
+      logger.debug("Download sources check baseline not found, returning null");
+    } else {
+      logger.error(
+        "Unexpected error while getting download sources check baseline",
+        error
+      );
+    }
+    return null;
+  }
+};
+
+// Updates to current time (when app starts)
+export const updateDownloadSourcesCheckBaseline = async (
+  timestamp: string
+): Promise<void> => {
+  const utcTimestamp = new Date(timestamp).toISOString();
+  await db.put(levelKeys.downloadSourcesCheckBaseline, utcTimestamp);
+};
+
+// Gets the 'since' value the API used in the last check (for modal comparison)
+export const getDownloadSourcesSinceValue = async (): Promise<
+  string | null
+> => {
+  try {
+    const timestamp = await db.get(levelKeys.downloadSourcesSinceValue);
+    return timestamp;
+  } catch (error) {
+    if (error instanceof Error && error.name === "NotFoundError") {
+      logger.debug("Download sources since value not found, returning null");
+    } else {
+      logger.error(
+        "Unexpected error while getting download sources since value",
+        error
+      );
+    }
+    return null;
+  }
+};
+
+// Saves the 'since' value we used in the API call (for modal to compare against)
+export const updateDownloadSourcesSinceValue = async (
+  timestamp: string
+): Promise<void> => {
+  const utcTimestamp = new Date(timestamp).toISOString();
+  await db.put(levelKeys.downloadSourcesSinceValue, utcTimestamp);
+};

src/main/level/sublevels/index.ts

@@ -7,3 +7,4 @@ export * from "./game-achievements";
 export * from "./keys";
 export * from "./themes";
 export * from "./download-sources";
+export * from "./downloadSourcesCheckTimestamp";

src/main/level/sublevels/keys.ts

@@ -18,4 +18,6 @@ export const levelKeys = {
   screenState: "screenState",
   rpcPassword: "rpcPassword",
   downloadSources: "downloadSources",
+  downloadSourcesCheckBaseline: "downloadSourcesCheckBaseline", // When we last started the app
+  downloadSourcesSinceValue: "downloadSourcesSinceValue", // The 'since' value API used (for modal comparison)
 };

src/main/main.ts

@@ -16,6 +16,7 @@ import {
   Ludusavi,
   Lock,
   DeckyPlugin,
+  DownloadSourcesChecker,
   WSClient,
 } from "@main/services";
 import { migrateDownloadSources } from "./helpers/migrate-download-sources";
@@ -57,6 +58,9 @@ export const loadState = async () => {
 
     const { syncDownloadSourcesFromApi } = await import("./services/user");
     void syncDownloadSourcesFromApi();
+
+    // Check for new download options on startup
+    DownloadSourcesChecker.checkForChanges();
     WSClient.connect();
   });
 

src/main/services/download-sources-checker.ts

@@ -0,0 +1,188 @@
+import { HydraApi } from "./hydra-api";
+import {
+  gamesSublevel,
+  getDownloadSourcesCheckBaseline,
+  updateDownloadSourcesCheckBaseline,
+  updateDownloadSourcesSinceValue,
+  downloadSourcesSublevel,
+} from "@main/level";
+import { logger } from "./logger";
+import { WindowManager } from "./window-manager";
+import type { Game } from "@types";
+
+interface DownloadSourcesChangeResponse {
+  shop: string;
+  objectId: string;
+  newDownloadOptionsCount: number;
+  downloadSourceIds: string[];
+}
+
+export class DownloadSourcesChecker {
+  private static async clearStaleBadges(
+    nonCustomGames: Game[]
+  ): Promise<{ gameId: string; count: number }[]> {
+    const previouslyFlaggedGames = nonCustomGames.filter(
+      (game: Game) =>
+        game.newDownloadOptionsCount && game.newDownloadOptionsCount > 0
+    );
+
+    const clearedPayload: { gameId: string; count: number }[] = [];
+    if (previouslyFlaggedGames.length > 0) {
+      logger.info(
+        `Clearing stale newDownloadOptionsCount for ${previouslyFlaggedGames.length} games`
+      );
+      for (const game of previouslyFlaggedGames) {
+        await gamesSublevel.put(`${game.shop}:${game.objectId}`, {
+          ...game,
+          newDownloadOptionsCount: undefined,
+        });
+        clearedPayload.push({
+          gameId: `${game.shop}:${game.objectId}`,
+          count: 0,
+        });
+      }
+    }
+
+    return clearedPayload;
+  }
+
+  private static async processApiResponse(
+    response: unknown,
+    nonCustomGames: Game[]
+  ): Promise<{ gameId: string; count: number }[]> {
+    if (!response || !Array.isArray(response)) {
+      return [];
+    }
+
+    const gamesWithNewOptions: { gameId: string; count: number }[] = [];
+
+    for (const gameUpdate of response as DownloadSourcesChangeResponse[]) {
+      if (gameUpdate.newDownloadOptionsCount > 0) {
+        const game = nonCustomGames.find(
+          (g) =>
+            g.shop === gameUpdate.shop && g.objectId === gameUpdate.objectId
+        );
+
+        if (game) {
+          await gamesSublevel.put(`${game.shop}:${game.objectId}`, {
+            ...game,
+            newDownloadOptionsCount: gameUpdate.newDownloadOptionsCount,
+          });
+
+          gamesWithNewOptions.push({
+            gameId: `${game.shop}:${game.objectId}`,
+            count: gameUpdate.newDownloadOptionsCount,
+          });
+        }
+      }
+    }
+
+    return gamesWithNewOptions;
+  }
+
+  private static sendNewDownloadOptionsEvent(
+    clearedPayload: { gameId: string; count: number }[],
+    gamesWithNewOptions: { gameId: string; count: number }[]
+  ): void {
+    const eventPayload = [...clearedPayload, ...gamesWithNewOptions];
+    if (eventPayload.length > 0 && WindowManager.mainWindow) {
+      WindowManager.mainWindow.webContents.send(
+        "on-new-download-options",
+        eventPayload
+      );
+    }
+
+    logger.info(
+      `Found new download options for ${gamesWithNewOptions.length} games`
+    );
+  }
+
+  static async checkForChanges(): Promise<void> {
+    logger.info("DownloadSourcesChecker.checkForChanges() called");
+
+    try {
+      // Get all installed games (excluding custom games)
+      const installedGames = await gamesSublevel.values().all();
+      const nonCustomGames = installedGames.filter(
+        (game: Game) => game.shop !== "custom"
+      );
+      logger.info(
+        `Found ${installedGames.length} total games, ${nonCustomGames.length} non-custom games`
+      );
+
+      if (nonCustomGames.length === 0) {
+        logger.info(
+          "No non-custom games found, skipping download sources check"
+        );
+        return;
+      }
+
+      const downloadSources = await downloadSourcesSublevel.values().all();
+      const downloadSourceIds = downloadSources.map((source) => source.id);
+      logger.info(
+        `Found ${downloadSourceIds.length} download sources: ${downloadSourceIds.join(", ")}`
+      );
+
+      if (downloadSourceIds.length === 0) {
+        logger.info(
+          "No download sources found, skipping download sources check"
+        );
+        return;
+      }
+
+      const previousBaseline = await getDownloadSourcesCheckBaseline();
+      const since =
+        previousBaseline ||
+        new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+
+      logger.info(`Using since: ${since} (from last app start)`);
+
+      const clearedPayload = await this.clearStaleBadges(nonCustomGames);
+
+      const games = nonCustomGames.map((game: Game) => ({
+        shop: game.shop,
+        objectId: game.objectId,
+      }));
+
+      logger.info(
+        `Checking download sources changes for ${games.length} non-custom games since ${since}`
+      );
+      logger.info(
+        `Making API call to HydraApi.checkDownloadSourcesChanges with:`,
+        {
+          downloadSourceIds,
+          gamesCount: games.length,
+          since,
+        }
+      );
+
+      const response = await HydraApi.checkDownloadSourcesChanges(
+        downloadSourceIds,
+        games,
+        since
+      );
+
+      logger.info("API call completed, response:", response);
+
+      await updateDownloadSourcesSinceValue(since);
+      logger.info(`Saved 'since' value: ${since} (for modal comparison)`);
+
+      const now = new Date().toISOString();
+      await updateDownloadSourcesCheckBaseline(now);
+      logger.info(
+        `Updated baseline to: ${now} (will be 'since' on next app start)`
+      );
+
+      const gamesWithNewOptions = await this.processApiResponse(
+        response,
+        nonCustomGames
+      );
+
+      this.sendNewDownloadOptionsEvent(clearedPayload, gamesWithNewOptions);
+
+      logger.info("Download sources check completed successfully");
+    } catch (error) {
+      logger.error("Failed to check download sources changes:", error);
+    }
+  }
+}

src/main/services/hydra-api.ts

@@ -400,4 +400,45 @@ export class HydraApi {
       .then((response) => response.data)
       .catch(this.handleUnauthorizedError);
   }
+
+  static async checkDownloadSourcesChanges(
+    downloadSourceIds: string[],
+    games: Array<{ shop: string; objectId: string }>,
+    since: string
+  ) {
+    logger.info("HydraApi.checkDownloadSourcesChanges called with:", {
+      downloadSourceIds,
+      gamesCount: games.length,
+      since,
+      isLoggedIn: this.isLoggedIn(),
+    });
+
+    try {
+      const result = await this.post<
+        Array<{
+          shop: string;
+          objectId: string;
+          newDownloadOptionsCount: number;
+          downloadSourceIds: string[];
+        }>
+      >(
+        "/download-sources/changes",
+        {
+          downloadSourceIds,
+          games,
+          since,
+        },
+        { needsAuth: true }
+      );
+
+      logger.info(
+        "HydraApi.checkDownloadSourcesChanges completed successfully:",
+        result
+      );
+      return result;
+    } catch (error) {
+      logger.error("HydraApi.checkDownloadSourcesChanges failed:", error);
+      throw error;
+    }
+  }
 }

src/main/services/index.ts

@@ -19,3 +19,4 @@ export * from "./wine";
 export * from "./lock";
 export * from "./decky-plugin";
 export * from "./user";
+export * from "./download-sources-checker";

src/main/services/library-sync/merge-with-remote-games.ts

@@ -9,6 +9,8 @@ type ProfileGame = {
   hasManuallyUpdatedPlaytime: boolean;
   isFavorite?: boolean;
   isPinned?: boolean;
+  achievementCount: number;
+  unlockedAchievementCount: number;
 } & ShopAssets;
 
 export const mergeWithRemoteGames = async () => {
@@ -39,6 +41,8 @@ export const mergeWithRemoteGames = async () => {
             playTimeInMilliseconds: updatedPlayTime,
             favorite: game.isFavorite ?? localGame.favorite,
             isPinned: game.isPinned ?? localGame.isPinned,
+            achievementCount: game.achievementCount,
+            unlockedAchievementCount: game.unlockedAchievementCount,
           });
         } else {
           await gamesSublevel.put(gameKey, {
@@ -55,6 +59,8 @@ export const mergeWithRemoteGames = async () => {
             isDeleted: false,
             favorite: game.isFavorite ?? false,
             isPinned: game.isPinned ?? false,
+            achievementCount: game.achievementCount,
+            unlockedAchievementCount: game.unlockedAchievementCount,
           });
         }
 

src/main/services/notifications/index.ts

@@ -11,9 +11,10 @@ import { NotificationOptions, toXmlString } from "./xml";
 import { logger } from "../logger";
 import { WindowManager } from "../window-manager";
 import type { Game, UserPreferences, UserProfile } from "@types";
-import { db, levelKeys } from "@main/level";
+import { db, levelKeys, themesSublevel } from "@main/level";
 import { restartAndInstallUpdate } from "@main/events/autoupdater/restart-and-install-update";
 import { SystemPath } from "../system-path";
+import { getThemeSoundPath } from "@main/helpers";
 
 async function downloadImage(url: string | null) {
   if (!url) return undefined;
@@ -40,6 +41,27 @@ async function downloadImage(url: string | null) {
   });
 }
 
+async function getAchievementSoundPath(): Promise<string> {
+  try {
+    const allThemes = await themesSublevel.values().all();
+    const activeTheme = allThemes.find((theme) => theme.isActive);
+
+    if (activeTheme?.hasCustomSound) {
+      const themeSoundPath = getThemeSoundPath(
+        activeTheme.id,
+        activeTheme.name
+      );
+      if (themeSoundPath) {
+        return themeSoundPath;
+      }
+    }
+  } catch (error) {
+    logger.error("Failed to get theme sound path", error);
+  }
+
+  return achievementSoundPath;
+}
+
 export const publishDownloadCompleteNotification = async (game: Game) => {
   const userPreferences = await db.get<string, UserPreferences>(
     levelKeys.userPreferences,
@@ -145,7 +167,8 @@ export const publishCombinedNewAchievementNotification = async (
   if (WindowManager.mainWindow) {
     WindowManager.mainWindow.webContents.send("on-achievement-unlocked");
   } else if (process.platform !== "linux") {
-    sound.play(achievementSoundPath);
+    const soundPath = await getAchievementSoundPath();
+    sound.play(soundPath);
   }
 };
 
@@ -205,6 +228,7 @@ export const publishNewAchievementNotification = async (info: {
   if (WindowManager.mainWindow) {
     WindowManager.mainWindow.webContents.send("on-achievement-unlocked");
   } else if (process.platform !== "linux") {
-    sound.play(achievementSoundPath);
+    const soundPath = await getAchievementSoundPath();
+    sound.play(soundPath);
   }
 };

src/preload/index.ts

@@ -103,6 +103,10 @@ contextBridge.exposeInMainWorld("electron", {
     ipcRenderer.invoke("removeDownloadSource", url, removeAll),
   getDownloadSources: () => ipcRenderer.invoke("getDownloadSources"),
   syncDownloadSources: () => ipcRenderer.invoke("syncDownloadSources"),
+  getDownloadSourcesCheckBaseline: () =>
+    ipcRenderer.invoke("getDownloadSourcesCheckBaseline"),
+  getDownloadSourcesSinceValue: () =>
+    ipcRenderer.invoke("getDownloadSourcesSinceValue"),
 
   /* Library */
   toggleAutomaticCloudSync: (
@@ -179,6 +183,8 @@ contextBridge.exposeInMainWorld("electron", {
     ipcRenderer.invoke("addGameToFavorites", shop, objectId),
   removeGameFromFavorites: (shop: GameShop, objectId: string) =>
     ipcRenderer.invoke("removeGameFromFavorites", shop, objectId),
+  clearNewDownloadOptions: (shop: GameShop, objectId: string) =>
+    ipcRenderer.invoke("clearNewDownloadOptions", shop, objectId),
   toggleGamePin: (shop: GameShop, objectId: string, pinned: boolean) =>
     ipcRenderer.invoke("toggleGamePin", shop, objectId, pinned),
   updateLaunchOptions: (
@@ -571,6 +577,25 @@ contextBridge.exposeInMainWorld("electron", {
   getActiveCustomTheme: () => ipcRenderer.invoke("getActiveCustomTheme"),
   toggleCustomTheme: (themeId: string, isActive: boolean) =>
     ipcRenderer.invoke("toggleCustomTheme", themeId, isActive),
+  copyThemeAchievementSound: (themeId: string, sourcePath: string) =>
+    ipcRenderer.invoke("copyThemeAchievementSound", themeId, sourcePath),
+  removeThemeAchievementSound: (themeId: string) =>
+    ipcRenderer.invoke("removeThemeAchievementSound", themeId),
+  getThemeSoundPath: (themeId: string) =>
+    ipcRenderer.invoke("getThemeSoundPath", themeId),
+  getThemeSoundDataUrl: (themeId: string) =>
+    ipcRenderer.invoke("getThemeSoundDataUrl", themeId),
+  importThemeSoundFromStore: (
+    themeId: string,
+    themeName: string,
+    storeUrl: string
+  ) =>
+    ipcRenderer.invoke(
+      "importThemeSoundFromStore",
+      themeId,
+      themeName,
+      storeUrl
+    ),
 
   /* Editor */
   openEditorWindow: (themeId: string) =>
@@ -581,6 +606,17 @@ contextBridge.exposeInMainWorld("electron", {
     return () =>
       ipcRenderer.removeListener("on-custom-theme-updated", listener);
   },
+  onNewDownloadOptions: (
+    cb: (gamesWithNewOptions: { gameId: string; count: number }[]) => void
+  ) => {
+    const listener = (
+      _event: Electron.IpcRendererEvent,
+      gamesWithNewOptions: { gameId: string; count: number }[]
+    ) => cb(gamesWithNewOptions);
+    ipcRenderer.on("on-new-download-options", listener);
+    return () =>
+      ipcRenderer.removeListener("on-new-download-options", listener);
+  },
   closeEditorWindow: (themeId?: string) =>
     ipcRenderer.invoke("closeEditorWindow", themeId),
 });

src/renderer/src/app.tsx

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useRef } from "react";
-import achievementSound from "@renderer/assets/audio/achievement.wav";
 import { Sidebar, BottomPanel, Header, Toast } from "@renderer/components";
 
 import {
@@ -10,6 +9,7 @@ import {
   useToast,
   useUserDetails,
 } from "@renderer/hooks";
+import { useDownloadOptionsListener } from "@renderer/hooks/use-download-options-listener";
 
 import { Outlet, useLocation, useNavigate } from "react-router-dom";
 import {
@@ -25,7 +25,12 @@ import { UserFriendModal } from "./pages/shared-modals/user-friend-modal";
 import { useSubscription } from "./hooks/use-subscription";
 import { HydraCloudModal } from "./pages/shared-modals/hydra-cloud/hydra-cloud-modal";
 
-import { injectCustomCss, removeCustomCss } from "./helpers";
+import {
+  injectCustomCss,
+  removeCustomCss,
+  getAchievementSoundUrl,
+  getAchievementSoundVolume,
+} from "./helpers";
 import "./app.scss";
 
 export interface AppProps {
@@ -36,6 +41,9 @@ export function App() {
   const contentRef = useRef<HTMLDivElement>(null);
   const { updateLibrary, library } = useLibrary();
 
+  // Listen for new download options updates
+  useDownloadOptionsListener();
+
   const { t } = useTranslation("app");
 
   const { clearDownload, setLastPacket } = useDownload();
@@ -216,9 +224,11 @@ export function App() {
     return () => unsubscribe();
   }, [loadAndApplyTheme]);
 
-  const playAudio = useCallback(() => {
-    const audio = new Audio(achievementSound);
-    audio.volume = 0.2;
+  const playAudio = useCallback(async () => {
+    const soundUrl = await getAchievementSoundUrl();
+    const volume = await getAchievementSoundVolume();
+    const audio = new Audio(soundUrl);
+    audio.volume = volume;
     audio.play();
   }, []);
 

src/renderer/src/components/game-card/game-card.tsx

@@ -47,7 +47,7 @@ export function GameCard({ game, ...props }: GameCardProps) {
     >
       <div className="game-card__backdrop">
         <img
-          src={game.libraryImageUrl}
+          src={game.libraryImageUrl ?? undefined}
           alt={game.title}
           className="game-card__cover"
           loading="lazy"

src/renderer/src/components/hero/hero.tsx

@@ -50,14 +50,14 @@ export function Hero() {
       >
         <div className="hero__backdrop">
           <img
-            src={game.libraryHeroImageUrl}
+            src={game.libraryHeroImageUrl ?? undefined}
             alt={game.description ?? ""}
             className="hero__media"
           />
 
           <div className="hero__content">
             <img
-              src={game.logoImageUrl}
+              src={game.logoImageUrl ?? undefined}
               width="250px"
               alt={game.description ?? ""}
               loading="eager"

src/renderer/src/components/sidebar/sidebar-game-item.tsx

@@ -80,6 +80,12 @@ export function SidebarGameItem({
           <span className="sidebar__menu-item-button-label">
             {getGameTitle(game)}
           </span>
+
+          {(game.newDownloadOptionsCount ?? 0) > 0 && (
+            <span className="sidebar__game-badge">
+              +{game.newDownloadOptionsCount}
+            </span>
+          )}
         </button>
       </li>
 

src/renderer/src/components/sidebar/sidebar.scss

@@ -115,6 +115,19 @@
     background-size: cover;
   }
 
+  &__game-badge {
+    background-color: rgba(34, 197, 94, 0.15);
+    color: rgb(187, 247, 208);
+    font-size: 10px;
+    font-weight: 600;
+    padding: 4px 6px;
+    border-radius: 6px;
+    display: flex;
+    margin-left: auto;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    border: 1px solid rgba(34, 197, 94, 0.5);
+  }
+
   &__section-header {
     display: flex;
     justify-content: space-between;

src/renderer/src/declaration.d.ts

@@ -142,6 +142,10 @@ declare global {
       shop: GameShop,
       objectId: string
     ) => Promise<void>;
+    clearNewDownloadOptions: (
+      shop: GameShop,
+      objectId: string
+    ) => Promise<void>;
     toggleGamePin: (
       shop: GameShop,
       objectId: string,
@@ -215,6 +219,8 @@ declare global {
     ) => Promise<void>;
     getDownloadSources: () => Promise<DownloadSource[]>;
     syncDownloadSources: () => Promise<void>;
+    getDownloadSourcesCheckBaseline: () => Promise<string | null>;
+    getDownloadSourcesSinceValue: () => Promise<string | null>;
 
     /* Hardware */
     getDiskFreeSpace: (path: string) => Promise<DiskUsage>;
@@ -410,11 +416,28 @@ declare global {
     getCustomThemeById: (themeId: string) => Promise<Theme | null>;
     getActiveCustomTheme: () => Promise<Theme | null>;
     toggleCustomTheme: (themeId: string, isActive: boolean) => Promise<void>;
+    copyThemeAchievementSound: (
+      themeId: string,
+      sourcePath: string
+    ) => Promise<void>;
+    removeThemeAchievementSound: (themeId: string) => Promise<void>;
+    getThemeSoundPath: (themeId: string) => Promise<string | null>;
+    getThemeSoundDataUrl: (themeId: string) => Promise<string | null>;
+    importThemeSoundFromStore: (
+      themeId: string,
+      themeName: string,
+      storeUrl: string
+    ) => Promise<void>;
 
     /* Editor */
     openEditorWindow: (themeId: string) => Promise<void>;
     onCustomThemeUpdated: (cb: () => void) => () => Electron.IpcRenderer;
     closeEditorWindow: (themeId?: string) => Promise<void>;
+
+    /* Download Options */
+    onNewDownloadOptions: (
+      cb: (gamesWithNewOptions: { gameId: string; count: number }[]) => void
+    ) => () => Electron.IpcRenderer;
   }
 
   interface Window {

src/renderer/src/features/library-slice.ts

@@ -20,10 +20,34 @@ export const librarySlice = createSlice({
     setLibrary: (state, action: PayloadAction<LibraryState["value"]>) => {
       state.value = action.payload;
     },
+
+    updateGameNewDownloadOptions: (
+      state,
+      action: PayloadAction<{ gameId: string; count: number }>
+    ) => {
+      const game = state.value.find((g) => g.id === action.payload.gameId);
+      if (game) {
+        game.newDownloadOptionsCount = action.payload.count;
+      }
+    },
+    clearNewDownloadOptions: (
+      state,
+      action: PayloadAction<{ gameId: string }>
+    ) => {
+      const game = state.value.find((g) => g.id === action.payload.gameId);
+      if (game) {
+        game.newDownloadOptionsCount = undefined;
+      }
+    },
     setLibrarySearchQuery: (state, action: PayloadAction<string>) => {
       state.searchQuery = action.payload;
     },
   },
 });
 
-export const { setLibrary, setLibrarySearchQuery } = librarySlice.actions;
+export const {
+  setLibrary,
+  updateGameNewDownloadOptions,
+  clearNewDownloadOptions,
+  setLibrarySearchQuery,
+} = librarySlice.actions;

src/renderer/src/helpers.ts

@@ -121,3 +121,35 @@ export const formatNumber = (num: number): string => {
 export const generateUUID = (): string => {
   return uuidv4();
 };
+
+export const getAchievementSoundUrl = async (): Promise<string> => {
+  const defaultSound = (await import("@renderer/assets/audio/achievement.wav"))
+    .default;
+
+  try {
+    const activeTheme = await window.electron.getActiveCustomTheme();
+
+    if (activeTheme?.hasCustomSound) {
+      const soundDataUrl = await window.electron.getThemeSoundDataUrl(
+        activeTheme.id
+      );
+      if (soundDataUrl) {
+        return soundDataUrl;
+      }
+    }
+  } catch (error) {
+    console.error("Failed to get theme sound", error);
+  }
+
+  return defaultSound;
+};
+
+export const getAchievementSoundVolume = async (): Promise<number> => {
+  try {
+    const prefs = await window.electron.getUserPreferences();
+    return prefs?.achievementSoundVolume ?? 0.15;
+  } catch (error) {
+    console.error("Failed to get sound volume", error);
+    return 0.15;
+  }
+};

src/renderer/src/hooks/index.ts

@@ -6,4 +6,5 @@ export * from "./redux";
 export * from "./use-user-details";
 export * from "./use-format";
 export * from "./use-feature";
+export * from "./use-download-options-listener";
 export * from "./use-game-card";

src/renderer/src/hooks/use-download-options-listener.ts

@@ -0,0 +1,19 @@
+import { useEffect } from "react";
+import { useAppDispatch } from "./redux";
+import { updateGameNewDownloadOptions } from "@renderer/features";
+
+export function useDownloadOptionsListener() {
+  const dispatch = useAppDispatch();
+
+  useEffect(() => {
+    const unsubscribe = window.electron.onNewDownloadOptions(
+      (gamesWithNewOptions) => {
+        for (const { gameId, count } of gamesWithNewOptions) {
+          dispatch(updateGameNewDownloadOptions({ gameId, count }));
+        }
+      }
+    );
+
+    return unsubscribe;
+  }, [dispatch]);
+}

src/renderer/src/hooks/use-library.ts

@@ -7,9 +7,25 @@ export function useLibrary() {
   const library = useAppSelector((state) => state.library.value);
 
   const updateLibrary = useCallback(async () => {
-    return window.electron
-      .getLibrary()
-      .then((updatedLibrary) => dispatch(setLibrary(updatedLibrary)));
+    return window.electron.getLibrary().then(async (updatedLibrary) => {
+      const libraryWithAchievements = await Promise.all(
+        updatedLibrary.map(async (game) => {
+          const unlockedAchievements =
+            await window.electron.getUnlockedAchievements(
+              game.objectId,
+              game.shop
+            );
+
+          return {
+            ...game,
+            unlockedAchievementCount:
+              game.unlockedAchievementCount || unlockedAchievements.length,
+          };
+        })
+      );
+
+      dispatch(setLibrary(libraryWithAchievements));
+    });
   }, [dispatch]);
 
   return { library, updateLibrary };

src/renderer/src/pages/achievements/notification/achievement-notification.tsx

@@ -1,11 +1,15 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import achievementSound from "@renderer/assets/audio/achievement.wav";
 import { useTranslation } from "react-i18next";
 import {
   AchievementCustomNotificationPosition,
   AchievementNotificationInfo,
 } from "@types";
-import { injectCustomCss, removeCustomCss } from "@renderer/helpers";
+import {
+  injectCustomCss,
+  removeCustomCss,
+  getAchievementSoundUrl,
+  getAchievementSoundVolume,
+} from "@renderer/helpers";
 import { AchievementNotificationItem } from "@renderer/components/achievements/notification/achievement-notification";
 import app from "../../../app.scss?inline";
 import styles from "../../../components/achievements/notification/achievement-notification.scss?inline";
@@ -33,9 +37,11 @@ export function AchievementNotification() {
 
   const [shadowRootRef, setShadowRootRef] = useState<HTMLElement | null>(null);
 
-  const playAudio = useCallback(() => {
-    const audio = new Audio(achievementSound);
-    audio.volume = 0.1;
+  const playAudio = useCallback(async () => {
+    const soundUrl = await getAchievementSoundUrl();
+    const volume = await getAchievementSoundVolume();
+    const audio = new Audio(soundUrl);
+    audio.volume = volume;
     audio.play();
   }, []);
 

src/renderer/src/pages/game-details/modals/repacks-modal.scss

@@ -45,12 +45,26 @@
   &__repack-title {
     color: globals.$muted-color;
     word-break: break-word;
+    display: flex;
+    align-items: center;
+    gap: calc(globals.$spacing-unit * 1);
   }
 
   &__repack-info {
     font-size: globals.$small-font-size;
   }
 
+  &__new-badge {
+    background-color: rgba(34, 197, 94, 0.15);
+    color: rgb(187, 247, 208);
+    padding: 2px 8px;
+    border-radius: 6px;
+    font-size: 9px;
+    text-align: center;
+    flex-shrink: 0;
+    border: 1px solid rgba(34, 197, 94, 0.5);
+  }
+
   &__no-results {
     width: 100%;
     padding: calc(globals.$spacing-unit * 4) 0;

src/renderer/src/pages/game-details/modals/repacks-modal.tsx

@@ -15,14 +15,14 @@ import {
   TextField,
   CheckboxField,
 } from "@renderer/components";
-import type { DownloadSource } from "@types";
-import type { GameRepack } from "@types";
+import type { DownloadSource, GameRepack } from "@types";
 
 import { DownloadSettingsModal } from "./download-settings-modal";
 import { gameDetailsContext } from "@renderer/context";
 import { Downloader } from "@shared";
 import { orderBy } from "lodash-es";
-import { useDate, useFeature } from "@renderer/hooks";
+import { useDate, useFeature, useAppDispatch } from "@renderer/hooks";
+import { clearNewDownloadOptions } from "@renderer/features";
 import "./repacks-modal.scss";
 
 export interface RepacksModalProps {
@@ -53,6 +53,13 @@ export function RepacksModal({
   const [hashesInDebrid, setHashesInDebrid] = useState<Record<string, boolean>>(
     {}
   );
+  const [lastCheckTimestamp, setLastCheckTimestamp] = useState<string | null>(
+    null
+  );
+  const [isLoadingTimestamp, setIsLoadingTimestamp] = useState(true);
+  const [viewedRepackIds, setViewedRepackIds] = useState<Set<string>>(
+    new Set()
+  );
 
   const { game, repacks } = useContext(gameDetailsContext);
 
@@ -60,6 +67,7 @@ export function RepacksModal({
 
   const { formatDate } = useDate();
   const navigate = useNavigate();
+  const dispatch = useAppDispatch();
 
   const getHashFromMagnet = (magnet: string) => {
     if (!magnet || typeof magnet !== "string") {
@@ -97,6 +105,34 @@ export function RepacksModal({
     fetchDownloadSources();
   }, []);
 
+  useEffect(() => {
+    const fetchLastCheckTimestamp = async () => {
+      setIsLoadingTimestamp(true);
+
+      const timestamp = await window.electron.getDownloadSourcesSinceValue();
+
+      setLastCheckTimestamp(timestamp);
+      setIsLoadingTimestamp(false);
+    };
+
+    if (visible) {
+      fetchLastCheckTimestamp();
+    }
+  }, [visible, repacks]);
+
+  useEffect(() => {
+    if (
+      visible &&
+      game?.newDownloadOptionsCount &&
+      game.newDownloadOptionsCount > 0
+    ) {
+      globalThis.electron.clearNewDownloadOptions(game.shop, game.objectId);
+
+      const gameId = `${game.shop}:${game.objectId}`;
+      dispatch(clearNewDownloadOptions({ gameId }));
+    }
+  }, [visible, game, dispatch]);
+
   const sortedRepacks = useMemo(() => {
     return orderBy(
       repacks,
@@ -139,6 +175,7 @@ export function RepacksModal({
   const handleRepackClick = (repack: GameRepack) => {
     setRepack(repack);
     setShowSelectFolderModal(true);
+    setViewedRepackIds((prev) => new Set(prev).add(repack.id));
   };
 
   const handleFilter: React.ChangeEventHandler<HTMLInputElement> = (event) => {
@@ -158,6 +195,20 @@ export function RepacksModal({
     return repack.uris.some((uri) => uri.includes(game.download!.uri));
   };
 
+  const isNewRepack = (repack: GameRepack): boolean => {
+    if (isLoadingTimestamp) return false;
+
+    if (viewedRepackIds.has(repack.id)) return false;
+
+    if (!lastCheckTimestamp || !repack.createdAt) {
+      return false;
+    }
+
+    const lastCheckUtc = new Date(lastCheckTimestamp).toISOString();
+
+    return repack.createdAt > lastCheckUtc;
+  };
+
   const [isFilterDrawerOpen, setIsFilterDrawerOpen] = useState(false);
 
   useEffect(() => {
@@ -273,7 +324,14 @@ export function RepacksModal({
                   onClick={() => handleRepackClick(repack)}
                   className="repacks-modal__repack-button"
                 >
-                  <p className="repacks-modal__repack-title">{repack.title}</p>
+                  <p className="repacks-modal__repack-title">
+                    {repack.title}
+                    {isNewRepack(repack) && (
+                      <span className="repacks-modal__new-badge">
+                        {t("new_download_option")}
+                      </span>
+                    )}
+                  </p>
 
                   {isLastDownloadedOption && (
                     <Badge>{t("last_downloaded_option")}</Badge>

src/renderer/src/pages/library/library-game-card-large.scss

@@ -84,7 +84,6 @@
     gap: calc(globals.$spacing-unit);
   }
 
-
   &__logo-container {
     flex: 1;
     display: flex;
@@ -207,5 +206,4 @@
     color: rgba(255, 255, 255, 0.85);
     white-space: nowrap;
   }
-
 }

src/renderer/src/pages/library/library-game-card-large.tsx

@@ -1,10 +1,6 @@
 import { LibraryGame } from "@types";
 import { useGameCard } from "@renderer/hooks";
-import {
-  ClockIcon,
-  AlertFillIcon,
-  TrophyIcon,
-} from "@primer/octicons-react";
+import { ClockIcon, AlertFillIcon, TrophyIcon } from "@primer/octicons-react";
 import { memo, useMemo } from "react";
 import "./library-game-card-large.scss";
 
@@ -16,36 +12,45 @@ interface LibraryGameCardLargeProps {
   ) => void;
 }
 
+const normalizePathForCss = (url: string | null | undefined): string => {
+  if (!url) return "";
+  return url.replaceAll("\\", "/");
+};
+
 const getImageWithCustomPriority = (
   customUrl: string | null | undefined,
   originalUrl: string | null | undefined,
   fallbackUrl?: string | null | undefined
 ) => {
-  return customUrl || originalUrl || fallbackUrl || "";
+  const selectedUrl = customUrl || originalUrl || fallbackUrl || "";
+  return normalizePathForCss(selectedUrl);
 };
 
 export const LibraryGameCardLarge = memo(function LibraryGameCardLarge({
   game,
   onContextMenu,
 }: Readonly<LibraryGameCardLargeProps>) {
-  const {
-    formatPlayTime,
-    handleCardClick,
-    handleContextMenuClick,
-  } = useGameCard(game, onContextMenu);
+  const { formatPlayTime, handleCardClick, handleContextMenuClick } =
+    useGameCard(game, onContextMenu);
 
   const backgroundImage = useMemo(
     () =>
       getImageWithCustomPriority(
+        game.customHeroImageUrl,
         game.libraryHeroImageUrl,
-        game.libraryImageUrl,
-        game.iconUrl
+        game.libraryImageUrl ?? game.iconUrl
       ),
-    [game.libraryHeroImageUrl, game.libraryImageUrl, game.iconUrl]
+    [
+      game.customHeroImageUrl,
+      game.libraryHeroImageUrl,
+      game.libraryImageUrl,
+      game.iconUrl,
+    ]
   );
 
   const backgroundStyle = useMemo(
-    () => ({ backgroundImage: `url(${backgroundImage})` }),
+    () =>
+      backgroundImage ? { backgroundImage: `url(${backgroundImage})` } : {},
     [backgroundImage]
   );
 
@@ -56,7 +61,7 @@ export const LibraryGameCardLarge = memo(function LibraryGameCardLarge({
     [game.unlockedAchievementCount, game.achievementCount]
   );
 
-  const logoImage = game.logoImageUrl;
+  const logoImage = game.customLogoImageUrl ?? game.logoImageUrl;
 
   return (
     <button

src/renderer/src/pages/library/library-game-card.scss

@@ -209,8 +209,6 @@
     transform: scale(1);
   }
 
-
-
   &__game-image {
     object-fit: cover;
     border-radius: 4px;

src/renderer/src/pages/library/library-game-card.tsx

@@ -1,11 +1,7 @@
 import { LibraryGame } from "@types";
 import { useGameCard } from "@renderer/hooks";
 import { memo } from "react";
-import {
-  ClockIcon,
-  AlertFillIcon,
-  TrophyIcon,
-} from "@primer/octicons-react";
+import { ClockIcon, AlertFillIcon, TrophyIcon } from "@primer/octicons-react";
 import "./library-game-card.scss";
 
 interface LibraryGameCardProps {
@@ -26,18 +22,17 @@ export const LibraryGameCard = memo(function LibraryGameCard({
   onMouseLeave,
   onContextMenu,
 }: Readonly<LibraryGameCardProps>) {
-  const {
-    formatPlayTime,
-    handleCardClick,
-    handleContextMenuClick,
-  } = useGameCard(game, onContextMenu);
+  const { formatPlayTime, handleCardClick, handleContextMenuClick } =
+    useGameCard(game, onContextMenu);
 
-  const coverImage =
+  const coverImage = (
+    game.customIconUrl ??
     game.coverImageUrl ??
     game.libraryImageUrl ??
     game.libraryHeroImageUrl ??
     game.iconUrl ??
-    undefined;
+    ""
+  ).replaceAll("\\", "/");
 
   return (
     <button

src/renderer/src/pages/library/library.tsx

@@ -19,7 +19,10 @@ export default function Library() {
     onLibraryBatchComplete?: (cb: () => void) => () => void;
   };
 
-  const [viewMode, setViewMode] = useState<ViewMode>("compact");
+  const [viewMode, setViewMode] = useState<ViewMode>(() => {
+    const savedViewMode = localStorage.getItem("library-view-mode");
+    return (savedViewMode as ViewMode) || "compact";
+  });
   const [filterBy, setFilterBy] = useState<FilterOption>("all");
   const [contextMenu, setContextMenu] = useState<{
     game: LibraryGame | null;
@@ -31,6 +34,11 @@ export default function Library() {
   const dispatch = useAppDispatch();
   const { t } = useTranslation("library");
 
+  const handleViewModeChange = useCallback((mode: ViewMode) => {
+    setViewMode(mode);
+    localStorage.setItem("library-view-mode", mode);
+  }, []);
+
   useEffect(() => {
     dispatch(setHeaderTitle(t("library")));
     const electron = (globalThis as unknown as { electron?: ElectronAPI })
@@ -71,7 +79,7 @@ export default function Library() {
   );
 
   const handleCloseContextMenu = useCallback(() => {
-    setContextMenu({ game: null, visible: false, position: { x: 0, y: 0 } });
+    setContextMenu((prev) => ({ ...prev, visible: false }));
   }, []);
 
   const filteredLibrary = useMemo(() => {
@@ -147,7 +155,10 @@ export default function Library() {
             </div>
 
             <div className="library__controls-right">
-              <ViewOptions viewMode={viewMode} onViewModeChange={setViewMode} />
+              <ViewOptions
+                viewMode={viewMode}
+                onViewModeChange={handleViewModeChange}
+              />
             </div>
           </div>
         </div>

src/renderer/src/pages/settings/aparence/modals/import-theme-modal.tsx

@@ -51,6 +51,16 @@ export const ImportThemeModal = ({
 
       if (!currentTheme) return;
 
+      try {
+        await window.electron.importThemeSoundFromStore(
+          theme.id,
+          themeName,
+          THEME_WEB_STORE_URL
+        );
+      } catch (soundError) {
+        logger.error("Failed to import theme sound", soundError);
+      }
+
       const activeTheme = await window.electron.getActiveCustomTheme();
 
       if (activeTheme) {

src/renderer/src/pages/settings/settings-general.scss

@@ -17,4 +17,159 @@
   &__test-achievement-notification-button {
     align-self: flex-start;
   }
+
+  &__volume-control {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+
+    label {
+      font-size: 14px;
+      color: globals.$muted-color;
+    }
+  }
+
+  &__volume-slider-wrapper {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    width: 200px;
+    position: relative;
+    --volume-percent: 0%;
+  }
+
+  &__volume-icon {
+    color: globals.$muted-color;
+    flex-shrink: 0;
+  }
+
+  &__volume-value {
+    font-size: 14px;
+    color: globals.$body-color;
+    font-weight: 500;
+    min-width: 40px;
+    text-align: right;
+    flex-shrink: 0;
+  }
+
+  &__volume-slider {
+    flex: 1;
+    height: 6px;
+    border-radius: 3px;
+    background: globals.$dark-background-color;
+    outline: none;
+    -webkit-appearance: none;
+    appearance: none;
+    cursor: pointer;
+    transition: background 0.2s;
+
+    &::-webkit-slider-thumb {
+      -webkit-appearance: none;
+      appearance: none;
+      width: 18px;
+      height: 18px;
+      border-radius: 50%;
+      background: globals.$muted-color;
+      cursor: pointer;
+      border: 2px solid globals.$background-color;
+      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+      transition: all 0.2s;
+      margin-top: -6px;
+
+      &:hover {
+        transform: scale(1.1);
+        box-shadow: 0 2px 6px rgba(255, 255, 255, 0.4);
+      }
+
+      &:active {
+        transform: scale(1.05);
+      }
+    }
+
+    &::-moz-range-thumb {
+      width: 18px;
+      height: 18px;
+      border-radius: 50%;
+      background: globals.$muted-color;
+      cursor: pointer;
+      border: 2px solid globals.$background-color;
+      box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+      transition: all 0.2s;
+      margin-top: -6px;
+
+      &:hover {
+        transform: scale(1.1);
+        box-shadow: 0 2px 6px rgba(255, 255, 255, 0.4);
+      }
+
+      &:active {
+        transform: scale(1.05);
+      }
+    }
+
+    &::-webkit-slider-runnable-track {
+      width: 100%;
+      height: 6px;
+      border-radius: 3px;
+      background: linear-gradient(
+        to right,
+        globals.$muted-color 0%,
+        globals.$muted-color var(--volume-percent),
+        globals.$dark-background-color var(--volume-percent),
+        globals.$dark-background-color 100%
+      );
+    }
+
+    &::-moz-range-track {
+      width: 100%;
+      height: 6px;
+      border-radius: 3px;
+      background: globals.$dark-background-color;
+    }
+
+    &::-moz-range-progress {
+      height: 6px;
+      border-radius: 3px;
+      background: globals.$muted-color;
+    }
+
+    &:focus {
+      outline: none;
+
+      &::-webkit-slider-thumb {
+        box-shadow: 0 0 0 3px rgba(255, 255, 255, 0.2);
+      }
+
+      &::-moz-range-thumb {
+        box-shadow: 0 0 0 3px rgba(255, 255, 255, 0.2);
+      }
+    }
+
+    &::-ms-thumb {
+      width: 18px;
+      height: 18px;
+      border-radius: 50%;
+      background: globals.$muted-color;
+      cursor: pointer;
+      border: 2px solid globals.$background-color;
+    }
+
+    &::-ms-track {
+      width: 100%;
+      height: 6px;
+      background: transparent;
+      border-color: transparent;
+      color: transparent;
+    }
+
+    &::-ms-fill-lower {
+      background: globals.$muted-color;
+      border-radius: 3px;
+    }
+
+    &::-ms-fill-upper {
+      background: globals.$dark-background-color;
+      border-radius: 3px;
+    }
+  }
 }

src/renderer/src/pages/settings/settings-general.tsx

@@ -1,4 +1,11 @@
-import { useContext, useEffect, useMemo, useState } from "react";
+import {
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+  useCallback,
+  useRef,
+} from "react";
 import {
   TextField,
   Button,
@@ -12,7 +19,7 @@ import languageResources from "@locales";
 import { orderBy } from "lodash-es";
 import { settingsContext } from "@renderer/context";
 import "./settings-general.scss";
-import { DesktopDownloadIcon } from "@primer/octicons-react";
+import { DesktopDownloadIcon, UnmuteIcon } from "@primer/octicons-react";
 import { logger } from "@renderer/logger";
 import { AchievementCustomNotificationPosition } from "@types";
 
@@ -43,6 +50,7 @@ export function SettingsGeneral() {
     achievementCustomNotificationsEnabled: true,
     achievementCustomNotificationPosition:
       "top-left" as AchievementCustomNotificationPosition,
+    achievementSoundVolume: 15,
     language: "",
     customStyles: window.localStorage.getItem("customStyles") || "",
   });
@@ -51,6 +59,8 @@ export function SettingsGeneral() {
 
   const [defaultDownloadsPath, setDefaultDownloadsPath] = useState("");
 
+  const volumeUpdateTimeoutRef = useRef<NodeJS.Timeout>();
+
   useEffect(() => {
     window.electron.getDefaultDownloadsPath().then((path) => {
       setDefaultDownloadsPath(path);
@@ -81,6 +91,9 @@ export function SettingsGeneral() {
 
     return () => {
       clearInterval(interval);
+      if (volumeUpdateTimeoutRef.current) {
+        clearTimeout(volumeUpdateTimeoutRef.current);
+      }
     };
   }, []);
 
@@ -110,6 +123,9 @@ export function SettingsGeneral() {
           userPreferences.achievementCustomNotificationsEnabled ?? true,
         achievementCustomNotificationPosition:
           userPreferences.achievementCustomNotificationPosition ?? "top-left",
+        achievementSoundVolume: Math.round(
+          (userPreferences.achievementSoundVolume ?? 0.15) * 100
+        ),
         friendRequestNotificationsEnabled:
           userPreferences.friendRequestNotificationsEnabled ?? false,
         friendStartGameNotificationsEnabled:
@@ -148,6 +164,21 @@ export function SettingsGeneral() {
     await updateUserPreferences(values);
   };
 
+  const handleVolumeChange = useCallback(
+    (newVolume: number) => {
+      setForm((prev) => ({ ...prev, achievementSoundVolume: newVolume }));
+
+      if (volumeUpdateTimeoutRef.current) {
+        clearTimeout(volumeUpdateTimeoutRef.current);
+      }
+
+      volumeUpdateTimeoutRef.current = setTimeout(() => {
+        updateUserPreferences({ achievementSoundVolume: newVolume / 100 });
+      }, 300);
+    },
+    [updateUserPreferences]
+  );
+
   const handleChangeAchievementCustomNotificationPosition = async (
     event: React.ChangeEvent<HTMLSelectElement>
   ) => {
@@ -309,6 +340,39 @@ export function SettingsGeneral() {
           </>
         )}
 
+      {form.achievementNotificationsEnabled && (
+        <div className="settings-general__volume-control">
+          <label htmlFor="achievement-volume">
+            {t("achievement_sound_volume")}
+          </label>
+          <div className="settings-general__volume-slider-wrapper">
+            <UnmuteIcon size={16} className="settings-general__volume-icon" />
+            <input
+              id="achievement-volume"
+              type="range"
+              min="0"
+              max="100"
+              value={form.achievementSoundVolume}
+              onChange={(e) => {
+                const volumePercent = parseInt(e.target.value, 10);
+                if (!isNaN(volumePercent)) {
+                  handleVolumeChange(volumePercent);
+                }
+              }}
+              className="settings-general__volume-slider"
+              style={
+                {
+                  "--volume-percent": `${form.achievementSoundVolume}%`,
+                } as React.CSSProperties
+              }
+            />
+            <span className="settings-general__volume-value">
+              {form.achievementSoundVolume}%
+            </span>
+          </div>
+        </div>
+      )}
+
       <h2 className="settings-general__section-title">{t("common_redist")}</h2>
 
       <p className="settings-general__common-redist-description">

src/renderer/src/pages/theme-editor/theme-editor.scss

@@ -47,6 +47,8 @@
     position: relative;
     border: 1px solid globals.$muted-color;
     border-radius: 2px;
+    flex: 1;
+    min-width: 0;
   }
 
   &__footer {
@@ -80,7 +82,7 @@
   }
 
   &__info {
-    padding: 16px;
+    padding: 8px;
 
     p {
       font-size: 16px;
@@ -93,12 +95,39 @@
   &__notification-preview {
     padding-top: 12px;
     display: flex;
-    flex-direction: row;
-    align-items: center;
+    flex-direction: column;
     gap: 16px;
 
     &__select-variation {
       flex: inherit;
     }
   }
+
+  &__notification-preview-controls {
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+    flex-shrink: 0;
+  }
+
+  &__notification-controls {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 8px;
+  }
+
+  &__sound-actions {
+    display: flex;
+    flex-direction: row;
+    gap: 8px;
+    align-items: center;
+  }
+
+  &__sound-actions-row {
+    display: flex;
+    flex-direction: row;
+    gap: 8px;
+    align-items: center;
+  }
 }

src/renderer/src/pages/theme-editor/theme-editor.tsx

@@ -3,11 +3,16 @@ import "./theme-editor.scss";
 import Editor from "@monaco-editor/react";
 import { AchievementCustomNotificationPosition, Theme } from "@types";
 import { useSearchParams } from "react-router-dom";
-import { Button, SelectField } from "@renderer/components";
-import { CheckIcon } from "@primer/octicons-react";
+import { Button, SelectField, TextField } from "@renderer/components";
+import {
+  CheckIcon,
+  UploadIcon,
+  TrashIcon,
+  PlayIcon,
+} from "@primer/octicons-react";
 import { useTranslation } from "react-i18next";
 import cn from "classnames";
-import { injectCustomCss } from "@renderer/helpers";
+import { injectCustomCss, getAchievementSoundVolume } from "@renderer/helpers";
 import { AchievementNotificationItem } from "@renderer/components/achievements/notification/achievement-notification";
 import { generateAchievementCustomNotificationTest } from "@shared";
 import { CollapsedMenu } from "@renderer/components/collapsed-menu/collapsed-menu";
@@ -27,6 +32,7 @@ export default function ThemeEditor() {
   const [theme, setTheme] = useState<Theme | null>(null);
   const [code, setCode] = useState("");
   const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
+  const [soundPath, setSoundPath] = useState<string>("");
 
   const [isClosingNotifications, setIsClosingNotifications] = useState(false);
 
@@ -62,6 +68,9 @@ export default function ThemeEditor() {
         if (loadedTheme) {
           setTheme(loadedTheme);
           setCode(loadedTheme.code);
+          if (loadedTheme.originalSoundPath) {
+            setSoundPath(loadedTheme.originalSoundPath);
+          }
           if (shadowRootRef) {
             injectCustomCss(loadedTheme.code, shadowRootRef);
           }
@@ -107,6 +116,73 @@ export default function ThemeEditor() {
     }
   };
 
+  const handleSelectSound = useCallback(async () => {
+    if (!theme) return;
+
+    const { filePaths } = await window.electron.showOpenDialog({
+      properties: ["openFile"],
+      filters: [
+        {
+          name: "Audio",
+          extensions: ["wav", "mp3", "ogg", "m4a"],
+        },
+      ],
+    });
+
+    if (filePaths && filePaths.length > 0) {
+      const originalPath = filePaths[0];
+      await window.electron.copyThemeAchievementSound(theme.id, originalPath);
+      const updatedTheme = await window.electron.getCustomThemeById(theme.id);
+      if (updatedTheme) {
+        setTheme(updatedTheme);
+        if (updatedTheme.originalSoundPath) {
+          setSoundPath(updatedTheme.originalSoundPath);
+        }
+      }
+    }
+  }, [theme]);
+
+  const handleRemoveSound = useCallback(async () => {
+    if (!theme) return;
+
+    await window.electron.removeThemeAchievementSound(theme.id);
+    const updatedTheme = await window.electron.getCustomThemeById(theme.id);
+    if (updatedTheme) {
+      setTheme(updatedTheme);
+    }
+    setSoundPath("");
+  }, [theme]);
+
+  const handlePreviewSound = useCallback(async () => {
+    if (!theme) return;
+
+    let soundUrl: string;
+
+    if (theme.hasCustomSound) {
+      const themeSoundUrl = await window.electron.getThemeSoundDataUrl(
+        theme.id
+      );
+      if (themeSoundUrl) {
+        soundUrl = themeSoundUrl;
+      } else {
+        const defaultSound = (
+          await import("@renderer/assets/audio/achievement.wav")
+        ).default;
+        soundUrl = defaultSound;
+      }
+    } else {
+      const defaultSound = (
+        await import("@renderer/assets/audio/achievement.wav")
+      ).default;
+      soundUrl = defaultSound;
+    }
+
+    const volume = await getAchievementSoundVolume();
+    const audio = new Audio(soundUrl);
+    audio.volume = volume;
+    audio.play();
+  }, [theme]);
+
   const achievementCustomNotificationPositionOptions = useMemo(() => {
     return [
       "top-left",
@@ -164,35 +240,66 @@ export default function ThemeEditor() {
       <div className="theme-editor__footer">
         <CollapsedMenu title={t("notification_preview")}>
           <div className="theme-editor__notification-preview">
-            <SelectField
-              className="theme-editor__notification-preview__select-variation"
-              label={t("variation")}
-              options={Object.values(notificationVariations).map(
-                (variation) => {
-                  return {
-                    key: variation,
-                    value: variation,
-                    label: t(variation),
-                  };
-                }
-              )}
-              onChange={(value) =>
-                setNotificationVariation(
-                  value.target.value as keyof typeof notificationVariations
-                )
+            <div className="theme-editor__notification-preview-controls">
+              <div className="theme-editor__notification-controls">
+                <SelectField
+                  className="theme-editor__notification-preview__select-variation"
+                  label={t("variation")}
+                  options={Object.values(notificationVariations).map(
+                    (variation) => {
+                      return {
+                        key: variation,
+                        value: variation,
+                        label: t(variation),
+                      };
+                    }
+                  )}
+                  onChange={(value) =>
+                    setNotificationVariation(
+                      value.target.value as keyof typeof notificationVariations
+                    )
+                  }
+                />
+
+                <SelectField
+                  label={t("alignment")}
+                  value={notificationAlignment}
+                  onChange={(e) =>
+                    setNotificationAlignment(
+                      e.target.value as AchievementCustomNotificationPosition
+                    )
+                  }
+                  options={achievementCustomNotificationPositionOptions}
+                />
+              </div>
+            </div>
+
+            <TextField
+              label={t("select_achievement_sound")}
+              value={soundPath || ""}
+              placeholder={soundPath ? undefined : t("no_sound_file_selected")}
+              readOnly
+              disabled
+              rightContent={
+                <Button theme="outline" onClick={handleSelectSound}>
+                  <UploadIcon />
+                  {t("select")}
+                </Button>
               }
             />
 
-            <SelectField
-              label={t("alignment")}
-              value={notificationAlignment}
-              onChange={(e) =>
-                setNotificationAlignment(
-                  e.target.value as AchievementCustomNotificationPosition
-                )
-              }
-              options={achievementCustomNotificationPositionOptions}
-            />
+            {theme?.hasCustomSound && (
+              <div className="theme-editor__sound-actions-row">
+                <Button theme="outline" onClick={handleRemoveSound}>
+                  <TrashIcon />
+                  {t("remove")}
+                </Button>
+                <Button theme="outline" onClick={handlePreviewSound}>
+                  <PlayIcon />
+                  {t("preview")}
+                </Button>
+              </div>
+            )}
 
             <div className="theme-editor__notification-preview-wrapper">
               <root.div>

src/types/index.ts

@@ -23,6 +23,7 @@ export interface GameRepack {
   uploadDate: string | null;
   downloadSourceId: string;
   downloadSourceName: string;
+  createdAt: string;
 }
 
 export interface DownloadSource {
@@ -41,9 +42,9 @@ export interface ShopAssets {
   shop: GameShop;
   title: string;
   iconUrl: string | null;
-  libraryHeroImageUrl: string;
-  libraryImageUrl: string;
-  logoImageUrl: string;
+  libraryHeroImageUrl: string | null;
+  libraryImageUrl: string | null;
+  logoImageUrl: string | null;
   logoPosition: string | null;
   coverImageUrl: string | null;
   downloadSources: string[];

src/types/level.types.ts

@@ -56,9 +56,12 @@ export interface Game {
   launchOptions?: string | null;
   favorite?: boolean;
   isPinned?: boolean;
+  achievementCount?: number;
+  unlockedAchievementCount?: number;
   pinnedDate?: Date | null;
   automaticCloudSync?: boolean;
   hasManuallyUpdatedPlaytime?: boolean;
+  newDownloadOptionsCount?: number;
 }
 
 export interface Download {
@@ -113,6 +116,7 @@ export interface UserPreferences {
   achievementNotificationsEnabled?: boolean;
   achievementCustomNotificationsEnabled?: boolean;
   achievementCustomNotificationPosition?: AchievementCustomNotificationPosition;
+  achievementSoundVolume?: number;
   friendRequestNotificationsEnabled?: boolean;
   friendStartGameNotificationsEnabled?: boolean;
   showDownloadSpeedInMegabytes?: boolean;

src/types/theme.types.ts

@@ -5,6 +5,8 @@ export interface Theme {
   authorName?: string;
   isActive: boolean;
   code: string;
+  hasCustomSound?: boolean;
+  originalSoundPath?: string;
   createdAt: Date;
   updatedAt: Date;
 }