feat(feed): make episode cache bound user-configurable (date window or count)

Add episodeCacheMode/count/days preferences (default: date, 60 days). Apply the bound when reading instead of writing, so a preference change takes effect without a refetch; the full parse cache stays intact so fetch-more can page beyond the bound. Thread the window through load/saveFeedsToFile and update tests and task docs.
2026-08-12 15:41:22 -04:00
parent 4127fd1181
commit 26729fa5e6
16 changed files with 431 additions and 160 deletions
--- a/src/pages/Settings/PreferencesPanel.tsx
+++ b/src/pages/Settings/PreferencesPanel.tsx
@@ -4,13 +4,15 @@
 * driven by the Shell router via nav.action.
 *
 * Auto-download (global setting, see stores/feed.ts runAutoDownload):
- *   • Auto Download        — master toggle (default: off)
- *   • Auto Download Count  — X most recent episodes per show (default: 2,
- *                            any positive integer — type it in the editor)
- *   • Auto Download Scope  — which shows: all / none / whitelist (default: all)
 *   • Auto Download Whitelist — shown only when scope is "whitelist": search
 *                            field over subscribed shows; suggestions toggle
 *                            in/out with Space (j/k to move, Esc to browse).
+ *   • Episode Cache Mode   — date or count bound for the episode list
+ *                            (default: date)
+ *   • Episode Cache Count  — N most recent episodes when mode is count
+ *                            (default: 25)
+ *   • Episode Cache Days   — rolling N-day window when mode is date
+ *                            (default: 60)
 */

 import { createSignal, Show, For, onMount, onCleanup } from "solid-js";
@@ -30,7 +32,7 @@ import {
 import { on } from "@/utils/event-bus";
 import type { KeybindActionName } from "@/context/KeybindContext";
 import { TABS } from "@/utils/navigation";
-import type { AutoDownloadScope, ThemeName } from "@/types/settings";
+import type { AutoDownloadScope, EpisodeCacheMode, ThemeName } from "@/types/settings";
 import type { Feed } from "@/types/feed";
 import type { SettingItem } from "./types";

@@ -48,6 +50,14 @@ const SCOPE_LABELS: Array<{ value: AutoDownloadScope; label: string }> = [
 	{ value: "none", label: "None" },
 	{ value: "whitelist", label: "Whitelist" },
 ];
+const CACHE_MODE_LABELS: Array<{ value: EpisodeCacheMode; label: string }> = [
+	{ value: "date", label: "Date" },
+	{ value: "count", label: "Count" },
+];
+
+function cacheModeLabel(mode: EpisodeCacheMode): string {
+	return CACHE_MODE_LABELS.find((s) => s.value === mode)?.label ?? mode;
+}

 function scopeLabel(scope: AutoDownloadScope): string {
 	return SCOPE_LABELS.find((s) => s.value === scope)?.label ?? scope;
@@ -205,6 +215,79 @@ export function usePreferencesItems(): SettingItem[] {
 					autoJumpToPlayer: !prefs().autoJumpToPlayer,
 				}),
 		},
+		{
+			id: "episodeCacheMode",
+			label: "Episode Cache Mode",
+			kind: "select",
+			display: () => cacheModeLabel(prefs().episodeCacheMode),
+			help: () =>
+				`How the Feed and My Shows episode lists are bounded.\nDate: keep episodes from the last N days (see Cache Days below).\nCount: keep the N most recent episodes (see Cache Count below).\nFetch More always pages beyond this bound — these episodes are volatile and don't persist.\nType: select\nDefault: date\nCurrent: ${cacheModeLabel(prefs().episodeCacheMode)}\nCycle with j/k; Enter to apply.`,
+			cycle: (dir) => {
+				const idx = CACHE_MODE_LABELS.findIndex(
+					(s) => s.value === prefs().episodeCacheMode,
+				);
+				const next =
+					CACHE_MODE_LABELS[
+						(idx + dir + CACHE_MODE_LABELS.length) % CACHE_MODE_LABELS.length
+					].value;
+				app.updatePreferences({ episodeCacheMode: next });
+			},
+		},
+		{
+			id: "episodeCacheCount",
+			label: "Episode Cache Count",
+			kind: "number",
+			display: () =>
+				prefs().episodeCacheMode === "count"
+					? `${prefs().episodeCacheCount} eps`
+					: "(date mode)",
+			help: () =>
+				`Number of most-recent episodes to keep in the Feed/My Shows lists when mode is Count.\nType: number (any positive integer)\nDefault: 25\nCurrent: ${prefs().episodeCacheCount}\nj/k to −/+1 · Enter to type a value.`,
+			cycle: (dir) => {
+				const next = Math.max(1, prefs().episodeCacheCount + dir);
+				app.updatePreferences({ episodeCacheCount: next });
+			},
+			renderEditor: () => (
+				<NumberInputEditor
+					label="Episode Cache Count"
+					value={() => prefs().episodeCacheCount}
+					commit={(n) => {
+						app.updatePreferences({
+							episodeCacheCount: Math.max(1, n),
+						});
+					}}
+				/>
+			),
+		},
+		{
+			id: "episodeCacheDays",
+			label: "Episode Cache Days",
+			kind: "number",
+			display: () =>
+				prefs().episodeCacheMode === "date"
+					? `${prefs().episodeCacheDays} days`
+					: "(count mode)",
+			help: () =>
+				`Rolling window in days for the Feed/My Shows episode lists when mode is Date.\nType: number (1–365)\nDefault: 60\nCurrent: ${prefs().episodeCacheDays} days\nj/k to −/+5 · Enter to type a value.`,
+			cycle: (dir) => {
+				const next = Math.min(
+					365,
+					Math.max(1, prefs().episodeCacheDays + dir * 5),
+				);
+				app.updatePreferences({ episodeCacheDays: next });
+			},
+			renderEditor: () => (
+				<NumberInputEditor
+					label="Episode Cache Days"
+					value={() => prefs().episodeCacheDays}
+					commit={(n) => {
+						app.updatePreferences({
+							episodeCacheDays: Math.min(365, Math.max(1, n)),
+						});
+					}}
+				/>
+			),
+		},
 		{
 			id: "fetchMore",
 			label: "Fetch More",
--- a/src/stores/app.ts
+++ b/src/stores/app.ts
@@ -45,6 +45,9 @@ const defaultPreferences: UserPreferences = {
 	autoJumpToPlayer: true,
 	fetchMoreMode: "auto",
 	refreshIntervalMinutes: 30,
+	episodeCacheMode: "date",
+	episodeCacheCount: 25,
+	episodeCacheDays: 60,
 };

 const defaultState: AppState = {
--- a/src/stores/feed.ts
+++ b/src/stores/feed.ts
@@ -13,8 +13,9 @@ import { DEFAULT_SOURCES } from "../types/source";
 import { getRSSItems, parseRSSItem, parseChannelCoverUrl } from "../api/rss-parser";
 import { resolveItunesFeedUrl } from "../utils/itunes-feed-resolver";
 import { savePodcastIndexCredentials } from "../utils/source-credentials";
-import { mergeEpisodes } from "../utils/episode-merge";
+import { mergeEpisodesBounded } from "../utils/episode-merge";
 import {
+	episodeInWindow,
 	loadFeedsFromFile,
 	saveFeedsToFile,
 	loadSourcesFromFile,
@@ -31,11 +32,6 @@ const MAX_EPISODES_REFRESH = 50;
 /** Max episodes to fetch on initial subscribe */
 const MAX_EPISODES_SUBSCRIBE = 20;

-/** Per-feed bound on both the cached parse results and the merged in-memory
- *  window; 500 covers years of a weekly show's history while capping a
- *  20-subscription install at 10k episodes. */
-export const MAX_EPISODES_IN_MEMORY = 500;
-
 /** Per-feed fetch timeout — a hung feed must not stall a refresh batch or
 *  the background refresh loop. */
 const FETCH_TIMEOUT_MS = 20_000;
@@ -93,15 +89,42 @@ const parseEpisodesIncremental = async (
 	return episodes;
 };

-/** Cache of all parsed episodes per feed (feedId -> Episode[]) */
+/** Cache of ALL parsed episodes per feed (feedId -> Episode[]). Holds the
+ *  full parse — the bound (count or date) is applied when reading, not when
+ *  writing, so changing the preference takes effect without a refetch.
+ *  Fetch-more reads beyond the bound from this cache (volatile only — the
+ *  cache itself is never extended by fetch-more). */
 const fullEpisodeCache = new Map<string, Episode[]>();

-/** Track how many episodes are currently loaded per feed */
+/** Track how many episodes are currently loaded (visible) per feed. The
+ *  loaded window grows via fetch-more but never exceeds what the cache
+ *  holds — when it reaches the cache length, hasMoreEpisodes flips false. */
 const episodeLoadCount = new Map<string, number>();

-/** Save feeds to file (async, fire-and-forget) */
+/** Read the episode cache bound from preferences: a closure that decides
+ *  whether the episode at `index` (0 = newest, after sort) is kept. */
+function episodeKeepFn(prefs: {
+	episodeCacheMode: "date" | "count";
+	episodeCacheCount: number;
+	episodeCacheDays: number;
+}): (ep: Episode, index: number) => boolean {
+	const now = new Date();
+	if (prefs.episodeCacheMode === "count") {
+		const count = Math.max(1, prefs.episodeCacheCount);
+		return (_ep: Episode, index: number) => index < count;
+	}
+	const days = Math.max(1, prefs.episodeCacheDays);
+	return (ep: Episode) => episodeInWindow(ep, now, days);
+}
+
+/** Save feeds to file (async, fire-and-forget). */
 function saveFeeds(feeds: Feed[]): void {
-	saveFeedsToFile(feeds);
+	const prefs = useAppStore().state().preferences;
+	const days =
+		prefs.episodeCacheMode === "date"
+			? Math.max(1, prefs.episodeCacheDays)
+			: undefined;
+	saveFeedsToFile(feeds, days);
 }

 /** Save sources to file (async, fire-and-forget) */
@@ -325,13 +348,15 @@ function createFeedStore() {
 		);
 	};

-	/** Fetch latest episodes from an RSS feed URL, caching all parsed episodes.
-	 *  Returns NULL when the feed could not be fetched (network error, non-OK
-	/** Fetch latest episodes from an RSS feed URL, caching all parsed episodes.
-	 *  Also returns the channel-level artwork so callers can backfill a feed's
-	 *  coverUrl (subscribe + refresh). Null episodes on any failure — a
-	 *  failed fetch must not look like an empty feed, or the store would wipe
-	 *  a subscribed show's episodes. */
+	/** Fetch latest episodes from an RSS feed URL, caching ALL parsed
+	 *  episodes in fullEpisodeCache. The visible episodes returned are
+	 *  bounded by the user's cache preference (count or date); the full
+	 *  cache survives so fetch-more can page beyond the bound without a
+	 *  refetch (volatile only — the cache is never extended by fetch-more).
+	 *  Returns NULL episodes on any failure — a failed fetch must not look
+	 *  like an empty feed, or the store would wipe a subscribed show's
+	 *  episodes. Also returns the channel-level artwork so callers can
+	 *  backfill a feed's coverUrl (subscribe + refresh). */
 	const fetchEpisodes = async (
 		feedUrl: string,
 		limit: number,
@@ -356,14 +381,28 @@ function createFeedStore() {
 				await parseEpisodesIncremental(xml, feedUrl),
 			);

-			// Cache all parsed episodes for pagination
 			if (feedId) {
-				fullEpisodeCache.set(feedId, allEpisodes.slice(0, MAX_EPISODES_IN_MEMORY));
-				episodeLoadCount.set(feedId, Math.min(limit, allEpisodes.length));
+				// Cache the FULL parse — the bound is applied when reading,
+				// not when writing, so a preference change takes effect
+				// without a refetch.
+				fullEpisodeCache.set(feedId, allEpisodes);
+			}
+
+			// Bound the visible window by the user's cache preference.
+			const prefs = useAppStore().state().preferences;
+			const keep = episodeKeepFn(prefs);
+			const bounded = allEpisodes.filter((ep, i) => keep(ep, i));
+			const visible = bounded.slice(0, limit);
+
+			if (feedId) {
+				// Track how many episodes are visible — the bounded window,
+				// not the full parse. hasMoreEpisodes compares this to the
+				// full cache length to decide if fetch-more can page deeper.
+				episodeLoadCount.set(feedId, visible.length);
 			}

 			return {
-				episodes: allEpisodes.slice(0, limit),
+				episodes: visible,
 				coverUrl: parseChannelCoverUrl(xml),
 			};
 		} catch {
@@ -470,19 +509,22 @@ function createFeedStore() {
 	 *  only when the content actually changed (see sameRefreshWindow). The
 	 *  fetched window is MERGED into the existing episodes (fetched copy wins
 	 *  on id collision) so a refresh never shrinks the in-memory list; the
-	 *  union is capped at MAX_EPISODES_IN_MEMORY. Returns the ORIGINAL array
-	 *  reference when nothing changed so callers skip persistence entirely —
-	 *  a refresh that fetched identical episodes must not re-sort the
-	 *  "updated" view. */
+	 *  union is pruned by the user's cache bound (count or date) so episodes
+	 *  outside the bound fall out of the visible list on the next refresh.
+	 *  Returns the ORIGINAL array reference when nothing changed so callers
+	 *  skip persistence entirely — a refresh that fetched identical episodes
+	 *  must not re-sort the "updated" view. */
 	const applyRefreshedEpisodes = (
 		prev: Feed[],
 		feedId: string,
 		episodes: Episode[],
 	): Feed[] => {
 		let changed = false;
+		const prefs = useAppStore().state().preferences;
+		const keep = episodeKeepFn(prefs);
 		const updated = prev.map((f) => {
 			if (f.id !== feedId) return f;
-			const merged = mergeEpisodes(f.episodes, episodes, MAX_EPISODES_IN_MEMORY);
+			const merged = mergeEpisodesBounded(f.episodes, episodes, keep);
 			if (sameRefreshWindow(f.episodes, episodes)) return f;
 			changed = true;
 			return { ...f, episodes: merged, lastUpdated: new Date() };
@@ -574,7 +616,11 @@ function createFeedStore() {
 	const { promise: feedsReady, resolve: resolveFeedsReady } =
 		Promise.withResolvers<void>();
 	(async () => {
-		const loadedFeeds = await loadFeedsFromFile();
+		const loadedFeeds = await loadFeedsFromFile(
+			useAppStore().state().preferences.episodeCacheMode === "date"
+				? Math.max(1, useAppStore().state().preferences.episodeCacheDays)
+				: undefined,
+		);
 		if (loadedFeeds.length > 0) setFeeds(loadedFeeds);
 		resolveFeedsReady();
 		const loadedSources = await loadSourcesFromFile<PodcastSource>();
@@ -752,7 +798,12 @@ function createFeedStore() {
 		return id ? getFeed(id) : undefined;
 	};

-	/** Check if a feed has more episodes available beyond what's currently loaded */
+	/** Check if a feed has more episodes available beyond what's currently
+	 *  loaded. The full parse cache holds ALL episodes (including beyond the
+	 *  cache bound), so fetch-more can always page deeper — the bound limits
+	 *  what the Feed/My Shows list shows initially, not what fetch-more can
+	 *  reach. When the loaded window reaches the cache length, this flips
+	 *  false. */
 	const hasMoreEpisodes = (feedId: string): boolean => {
 		const cached = fullEpisodeCache.get(feedId);
 		if (!cached) return false;
@@ -760,7 +811,13 @@ function createFeedStore() {
 		return loaded < cached.length;
 	};

-	/** Load the next chunk of episodes for one feed from the cache.
+	/** Load the next chunk of episodes for one feed from the full parse
+	 *  cache — VOLATILE only: the episodes surfaced beyond the cache bound
+	 *  are held in the feed's in-memory episode list (so the user can browse
+	 *  them) but are NOT written back to fullEpisodeCache (the cache keeps
+	 *  its original bounded shape; these episodes vanish on the next
+	 *  refresh or restart). The cache is populated by fetchEpisodes/refresh;
+	 *  a cold cache (post-restart) triggers a refetch here.
 	 *  No global guard — callers own the `isLoadingMore` flag so batches
 	 *  (loadMoreAllFeeds) can loop over multiple feeds in one go. */
 	const loadMoreEpisodesForFeed = async (feedId: string) => {
@@ -769,7 +826,8 @@ function createFeedStore() {

 		let cached = fullEpisodeCache.get(feedId);

-		// If no cache, re-fetch and parse the full feed
+		// If no cache, re-fetch and parse the full feed (cold path after a
+		// restart). The cache holds the FULL parse — no bound applied here.
 		if (!cached) {
 			try {
 				const response = await fetch(feed.podcast.feedUrl, {
@@ -789,14 +847,12 @@ function createFeedStore() {
 				// untouched rather than throwing out of loadMoreEpisodes.
 				return;
 			}
-			// Cold-refetch parse output is unsorted; sort and cap it so the
-			// cache and the pagination window stay newest-first and bounded.
+			// Cold-refetch parse output is unsorted; sort it newest-first.
 			// Yield before the sync sort (the parse already yielded before
 			// this point, but the sort of potentially hundreds of episodes
 			// is its own sync block).
 			await yieldToUI();
 			cached = sortEpisodesReverseChronological(cached);
-			cached = cached.slice(0, MAX_EPISODES_IN_MEMORY);
 			fullEpisodeCache.set(feedId, cached);
 			// Set current load count to match what's already displayed
 			episodeLoadCount.set(feedId, feed.episodes.length);
@@ -810,6 +866,9 @@ function createFeedStore() {

 		if (newCount <= currentCount) return; // nothing more to load

+		// Advance the loaded window — volatile: the episodes beyond the cache
+		// bound are held in feed.episodes (visible) but the cache itself is
+		// NOT extended. episodeLoadCount tracks the volatile window size.
 		episodeLoadCount.set(feedId, newCount);
 		const episodes = cached.slice(0, newCount);

--- a/src/types/settings.ts
+++ b/src/types/settings.ts
@@ -96,6 +96,11 @@ export type FetchMoreMode = "manual" | "auto";
 /** Which shows the auto-download setting applies to (default: all). */
 export type AutoDownloadScope = "all" | "none" | "whitelist";

+/** How the episode cache (the Feed / My Shows list + the pagination cache)
+ *  is bounded: by a rolling date window or by a count of most-recent
+ *  episodes (default: date). */
+export type EpisodeCacheMode = "date" | "count";
+
 export type UserPreferences = {
 	showExplicit: boolean;
 	autoDownload: boolean;
@@ -111,6 +116,12 @@ export type UserPreferences = {
 	fetchMoreMode: FetchMoreMode;
 	/** Minutes between automatic background feed refreshes (default: 30). */
 	refreshIntervalMinutes: number;
+	/** How the episode list cache is bounded — by date or by count (default: date). */
+	episodeCacheMode: EpisodeCacheMode;
+	/** Number of most-recent episodes to keep when mode is "count" (default: 25). */
+	episodeCacheCount: number;
+	/** Rolling window in days for the episode list when mode is "date" (default: 60). */
+	episodeCacheDays: number;
 };

 export type AppState = {
--- a/src/utils/app-persistence.ts
+++ b/src/utils/app-persistence.ts
@@ -49,6 +49,9 @@ const defaultPreferences: UserPreferences = {
 	autoJumpToPlayer: true,
 	fetchMoreMode: "auto",
 	refreshIntervalMinutes: 30,
+	episodeCacheMode: "date",
+	episodeCacheCount: 25,
+	episodeCacheDays: 60,
 };

 const defaultState: AppState = {
--- a/src/utils/episode-merge.ts
+++ b/src/utils/episode-merge.ts
@@ -1,4 +1,4 @@
-import type { Episode } from "../types/episode"
+import type { Episode } from "../types/episode";

 /** Sort key for an episode's pubDate — missing/invalid dates sort as NEWEST
 *  (Infinity) so undated episodes float to the top instead of dropping into
@@ -10,17 +10,21 @@ const ts = (ep: Episode): number => {

 /**
 * Union of two episode lists keyed by id — on collision the fetched copy
- * wins (fresh metadata). Result is sorted newest-first by pubDate and capped
- * at `cap` entries (oldest dropped). Never mutates either input.
+ * wins (fresh metadata). Result is sorted newest-first by pubDate and pruned
+ * by the supplied `keep` predicate: episodes outside the configured cache
+ * bound (date window or count) are dropped. Never mutates either input.
+ *
+ * The caller supplies `keep` so this module stays free of the preference
+ * types — the feed store passes a closure bound to the user's mode/count/days.
 */
-export function mergeEpisodes(
+export function mergeEpisodesBounded(
  existing: Episode[],
  fetched: Episode[],
-  cap: number,
+  keep: (ep: Episode, index: number) => boolean,
 ): Episode[] {
  const byId = new Map<string, Episode>()
  for (const ep of existing) byId.set(ep.id, ep)
  for (const ep of fetched) byId.set(ep.id, ep)
  const sorted = [...byId.values()].sort((a, b) => ts(b) - ts(a))
-  return sorted.slice(0, cap)
+  return sorted.filter((ep, i) => keep(ep, i))
 }
--- a/src/utils/feeds-persistence.ts
+++ b/src/utils/feeds-persistence.ts
@@ -10,22 +10,35 @@ import type { Episode } from "../types/episode";
 import type { Feed } from "../types/feed";
 import type { PodcastSource } from "../types/source";

-/** Retention window for persisted episodes: older episodes are dropped when
- *  feeds are written to config.json unless they are completed downloads. */
-export const PERSISTED_WINDOW_DAYS = 30;
+/** Default episode lifecycle window in days — used when no preference is
+ *  configured (legacy configs, first launch). The actual bound is the user's
+ *  episodeCacheDays preference; this is just the fail-safe default. */
+export const DEFAULT_EPISODE_WINDOW_DAYS = 60;

-/** True when an episode may be persisted: it is a completed download, or its
- *  pubDate is missing/invalid (fail-safe: never drop an undatable episode),
- *  or it falls inside the retention window. */
+/** True when an episode falls inside a rolling date window of `days` days.
+ *  A missing/invalid pubDate is ALWAYS kept (fail-safe: never drop an
+ *  undatable episode) — the volatile cache must agree with
+ *  episodeIsPersistable so an episode the persistence layer retains can
+ *  never be silently pruned from the list. */
+export function episodeInWindow(
+	ep: Episode,
+	now: Date,
+	days: number = DEFAULT_EPISODE_WINDOW_DAYS,
+): boolean {
+	const t = ep.pubDate?.getTime();
+	if (!t || Number.isNaN(t)) return true;
+	return t >= now.getTime() - days * 24 * 3600 * 1000;
+}
+
+/** True when an episode may be persisted: a completed download, or it falls
+ *  inside the lifecycle window (undatable episodes always kept). */
 export function episodeIsPersistable(
 	ep: Episode,
 	downloadedIds: Set<string>,
 	now: Date,
+	days: number = DEFAULT_EPISODE_WINDOW_DAYS,
 ): boolean {
-	if (downloadedIds.has(ep.id)) return true;
-	const t = ep.pubDate?.getTime();
-	if (!t || Number.isNaN(t)) return true;
-	return t >= now.getTime() - PERSISTED_WINDOW_DAYS * 24 * 3600 * 1000;
+	return downloadedIds.has(ep.id) || episodeInWindow(ep, now, days);
 }

 /** Episode ids of completed downloads, read from downloads.json. In-flight
@@ -70,12 +83,13 @@ function reviveDates(feed: Feed): Feed {
 		})),
 	};
 }
-
 /** Load feeds from config.json, pruning episodes outside the retention
 *  window (completed downloads always kept). When anything was pruned, the
 *  pruned list is rewritten to config.json (startup cleanup for legacy
 *  configs). The read path is awaited so the returned value is deterministic. */
-export async function loadFeedsFromFile(): Promise<Feed[]> {
+export async function loadFeedsFromFile(
+	windowDays?: number,
+): Promise<Feed[]> {
 	try {
 		const cfg = await loadConfig();
 		if (!Array.isArray(cfg.feeds)) return [];
@@ -85,14 +99,14 @@ export async function loadFeedsFromFile(): Promise<Feed[]> {
 		let prunedAny = false;
 		const pruned = feeds.map((f) => {
 			const kept = f.episodes.filter((ep) =>
-				episodeIsPersistable(ep, downloadedIds, now),
+				episodeIsPersistable(ep, downloadedIds, now, windowDays),
 			);
 			if (kept.length !== f.episodes.length) prunedAny = true;
 			return { ...f, episodes: kept };
 		});
 		if (prunedAny) {
 			// Fire-and-forget cleanup rewrite of the legacy config.
-			saveFeedsToFile(pruned);
+			saveFeedsToFile(pruned, windowDays);
 		}
 		return pruned;
 	} catch {
@@ -104,14 +118,14 @@ export async function loadFeedsFromFile(): Promise<Feed[]> {
 *  (completed downloads always kept). Fire-and-forget: the prune reads
 *  downloads.json asynchronously, then enqueues the write. On any error the
 *  UNPRUNED feeds are saved instead, so data is never lost. */
-export function saveFeedsToFile(feeds: Feed[]): void {
+export function saveFeedsToFile(feeds: Feed[], windowDays?: number): void {
 	(async () => {
 		try {
 			const downloadedIds = await readDownloadedEpisodeIds();
 			const pruned = feeds.map((f) => ({
 				...f,
 				episodes: f.episodes.filter((ep) =>
-					episodeIsPersistable(ep, downloadedIds, new Date()),
+					episodeIsPersistable(ep, downloadedIds, new Date(), windowDays),
 				),
 			}));
 			updateConfig({ feeds: pruned });
@@ -120,7 +134,6 @@ export function saveFeedsToFile(feeds: Feed[]): void {
 		}
 	})().catch(() => {});
 }
-
 /** Load sources from config.json */
 export async function loadSourcesFromFile<T>(): Promise<T[] | null> {
 	try {
@@ -131,7 +144,6 @@ export async function loadSourcesFromFile<T>(): Promise<T[] | null> {
 		return null;
 	}
 }
-
 /** Save sources to config.json */
 export function saveSourcesToFile<T>(sources: T[]): void {
 	updateConfig({ sources: sources as unknown as PodcastSource[] });