fix: show downloaded episodes in the Local Files playlist (#176) (#177)

* fix: show downloaded episodes in the Local Files playlist (#176)

Downloaded episodes were recorded in the downloadedEpisodes store but never
added to the localFiles playlist, so the Podcast grid's "Local Files" list
stayed empty ("No episodes found") even though the file was on disk and the
"Remove file" option appeared in the episode list.

Make localFiles a change-gated projection of downloadedEpisodes -- the
authoritative offline set, written by both downloads and "Play with PodNotes".
Entries are copied verbatim so filePath/size and the real podcastName survive,
keeping local-file playback working. Existing downloads are backfilled on load,
and removing a downloaded file now also removes it from Local Files.

* perf: skip Local Files store write on no-op sync (#177)

Addresses PR review feedback: the membership change-gate returned the same
playlist object from update(), but Svelte still notifies subscribers for any
object value, so LocalFilesController.onChange + saveSettings re-ran on every
downloadedEpisodes mutation. Compare against the current store value before
calling update() so an unchanged membership skips the store write entirely.
Strengthen the no-op test to assert no subscriber notification fires.

Author: chhoumann

docs/docs/local_files.md

@@ -1,5 +1,5 @@
 PodNotes supports local files. You can right-click any audio file and click `Play with PodNotes`.
 
-In the podcast grid, you will see a playlist with a folder icon. This is a playlist consisting of all local files (non-downloaded episodes) you have played with PodNotes.
+In the podcast grid, you will see a playlist with a folder icon. This is a playlist of every episode you have available offline: both local audio files you have played with `Play with PodNotes` and episodes you have downloaded. Removing a downloaded file also removes it from this playlist.
 
 PodNotes will attempt to treat all local files as podcast episodes. This means all standard features are available, such as timestamps, note creation, and persisting playback time. Any exceptions will be added here.

src/getContextMenuHandler.ts

@@ -3,7 +3,6 @@ import { TFile } from "obsidian";
 import { get } from "svelte/store";
 import {
 	downloadedEpisodes,
-	localFiles,
 	playedEpisodes,
 	currentEpisode,
 	viewState,
@@ -43,13 +42,14 @@ export default function getContextMenuHandler(app: App): EventRef {
 								localEpisode
 							)
 						) {
+							// The Local Files playlist is mirrored from downloadedEpisodes
+							// (see localFiles.syncWithDownloaded), so this single write
+							// surfaces the file there too.
 							downloadedEpisodes.addEpisode(
 								localEpisode,
 								file.path,
 								file.stat.size
 							);
-
-							localFiles.addEpisode(localEpisode);
 						}
 
 						// Fixes where the episode won't play if it has been played.

src/main.ts

@@ -73,6 +73,7 @@ export default class PodNotes extends Plugin implements IPodNotes {
 	private hidePlayedEpisodesController?: StoreController<boolean>;
 	private transcriptionService?: TranscriptionService;
 	private volumeUnsubscribe?: Unsubscriber;
+	private localFilesMirrorUnsubscribe?: Unsubscriber;
 
 	private maxLayoutReadyAttempts = 10;
 	private layoutReadyAttempts = 0;
@@ -123,6 +124,14 @@ export default class PodNotes extends Plugin implements IPodNotes {
 			this,
 		).on();
 
+		// Keep the Local Files playlist in sync with downloaded episodes (issue #176).
+		// downloadedEpisodes is the authoritative offline set, so mirror it into the
+		// localFiles playlist that the Podcast grid renders. Svelte's immediate-fire
+		// backfills already-downloaded episodes on load; later changes keep it current.
+		this.localFilesMirrorUnsubscribe = downloadedEpisodes.subscribe(
+			(downloaded) => localFiles.syncWithDownloaded(downloaded),
+		);
+
 		this.api = new API();
 		this.volumeUnsubscribe = volume.subscribe((value) => {
 			const clamped = Math.min(1, Math.max(0, value));
@@ -389,6 +398,7 @@ export default class PodNotes extends Plugin implements IPodNotes {
 		this.currentEpisodeController?.off();
 		this.hidePlayedEpisodesController?.off();
 		this.volumeUnsubscribe?.();
+		this.localFilesMirrorUnsubscribe?.();
 
 		// Clean up any active blob URLs to prevent memory leaks
 		blobUrlManager.revokeAll();

src/store/index.test.ts

@@ -4,11 +4,14 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 import type { Episode } from "src/types/Episode";
 import type { IPodNotes } from "src/types/IPodNotes";
 import type { PlayedEpisode } from "src/types/PlayedEpisode";
-import { QUEUE_SETTINGS } from "src/constants";
+import type DownloadedEpisode from "src/types/DownloadedEpisode";
+import { LOCAL_FILES_SETTINGS, QUEUE_SETTINGS } from "src/constants";
 import { QueueController } from "src/store_controllers/QueueController";
 import {
 	currentEpisode,
 	dedupeEpisodesByTitle,
+	downloadedEpisodes,
+	localFiles,
 	playedEpisodes,
 	queue,
 	reorderEpisodes,
@@ -76,6 +79,211 @@ describe("playedEpisodes store", () => {
 	});
 });
 
+function downloadedEpisode(
+	podcastName: string,
+	title: string,
+	overrides: Partial<DownloadedEpisode> = {},
+): DownloadedEpisode {
+	return {
+		title,
+		streamUrl: `https://example.com/${title}.mp3`,
+		url: `https://example.com/${title}`,
+		description: "",
+		content: "",
+		podcastName,
+		filePath: `podcasts/${podcastName} ${title}.mp3`,
+		size: 1024,
+		...overrides,
+	};
+}
+
+describe("localFiles store — syncWithDownloaded (issue #176)", () => {
+	beforeEach(() => {
+		downloadedEpisodes.set({});
+		localFiles.set({
+			...LOCAL_FILES_SETTINGS,
+			episodes: [],
+		});
+	});
+
+	test("mirrors downloaded episodes across every podcast bucket", () => {
+		localFiles.syncWithDownloaded({
+			"Podcast A": [downloadedEpisode("Podcast A", "Ep 1")],
+			"Podcast B": [
+				downloadedEpisode("Podcast B", "Ep 2"),
+				downloadedEpisode("Podcast B", "Ep 3"),
+			],
+		});
+
+		const titles = get(localFiles).episodes.map((ep) => ep.title);
+		expect(titles).toEqual(["Ep 1", "Ep 2", "Ep 3"]);
+	});
+
+	test("keeps same-title episodes from different podcasts (composite-key dedup)", () => {
+		localFiles.syncWithDownloaded({
+			"Podcast A": [downloadedEpisode("Podcast A", "Shared title")],
+			"Podcast B": [downloadedEpisode("Podcast B", "Shared title")],
+		});
+
+		const episodes = get(localFiles).episodes;
+		expect(episodes).toHaveLength(2);
+		expect(episodes.map((ep) => ep.podcastName).sort()).toEqual([
+			"Podcast A",
+			"Podcast B",
+		]);
+	});
+
+	test("preserves filePath/size and the real podcastName (not coerced)", () => {
+		localFiles.syncWithDownloaded({
+			"Real Podcast": [
+				downloadedEpisode("Real Podcast", "Ep 1", {
+					filePath: "podcasts/real.mp3",
+					size: 4096,
+				}),
+			],
+		});
+
+		const [ep] = get(localFiles).episodes;
+		expect(ep.podcastName).toBe("Real Podcast");
+		expect((ep as DownloadedEpisode).filePath).toBe("podcasts/real.mp3");
+		expect((ep as DownloadedEpisode).size).toBe(4096);
+	});
+
+	test("keeps manual local files with podcastName 'local file'", () => {
+		localFiles.syncWithDownloaded({
+			"local file": [downloadedEpisode("local file", "My Recording")],
+		});
+
+		const [ep] = get(localFiles).episodes;
+		expect(ep.podcastName).toBe("local file");
+	});
+
+	test("removal from downloadedEpisodes propagates to the playlist", () => {
+		const map = {
+			"Podcast A": [
+				downloadedEpisode("Podcast A", "Ep 1"),
+				downloadedEpisode("Podcast A", "Ep 2"),
+			],
+		};
+		localFiles.syncWithDownloaded(map);
+		expect(get(localFiles).episodes).toHaveLength(2);
+
+		localFiles.syncWithDownloaded({
+			"Podcast A": [downloadedEpisode("Podcast A", "Ep 2")],
+		});
+
+		const titles = get(localFiles).episodes.map((ep) => ep.title);
+		expect(titles).toEqual(["Ep 2"]);
+	});
+
+	test("empty map clears the playlist but preserves its metadata", () => {
+		localFiles.syncWithDownloaded({
+			"Podcast A": [downloadedEpisode("Podcast A", "Ep 1")],
+		});
+
+		localFiles.syncWithDownloaded({});
+
+		const playlist = get(localFiles);
+		expect(playlist.episodes).toEqual([]);
+		expect(playlist.name).toBe(LOCAL_FILES_SETTINGS.name);
+		expect(playlist.icon).toBe(LOCAL_FILES_SETTINGS.icon);
+	});
+
+	test("is a no-op when membership is unchanged (no store notification)", () => {
+		localFiles.syncWithDownloaded({
+			"Podcast A": [downloadedEpisode("Podcast A", "Ep 1")],
+		});
+		const before = get(localFiles);
+
+		// Svelte notifies subscribers for every object value (safe_not_equal treats
+		// objects as always-changed), so a no-op must not touch the store at all --
+		// otherwise LocalFilesController.onChange + saveSettings would re-run.
+		let notifications = 0;
+		const unsubscribe = localFiles.subscribe(() => {
+			notifications += 1;
+		});
+		expect(notifications).toBe(1); // immediate fire on subscribe
+
+		localFiles.syncWithDownloaded({
+			"Podcast A": [downloadedEpisode("Podcast A", "Ep 1")],
+		});
+		expect(notifications).toBe(1); // unchanged membership -> no extra notification
+		expect(get(localFiles)).toBe(before); // store value object reused
+
+		// A real membership change does notify.
+		localFiles.syncWithDownloaded({
+			"Podcast A": [
+				downloadedEpisode("Podcast A", "Ep 1"),
+				downloadedEpisode("Podcast A", "Ep 2"),
+			],
+		});
+		expect(notifications).toBe(2);
+
+		unsubscribe();
+	});
+
+	test("getLocalEpisode prefers a manual local file over a same-titled download", () => {
+		localFiles.syncWithDownloaded({
+			"Real Podcast": [downloadedEpisode("Real Podcast", "Collision")],
+			"local file": [
+				downloadedEpisode("local file", "Collision", {
+					filePath: "recordings/collision.mp3",
+				}),
+			],
+		});
+
+		expect(localFiles.getLocalEpisode("Collision")?.podcastName).toBe(
+			"local file",
+		);
+	});
+
+	test("dedupes identical composite keys, keeping the first occurrence", () => {
+		localFiles.syncWithDownloaded({
+			"Podcast A": [
+				downloadedEpisode("Podcast A", "Dup", { filePath: "first.mp3" }),
+				downloadedEpisode("Podcast A", "Dup", { filePath: "second.mp3" }),
+			],
+		});
+
+		const episodes = get(localFiles).episodes;
+		expect(episodes).toHaveLength(1);
+		expect((episodes[0] as DownloadedEpisode).filePath).toBe("first.mp3");
+	});
+
+	test("skips entries with no usable episode key", () => {
+		localFiles.syncWithDownloaded({
+			"Podcast A": [
+				downloadedEpisode("Podcast A", ""),
+				downloadedEpisode("Podcast A", "Valid"),
+			],
+		});
+
+		const titles = get(localFiles).episodes.map((ep) => ep.title);
+		expect(titles).toEqual(["Valid"]);
+	});
+
+	test("surfaces a file added only to downloadedEpisodes (getContextMenuHandler flow)", () => {
+		// getContextMenuHandler now writes a manual local file only to
+		// downloadedEpisodes and relies on the projection to surface it.
+		downloadedEpisodes.addEpisode(
+			downloadedEpisode("local file", "My Recording", {
+				filePath: "recordings/my recording.m4a",
+			}),
+			"recordings/my recording.m4a",
+			2048,
+		);
+
+		localFiles.syncWithDownloaded(get(downloadedEpisodes));
+
+		const [ep] = get(localFiles).episodes;
+		expect(ep?.title).toBe("My Recording");
+		expect(ep?.podcastName).toBe("local file");
+		expect((ep as DownloadedEpisode).filePath).toBe(
+			"recordings/my recording.m4a",
+		);
+	});
+});
+
 function ep(title: string, podcastName = "Pod"): Episode {
 	return {
 		title,