fix: performance overhaul to prevent crashes

- Fix blob URL memory leak with BlobUrlManager that tracks and revokes URLs
- Fix episode key collision using composite key (podcastName::title)
- Fix array bounds check crash in downloadedEpisodes.removeEpisode
- Add network request timeouts (30s default) to prevent UI hangs
- Fix interval leak in opml.ts TimerNotice
- Add localStorage size limits (4MB) to FeedCacheService with LRU eviction
- Add null safety checks throughout to prevent Svelte reactivity errors
- Add unmount safety flag to prevent state updates after component destroy

Author: chhoumann

src/iTunesAPIConsumer.ts

@@ -1,5 +1,16 @@
-import { requestUrl } from "obsidian";
 import type { PodcastFeed } from "./types/PodcastFeed";
+import { requestWithTimeout, NetworkError } from "./utility/networkRequest";
+
+interface iTunesResult {
+	collectionName: string;
+	feedUrl: string;
+	artworkUrl100: string;
+	collectionId: string;
+}
+
+interface iTunesSearchResponse {
+	results: iTunesResult[];
+}
 
 export async function queryiTunesPodcasts(query: string): Promise<PodcastFeed[]> {
 	const url = new URL("https://itunes.apple.com/search?");
@@ -8,13 +19,20 @@ export async function queryiTunesPodcasts(query: string): Promise<PodcastFeed[]>
 	url.searchParams.append("limit", "3");
 	url.searchParams.append("kind", "podcast");
 
-	const res = await requestUrl({ url: url.href });
-	const data = res.json.results;
+	try {
+		const response = await requestWithTimeout(url.href, { timeoutMs: 15000 });
+		const data = response.json as iTunesSearchResponse;
 
-	return data.map((d: { collectionName: string, feedUrl: string, artworkUrl100: string, collectionId: string }) => ({
-		title: d.collectionName,
-		url: d.feedUrl,
-		artworkUrl: d.artworkUrl100,
-		collectionId: d.collectionId
-	}));
+		return (data.results || []).map((d) => ({
+			title: d.collectionName,
+			url: d.feedUrl,
+			artworkUrl: d.artworkUrl100,
+			collectionId: d.collectionId,
+		}));
+	} catch (error) {
+		if (error instanceof NetworkError) {
+			console.error(`iTunes search failed: ${error.message}`);
+		}
+		return [];
+	}
 }

src/main.ts

@@ -10,6 +10,7 @@ import {
 	hidePlayedEpisodes,
 	volume,
 } from "src/store";
+import { blobUrlManager } from "src/utility/createMediaUrlObjectFromFilePath";
 import { Plugin, type WorkspaceLeaf } from "obsidian";
 import { API } from "src/API/API";
 import type { IAPI } from "src/API/IAPI";
@@ -374,6 +375,9 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		this.currentEpisodeController?.off();
 		this.hidePlayedEpisodesController?.off();
 		this.volumeUnsubscribe?.();
+
+		// Clean up any active blob URLs to prevent memory leaks
+		blobUrlManager.revokeAll();
 	}
 
 	async loadSettings() {

src/opml.ts

@@ -7,7 +7,8 @@ import { get } from "svelte/store";
 function TimerNotice(heading: string, initialMessage: string) {
 	let currentMessage = initialMessage;
 	const startTime = Date.now();
-	let stopTime: number;
+	let stopTime: number | undefined;
+	let intervalId: ReturnType<typeof setInterval> | undefined;
 	const notice = new Notice(initialMessage, 0);
 
 	function formatMsg(message: string): string {
@@ -19,20 +20,30 @@ function TimerNotice(heading: string, initialMessage: string) {
 		notice.setMessage(formatMsg(currentMessage));
 	}
 
-	const interval = setInterval(() => {
-		notice.setMessage(formatMsg(currentMessage));
-	}, 1000);
-
 	function getTime(): string {
 		return formatTime(stopTime ? stopTime - startTime : Date.now() - startTime);
 	}
 
+	function clearTimer() {
+		if (intervalId !== undefined) {
+			clearInterval(intervalId);
+			intervalId = undefined;
+		}
+	}
+
+	intervalId = setInterval(() => {
+		notice.setMessage(formatMsg(currentMessage));
+	}, 1000);
+
 	return {
 		update,
-		hide: () => notice.hide(),
+		hide: () => {
+			clearTimer();
+			notice.hide();
+		},
 		stop: () => {
 			stopTime = Date.now();
-			clearInterval(interval);
+			clearTimer();
 		},
 	};
 }

src/parser/feedParser.ts

@@ -1,6 +1,6 @@
 import type { PodcastFeed } from "src/types/PodcastFeed";
-import { requestUrl } from "obsidian";
 import type { Episode } from "src/types/Episode";
+import { requestWithTimeout } from "src/utility/networkRequest";
 
 export default class FeedParser {
 	private feed: PodcastFeed | undefined;
@@ -125,7 +125,7 @@ export default class FeedParser {
 	}
 
 	private async parseFeed(feedUrl: string): Promise<Document> {
-		const req = await requestUrl({ url: feedUrl });
+		const req = await requestWithTimeout(feedUrl, { timeoutMs: 30000 });
 		const dp = new DOMParser();
 
 		const body = dp.parseFromString(req.text, "text/xml");

src/services/FeedCacheService.ts

@@ -15,6 +15,7 @@ type FeedCache = Record<string, CachedFeedData>;
 const STORAGE_KEY = "podnotes:feed-cache:v1";
 const DEFAULT_TTL_MS = 1000 * 60 * 60 * 6; // 6 hours.
 const MAX_EPISODES_PER_FEED = 75;
+const MAX_CACHE_SIZE_BYTES = 4 * 1024 * 1024; // 4MB to leave room for other localStorage usage
 
 let cache: FeedCache | null = null;
 
@@ -55,16 +56,67 @@ function loadCache(): FeedCache {
 	}
 }
 
+function evictOldestEntries(cacheData: FeedCache, targetSizeBytes: number): FeedCache {
+	const entries = Object.entries(cacheData);
+
+	// Sort by updatedAt ascending (oldest first)
+	entries.sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+
+	const result: FeedCache = {};
+	let currentSize = 0;
+
+	// Add entries from newest to oldest until we exceed target size
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const [key, value] = entries[i];
+		const entrySize = JSON.stringify({ [key]: value }).length;
+
+		if (currentSize + entrySize <= targetSizeBytes) {
+			result[key] = value;
+			currentSize += entrySize;
+		}
+	}
+
+	return result;
+}
+
 function persistCache(): void {
 	const storage = getStorage();
-	if (!storage) {
+	if (!storage || !cache) {
 		return;
 	}
 
 	try {
-		storage.setItem(STORAGE_KEY, JSON.stringify(cache ?? {}));
+		let serialized = JSON.stringify(cache);
+
+		// If cache is too large, evict oldest entries
+		if (serialized.length > MAX_CACHE_SIZE_BYTES) {
+			console.warn(
+				`Feed cache size (${serialized.length} bytes) exceeds limit, evicting old entries`,
+			);
+			cache = evictOldestEntries(cache, MAX_CACHE_SIZE_BYTES * 0.8); // Target 80% of max
+			serialized = JSON.stringify(cache);
+		}
+
+		storage.setItem(STORAGE_KEY, serialized);
 	} catch (error) {
-		console.error("Failed to persist feed cache:", error);
+		// Handle quota exceeded error specifically
+		if (
+			error instanceof DOMException &&
+			(error.name === "QuotaExceededError" ||
+				error.name === "NS_ERROR_DOM_QUOTA_REACHED")
+		) {
+			console.warn("localStorage quota exceeded, clearing feed cache");
+			try {
+				// Clear cache and try again with empty cache
+				cache = {};
+				storage.setItem(STORAGE_KEY, "{}");
+			} catch {
+				// If we still can't write, just clear the item
+				storage.removeItem(STORAGE_KEY);
+			}
+		} else {
+			console.error("Failed to persist feed cache:", error);
+		}
 	}
 }
 

src/store/index.ts

@@ -8,6 +8,7 @@ import { ViewState } from "src/types/ViewState";
 import type DownloadedEpisode from "src/types/DownloadedEpisode";
 import { TFile } from "obsidian";
 import type { LocalEpisode } from "src/types/LocalEpisode";
+import { getEpisodeKey } from "src/utility/episodeKey";
 
 export const plugin = writable<PodNotes>();
 export const currentTime = writable<number>(0);
@@ -46,18 +47,51 @@ export const playedEpisodes = (() => {
 	const store = writable<{ [key: string]: PlayedEpisode }>({});
 	const { subscribe, update, set } = store;
 
+	/**
+	 * Gets played episode data, checking both composite key and legacy title-only key
+	 * for backwards compatibility.
+	 */
+	function getPlayedEpisode(
+		playedEps: { [key: string]: PlayedEpisode },
+		episode: Episode | null | undefined,
+	): PlayedEpisode | undefined {
+		if (!episode) return undefined;
+
+		const key = getEpisodeKey(episode);
+		// First try composite key
+		if (key && playedEps[key]) {
+			return playedEps[key];
+		}
+		// Fall back to title-only for backwards compatibility
+		if (episode.title && playedEps[episode.title]) {
+			return playedEps[episode.title];
+		}
+		return undefined;
+	}
+
 	return {
 		subscribe,
 		set,
 		update,
+		/**
+		 * Gets played episode data with backwards compatibility.
+		 */
+		get: (episode: Episode): PlayedEpisode | undefined => {
+			return getPlayedEpisode(get(store), episode);
+		},
 		setEpisodeTime: (
-			episode: Episode,
+			episode: Episode | null | undefined,
 			time: number,
 			duration: number,
 			finished: boolean,
 		) => {
+			if (!episode) return;
+
 			update((playedEpisodes) => {
-				playedEpisodes[episode.title] = {
+				const key = getEpisodeKey(episode);
+				if (!key) return playedEpisodes;
+
+				playedEpisodes[key] = {
 					title: episode.title,
 					podcastName: episode.podcastName,
 					time,
@@ -68,29 +102,47 @@ export const playedEpisodes = (() => {
 				return playedEpisodes;
 			});
 		},
-		markAsPlayed: (episode: Episode) => {
+		markAsPlayed: (episode: Episode | null | undefined) => {
+			if (!episode) return;
+
 			update((playedEpisodes) => {
-				const playedEpisode = playedEpisodes[episode.title] || episode;
+				const key = getEpisodeKey(episode);
+				if (!key) return playedEpisodes;
 
-				if (playedEpisode) {
-					playedEpisode.time = playedEpisode.duration;
-					playedEpisode.finished = true;
-				}
+				const playedEpisode = getPlayedEpisode(playedEpisodes, episode) || {
+					title: episode.title,
+					podcastName: episode.podcastName,
+					time: 0,
+					duration: 0,
+					finished: false,
+				};
 
-				playedEpisodes[episode.title] = playedEpisode;
+				playedEpisode.time = playedEpisode.duration;
+				playedEpisode.finished = true;
+
+				playedEpisodes[key] = playedEpisode;
 				return playedEpisodes;
 			});
 		},
-		markAsUnplayed: (episode: Episode) => {
+		markAsUnplayed: (episode: Episode | null | undefined) => {
+			if (!episode) return;
+
 			update((playedEpisodes) => {
-				const playedEpisode = playedEpisodes[episode.title] || episode;
+				const key = getEpisodeKey(episode);
+				if (!key) return playedEpisodes;
 
-				if (playedEpisode) {
-					playedEpisode.time = 0;
-					playedEpisode.finished = false;
-				}
+				const playedEpisode = getPlayedEpisode(playedEpisodes, episode) || {
+					title: episode.title,
+					podcastName: episode.podcastName,
+					time: 0,
+					duration: 0,
+					finished: false,
+				};
 
-				playedEpisodes[episode.title] = playedEpisode;
+				playedEpisode.time = 0;
+				playedEpisode.finished = false;
+
+				playedEpisodes[key] = playedEpisode;
 				return playedEpisodes;
 			});
 		},
@@ -313,11 +365,16 @@ export const downloadedEpisodes = (() => {
 				const index = podcastEpisodes.findIndex(
 					(e) => e.title === episode.title,
 				);
-				const filePath = podcastEpisodes[index].filePath;
 
+				// Guard against episode not found
+				if (index === -1) {
+					return downloadedEpisodes;
+				}
+
+				const filePath = podcastEpisodes[index].filePath;
 				podcastEpisodes.splice(index, 1);
 
-				if (removeFile) {
+				if (removeFile && filePath) {
 					try {
 						// @ts-ignore: app is not defined in the global scope anymore, but is still
 						// available. Need to fix this later

src/ui/PodcastView/EpisodeList.svelte

@@ -6,13 +6,21 @@
 	import Icon from "../obsidian/Icon.svelte";
 	import Text from "../obsidian/Text.svelte";
 	import Loading from "./Loading.svelte";
+	import { getEpisodeKey } from "src/utility/episodeKey";
 
 	export let episodes: Episode[] = [];
 	export let showThumbnails: boolean = false;
 	export let showListMenu: boolean = true;
 	export let isLoading: boolean = false;
 	let searchInputQuery: string = "";
 
+	function isEpisodeFinished(episode: Episode | null | undefined, playedEps: typeof $playedEpisodes): boolean {
+		if (!episode) return false;
+		const key = getEpisodeKey(episode);
+		// Check composite key first, then fall back to title-only for backwards compat
+		return (key && playedEps[key]?.finished) || playedEps[episode.title]?.finished || false;
+	}
+
 	const dispatch = createEventDispatcher();
 
 	function forwardClickEpisode(event: CustomEvent<{ episode: Episode }>) {
@@ -75,7 +83,7 @@
 			<p>No episodes found.</p>
 		{/if}
 		{#each episodes as episode (episode.url || episode.streamUrl || `${episode.title}-${episode.episodeDate ?? ""}`)}
-			{@const episodePlayed = $playedEpisodes[episode.title]?.finished}
+			{@const episodePlayed = isEpisodeFinished(episode, $playedEpisodes)}
 			{#if !$hidePlayedEpisodes || !episodePlayed}
 				<EpisodeListItem
 					{episode}