fix(jellyfin): show overlay, inject plugin, and fix stats title on playback (#77)

* fix(jellyfin): show overlay, inject plugin, and fix stats title on playb

- Show visible overlay automatically during Jellyfin playback so subtitleStyle applies
- Inject bundled mpv plugin on auto-launch so keybindings work without overlay focus
- Group Jellyfin playback stats under item metadata (jellyfin://host/item/id) instead of stream URLs so episodes merge with matching local titles
- Mark ffsubsync unavailable in subsync modal for remote media paths
- Drain queued second-instance commands even when onReady throws

* fix(overlay): stabilize macOS focus handoff and sidebar Yomitan pause

- Keep overlay visible during macOS foreground probe after overlay blur
- Hold sidebar hover-pause while a Yomitan lookup popup remains open

* fix(jellyfin): fix discovery loop, device identity, tray state, and Disc

- Derive device identity from OS hostname; remove legacy configurable client/device fields
- Prevent discovery playback from reloading active item, misreporting pause state, and duplicate overlay restores
- Restart stale tray discovery sessions without re-login when server drops SubMiner cast target
- Sync tray discovery checkbox state on Linux after CLI/startup/remote-session changes
- Stop Discord presence falling back to stream URLs; prime title before tokenized stream loads
- Fix picker library discovery when log level is above info
- Fix config.example.jsonc trailing commas and array formatting

* docs(release): trim and consolidate prerelease notes for 0.15.0

- Remove breaking changes section and several redundant bullet points
- Consolidate per-platform updater notes into a single entry
- Normalize em-dash separators to hyphens in section headers

* fix(config): remove trailing commas from config.example.jsonc

- Strip trailing commas throughout both config.example.jsonc copies
- Reformat inline arrays to multi-line for JSON strictness
- Update Jellyfin subtitle preload and playback launch tests and impl

* fix(tokenizer): preserve known-word highlight when POS filters suppress

- Known-word cache matches now set isKnown=true even for tokens excluded by POS filters
- POS exclusion gate suppresses N+1, frequency, and JLPT only; known status is computed before the gate
- Jellyfin subtitle preload continues after cleanup failures instead of aborting
- Update config docs and option description to document the known-word bypass behavior

* fix(jellyfin): send explicit hide/show overlay instead of toggle

- Track overlay visibility in plugin state; y-t uses explicit hide/show commands when state is known
- Prevent paused Jellyfin playback from resuming on overlay hide
- Fix subtitle cache cleanup to only remove dirs after successful cleanup

* fix(jellyfin): fix remote progress sync, seek reporting, and startup sto

- arm active playback before loadfile with loadedMediaPath: null to suppress premature stop events
- force immediate progress report on seek-like position jumps at the mpv time-pos level
- send positionTicks and failed=false in reportStopped payload
- remove EventName from HTTP timeline payloads (websocket-only field)
- add startup grace window to drop stop events before media finishes loading

* fix(jellyfin): fix overlay toggle sync, redirect reload, and AppImage bi

- Sync visible-overlay state back to plugin via script messages to avoid toggle/hide drift
- Collapse duplicate toggle events within 250ms to prevent hide-then-show on single keypress
- Preserve manual hide across Jellyfin path-changing redirects even when media-title drops
- Rearm managed subtitle defaults on path-changing redirects
- Route toggleVisibleOverlay session binding through plugin toggle instead of app-side IPC
- Show Linux/Hyprland overlay passively (showInactive) to avoid stealing mpv keyboard focus
- Fix AppImage binary resolution to prefer $APPIMAGE env over mounted inner binary
- Add stats window layer management so delete/update dialogs appear above stats window
- Fix Jellyfin remote progress sync during Linux websocket reconnect windows

* Fix CodeRabbit review feedback

* fix(jellyfin): subtitle timing, resume progress, and overlay sync

- Add per-stream subtitle delay persistence and auto timeline-offset correction
- Strip server-selected subtitle stream from mpv load URL; suppress plugin subtitle rearm and auto-start during app-managed preload
- Fix resume position lost when mpv resets on stop; use last known position for final progress/stopped reports
- Keep Play vs Resume distinct to avoid early seek race on normal play
- Fix discovery resume when remote play sends StartPositionTicks=0 despite saved progress
- Deduplicate show/hide overlay commands using recorded visibility state
- Rewrite docs-site Jellyfin page around cast-to-device UX

* test: update lifecycle cleanup assertion

* fix: clear aborted playback state, fix overlay passthrough, and guard du

- Reset app_managed_playback_pending on lifecycle cleanup to prevent state leak into next item
- Record visible overlay action only after command succeeds, not before
- Non-native passive overlay now always click-through on re-show (fix isNonNativePassiveOverlay ordering)
- Defer activeParsedSubtitleMediaPath assignment until after prefetch completes
- Move autoplay gate release into the hide branch of toggleVisibleOverlay
- Clear active Jellyfin playback when stopping media that never loaded
- Reset managed subtitle delay and delay key when no external tracks are available
- Await async removeDir in subtitle cache cleanup
- Guard duplicate delete clicks in MediaDetailView and SessionsTab with refs
- Escape key in DeleteConfirmDialog now calls stopPropagation and stopImmediatePropagation

stats/src/App.tsx

@@ -1,4 +1,5 @@
 import { Suspense, lazy, useCallback, useState } from 'react';
+import { DeleteConfirmDialog } from './components/layout/DeleteConfirmDialog';
 import { TabBar } from './components/layout/TabBar';
 import { OverviewTab } from './components/overview/OverviewTab';
 import { useExcludedWords } from './hooks/useExcludedWords';
@@ -272,6 +273,7 @@ export function App() {
           />
         </Suspense>
       ) : null}
+      <DeleteConfirmDialog />
     </div>
   );
 }

stats/src/components/anime/EpisodeDetail.tsx

@@ -85,7 +85,7 @@ export function EpisodeDetail({ videoId, onSessionDeleted }: EpisodeDetailProps)
   }, [videoId]);
 
   const handleDeleteSession = async (sessionId: number) => {
-    if (!confirmSessionDelete()) return;
+    if (!(await confirmSessionDelete())) return;
     await apiClient.deleteSession(sessionId);
     setData((prev) => {
       if (!prev) return prev;

stats/src/components/anime/EpisodeList.tsx

@@ -44,7 +44,7 @@ export function EpisodeList({
   };
 
   const handleDeleteEpisode = async (videoId: number, title: string) => {
-    if (!confirmEpisodeDelete(title)) return;
+    if (!(await confirmEpisodeDelete(title))) return;
     await apiClient.deleteVideo(videoId);
     setEpisodes((prev) => prev.filter((ep) => ep.videoId !== videoId));
     if (expandedVideoId === videoId) setExpandedVideoId(null);

stats/src/components/layout/DeleteConfirmDialog.test.tsx

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+
+test('delete confirmation dialog swallows Escape before closing', () => {
+  const source = fs.readFileSync(
+    path.join(process.cwd(), 'stats/src/components/layout/DeleteConfirmDialog.tsx'),
+    'utf8',
+  );
+  const handlerBlock = source.match(
+    /const onKeyDown = \(event: KeyboardEvent\) => \{(?<body>[\s\S]*?)\n    \};/,
+  )?.groups?.body;
+
+  assert.ok(handlerBlock);
+  assert.match(handlerBlock, /event\.preventDefault\(\);/);
+  assert.match(handlerBlock, /event\.stopPropagation\(\);/);
+  assert.match(handlerBlock, /event\.stopImmediatePropagation\(\);/);
+  assert.ok(
+    handlerBlock.indexOf('event.stopPropagation();') < handlerBlock.indexOf('finish(false);'),
+  );
+});

stats/src/components/layout/DeleteConfirmDialog.tsx

@@ -0,0 +1,96 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { setDeleteConfirmPresenter } from '../../lib/delete-confirm';
+
+interface PendingDeleteConfirm {
+  message: string;
+  resolve: (confirmed: boolean) => void;
+}
+
+export function DeleteConfirmDialog() {
+  const [pendingConfirm, setPendingConfirm] = useState<PendingDeleteConfirm | null>(null);
+  const pendingRef = useRef<PendingDeleteConfirm | null>(null);
+  const cancelButtonRef = useRef<HTMLButtonElement>(null);
+
+  const finish = useCallback((confirmed: boolean) => {
+    const pending = pendingRef.current;
+    pendingRef.current = null;
+    setPendingConfirm(null);
+    pending?.resolve(confirmed);
+  }, []);
+
+  useEffect(() => {
+    return setDeleteConfirmPresenter(
+      (message) =>
+        new Promise<boolean>((resolve) => {
+          pendingRef.current?.resolve(false);
+          const next = { message, resolve };
+          pendingRef.current = next;
+          setPendingConfirm(next);
+        }),
+    );
+  }, []);
+
+  useEffect(() => {
+    if (!pendingConfirm) return;
+    cancelButtonRef.current?.focus();
+  }, [pendingConfirm]);
+
+  useEffect(() => {
+    if (!pendingConfirm) return;
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key !== 'Escape') return;
+      event.preventDefault();
+      event.stopPropagation();
+      event.stopImmediatePropagation();
+      finish(false);
+    };
+    window.addEventListener('keydown', onKeyDown, true);
+    return () => window.removeEventListener('keydown', onKeyDown, true);
+  }, [finish, pendingConfirm]);
+
+  useEffect(() => {
+    return () => {
+      pendingRef.current?.resolve(false);
+      pendingRef.current = null;
+    };
+  }, []);
+
+  if (!pendingConfirm) return null;
+
+  return (
+    <div className="fixed inset-0 z-[2147483647] flex items-center justify-center bg-ctp-crust/55 p-4 backdrop-blur-sm">
+      <div
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="delete-confirm-title"
+        className="w-full max-w-md rounded-lg border border-ctp-surface1 bg-ctp-mantle shadow-2xl"
+      >
+        <div className="border-b border-ctp-surface1 px-4 py-3">
+          <h2 id="delete-confirm-title" className="text-sm font-semibold text-ctp-text">
+            Delete?
+          </h2>
+        </div>
+        <div className="px-4 py-4 text-sm leading-6 text-ctp-subtext0">
+          {pendingConfirm.message}
+        </div>
+        <div className="grid grid-cols-2 border-t border-ctp-surface1">
+          <button
+            ref={cancelButtonRef}
+            type="button"
+            onClick={() => finish(false)}
+            className="border-r border-ctp-surface1 px-4 py-3 text-sm text-ctp-subtext0 transition-colors hover:bg-ctp-surface0 hover:text-ctp-text focus:outline-none focus:bg-ctp-surface0 focus:text-ctp-text"
+          >
+            Cancel
+          </button>
+          <button
+            type="button"
+            onClick={() => finish(true)}
+            className="px-4 py-3 text-sm font-semibold text-ctp-red transition-colors hover:bg-ctp-surface0 focus:outline-none focus:bg-ctp-surface0"
+          >
+            Delete
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

stats/src/components/library/MediaDetailView.test.tsx

@@ -125,3 +125,40 @@ test('buildDeleteEpisodeHandler sets error when deleteVideo throws', async () =>
   await handler();
   assert.equal(capturedError, 'Network failure');
 });
+
+test('buildDeleteEpisodeHandler guards duplicate clicks while confirmation is pending', async () => {
+  const confirmResolvers: Array<(value: boolean) => void> = [];
+  let confirmCalls = 0;
+  let deleteCalls = 0;
+  const isDeletingRef = { current: false };
+
+  const handler = buildDeleteEpisodeHandler({
+    videoId: 42,
+    title: 'Test Episode',
+    apiClient: {
+      deleteVideo: async () => {
+        deleteCalls += 1;
+      },
+    },
+    confirmFn: () => {
+      confirmCalls += 1;
+      return new Promise<boolean>((resolve) => {
+        confirmResolvers.push(resolve);
+      });
+    },
+    onBack: () => {},
+    setDeleteError: () => {},
+    isDeletingRef,
+  });
+
+  const first = handler();
+  const second = handler();
+  for (const resolveConfirm of confirmResolvers) {
+    resolveConfirm(true);
+  }
+  await Promise.all([first, second]);
+
+  assert.equal(confirmCalls, 1);
+  assert.equal(deleteCalls, 1);
+  assert.equal(isDeletingRef.current, false);
+});

stats/src/components/library/MediaDetailView.tsx

@@ -11,7 +11,7 @@ interface DeleteEpisodeHandlerOptions {
   videoId: number;
   title: string;
   apiClient: { deleteVideo: (id: number) => Promise<void> };
-  confirmFn: (title: string) => boolean;
+  confirmFn: (title: string) => boolean | Promise<boolean>;
   onBack: () => void;
   setDeleteError: (msg: string | null) => void;
   /**
@@ -27,8 +27,19 @@ interface DeleteEpisodeHandlerOptions {
 export function buildDeleteEpisodeHandler(opts: DeleteEpisodeHandlerOptions): () => Promise<void> {
   return async () => {
     if (opts.isDeletingRef?.current) return;
-    if (!opts.confirmFn(opts.title)) return;
     if (opts.isDeletingRef) opts.isDeletingRef.current = true;
+    let confirmed = false;
+    try {
+      confirmed = await opts.confirmFn(opts.title);
+    } catch (err) {
+      if (opts.isDeletingRef) opts.isDeletingRef.current = false;
+      opts.setDeleteError(err instanceof Error ? err.message : 'Failed to confirm delete.');
+      return;
+    }
+    if (!confirmed) {
+      if (opts.isDeletingRef) opts.isDeletingRef.current = false;
+      return;
+    }
     opts.setIsDeleting?.(true);
     opts.setDeleteError(null);
     try {
@@ -73,6 +84,7 @@ export function MediaDetailView({
   const [deletingSessionId, setDeletingSessionId] = useState<number | null>(null);
   const [isDeletingEpisode, setIsDeletingEpisode] = useState(false);
   const isDeletingEpisodeRef = useRef(false);
+  const isDeletingSessionRef = useRef(false);
 
   useEffect(() => {
     setLocalSessions(data?.sessions ?? null);
@@ -101,7 +113,20 @@ export function MediaDetailView({
   const relatedCollectionLabel = getRelatedCollectionLabel(detail);
 
   const handleDeleteSession = async (session: SessionSummary) => {
-    if (!confirmSessionDelete()) return;
+    if (isDeletingSessionRef.current) return;
+    isDeletingSessionRef.current = true;
+    let confirmed = false;
+    try {
+      confirmed = await confirmSessionDelete();
+    } catch (err) {
+      setDeleteError(err instanceof Error ? err.message : 'Failed to confirm delete.');
+      isDeletingSessionRef.current = false;
+      return;
+    }
+    if (!confirmed) {
+      isDeletingSessionRef.current = false;
+      return;
+    }
 
     setDeleteError(null);
     setDeletingSessionId(session.sessionId);
@@ -114,6 +139,7 @@ export function MediaDetailView({
       setDeleteError(err instanceof Error ? err.message : 'Failed to delete session.');
     } finally {
       setDeletingSessionId(null);
+      isDeletingSessionRef.current = false;
     }
   };
 

stats/src/components/overview/OverviewTab.tsx

@@ -47,7 +47,7 @@ export function OverviewTab({ onNavigateToMediaDetail, onNavigateToSession }: Ov
   }, []);
 
   const handleDeleteSession = async (session: SessionSummary) => {
-    if (!confirmSessionDelete()) return;
+    if (!(await confirmSessionDelete())) return;
     setDeleteError(null);
     setDeletingIds((prev) => new Set(prev).add(session.sessionId));
     try {
@@ -65,7 +65,7 @@ export function OverviewTab({ onNavigateToMediaDetail, onNavigateToSession }: Ov
   };
 
   const handleDeleteDayGroup = async (dayLabel: string, daySessions: SessionSummary[]) => {
-    if (!confirmDayGroupDelete(dayLabel, daySessions.length)) return;
+    if (!(await confirmDayGroupDelete(dayLabel, daySessions.length))) return;
     setDeleteError(null);
     const ids = daySessions.map((s) => s.sessionId);
     setDeletingIds((prev) => {
@@ -91,7 +91,7 @@ export function OverviewTab({ onNavigateToMediaDetail, onNavigateToSession }: Ov
   const handleDeleteAnimeGroup = async (groupSessions: SessionSummary[]) => {
     const title =
       groupSessions[0]?.animeTitle ?? groupSessions[0]?.canonicalTitle ?? 'Unknown Media';
-    if (!confirmAnimeGroupDelete(title, groupSessions.length)) return;
+    if (!(await confirmAnimeGroupDelete(title, groupSessions.length))) return;
     setDeleteError(null);
     const ids = groupSessions.map((s) => s.sessionId);
     setDeletingIds((prev) => {

stats/src/components/sessions/SessionsTab.test.tsx

@@ -125,6 +125,34 @@ test('buildBucketDeleteHandler reports errors via onError without calling onSucc
   assert.equal(successCalled, false);
 });
 
+test('buildBucketDeleteHandler reports confirmation errors via onError', async () => {
+  let errorMessage: string | null = null;
+  let deleteCalled = false;
+
+  const bucket = makeBucket([makeSession({ sessionId: 1 }), makeSession({ sessionId: 2 })]);
+
+  const handler = buildBucketDeleteHandler({
+    bucket,
+    apiClient: {
+      deleteSessions: async () => {
+        deleteCalled = true;
+      },
+    },
+    confirm: async () => {
+      throw new Error('confirm failed');
+    },
+    onSuccess: () => {},
+    onError: (message) => {
+      errorMessage = message;
+    },
+  });
+
+  await handler();
+
+  assert.equal(errorMessage, 'confirm failed');
+  assert.equal(deleteCalled, false);
+});
+
 test('buildBucketDeleteHandler falls back to a generic title when canonicalTitle is null', async () => {
   let seenTitle: string | null = null;
 

stats/src/components/sessions/SessionsTab.tsx

@@ -27,7 +27,7 @@ function groupSessionsByDay(sessions: SessionSummary[]): Map<string, SessionSumm
 export interface BucketDeleteDeps {
   bucket: SessionBucket;
   apiClient: { deleteSessions: (ids: number[]) => Promise<void> };
-  confirm: (title: string, count: number) => boolean;
+  confirm: (title: string, count: number) => boolean | Promise<boolean>;
   onSuccess: (deletedIds: number[]) => void;
   onError: (message: string) => void;
 }
@@ -43,8 +43,8 @@ export function buildBucketDeleteHandler(deps: BucketDeleteDeps): () => Promise<
   return async () => {
     const title = bucket.representativeSession.canonicalTitle ?? 'this episode';
     const ids = bucket.sessions.map((s) => s.sessionId);
-    if (!confirm(title, ids.length)) return;
     try {
+      if (!(await confirm(title, ids.length))) return;
       await client.deleteSessions(ids);
       onSuccess(ids);
     } catch (err) {
@@ -120,7 +120,14 @@ export function SessionsTab({
   };
 
   const handleDeleteSession = async (session: SessionSummary) => {
-    if (!confirmSessionDelete()) return;
+    let confirmed = false;
+    try {
+      confirmed = await confirmSessionDelete();
+    } catch (err) {
+      setDeleteError(err instanceof Error ? err.message : 'Failed to confirm delete.');
+      return;
+    }
+    if (!confirmed) return;
 
     setDeleteError(null);
     setDeletingSessionId(session.sessionId);

stats/src/lib/delete-confirm.test.ts

@@ -5,9 +5,10 @@ import {
   confirmDayGroupDelete,
   confirmEpisodeDelete,
   confirmSessionDelete,
+  setDeleteConfirmPresenter,
 } from './delete-confirm';
 
-test('confirmSessionDelete uses the shared session delete warning copy', () => {
+test('confirmSessionDelete uses the shared session delete warning copy', async () => {
   const calls: string[] = [];
   const originalConfirm = globalThis.confirm;
   globalThis.confirm = ((message?: string) => {
@@ -16,14 +17,183 @@ test('confirmSessionDelete uses the shared session delete warning copy', () => {
   }) as typeof globalThis.confirm;
 
   try {
-    assert.equal(confirmSessionDelete(), true);
+    assert.equal(await confirmSessionDelete(), true);
     assert.deepEqual(calls, ['Delete this session and all associated data?']);
   } finally {
     globalThis.confirm = originalConfirm;
   }
 });
 
-test('confirmDayGroupDelete includes the day label and count in the warning copy', () => {
+test('confirmSessionDelete suspends stats overlay layering around native confirm', async () => {
+  const calls: string[] = [];
+  const originalConfirm = globalThis.confirm;
+  const originalElectronAPI = (
+    globalThis as typeof globalThis & {
+      electronAPI?: {
+        stats?: {
+          beginNativeDialog?: () => void;
+          endNativeDialog?: () => void;
+        };
+      };
+    }
+  ).electronAPI;
+  (
+    globalThis as typeof globalThis & {
+      electronAPI?: {
+        stats?: {
+          beginNativeDialog?: () => void;
+          endNativeDialog?: () => void;
+        };
+      };
+    }
+  ).electronAPI = {
+    stats: {
+      beginNativeDialog: () => calls.push('begin-native-dialog'),
+      endNativeDialog: () => calls.push('end-native-dialog'),
+    },
+  };
+  globalThis.confirm = ((message?: string) => {
+    calls.push(`confirm:${message ?? ''}`);
+    return true;
+  }) as typeof globalThis.confirm;
+
+  try {
+    assert.equal(await confirmSessionDelete(), true);
+    assert.deepEqual(calls, [
+      'begin-native-dialog',
+      'confirm:Delete this session and all associated data?',
+      'end-native-dialog',
+    ]);
+  } finally {
+    globalThis.confirm = originalConfirm;
+    (
+      globalThis as typeof globalThis & {
+        electronAPI?: {
+          stats?: {
+            beginNativeDialog?: () => void;
+            endNativeDialog?: () => void;
+          };
+        };
+      }
+    ).electronAPI = originalElectronAPI;
+  }
+});
+
+test('confirmSessionDelete uses parented Electron confirm when available', async () => {
+  const calls: string[] = [];
+  const originalConfirm = globalThis.confirm;
+  const originalElectronAPI = (
+    globalThis as typeof globalThis & {
+      electronAPI?: {
+        stats?: {
+          confirmNativeDialog?: (message: string) => boolean;
+          beginNativeDialog?: () => void;
+          endNativeDialog?: () => void;
+        };
+      };
+    }
+  ).electronAPI;
+  (
+    globalThis as typeof globalThis & {
+      electronAPI?: {
+        stats?: {
+          confirmNativeDialog?: (message: string) => boolean;
+          beginNativeDialog?: () => void;
+          endNativeDialog?: () => void;
+        };
+      };
+    }
+  ).electronAPI = {
+    stats: {
+      confirmNativeDialog: (message) => {
+        calls.push(`native-confirm:${message}`);
+        return false;
+      },
+      beginNativeDialog: () => calls.push('begin-native-dialog'),
+      endNativeDialog: () => calls.push('end-native-dialog'),
+    },
+  };
+  globalThis.confirm = ((message?: string) => {
+    calls.push(`browser-confirm:${message ?? ''}`);
+    return true;
+  }) as typeof globalThis.confirm;
+
+  try {
+    assert.equal(await confirmSessionDelete(), false);
+    assert.deepEqual(calls, ['native-confirm:Delete this session and all associated data?']);
+  } finally {
+    globalThis.confirm = originalConfirm;
+    (
+      globalThis as typeof globalThis & {
+        electronAPI?: {
+          stats?: {
+            confirmNativeDialog?: (message: string) => boolean;
+            beginNativeDialog?: () => void;
+            endNativeDialog?: () => void;
+          };
+        };
+      }
+    ).electronAPI = originalElectronAPI;
+  }
+});
+
+test('confirmSessionDelete uses the registered stats presenter before native or browser confirm', async () => {
+  const calls: string[] = [];
+  const originalConfirm = globalThis.confirm;
+  const originalElectronAPI = (
+    globalThis as typeof globalThis & {
+      electronAPI?: {
+        stats?: {
+          confirmNativeDialog?: (message: string) => boolean;
+        };
+      };
+    }
+  ).electronAPI;
+  (
+    globalThis as typeof globalThis & {
+      electronAPI?: {
+        stats?: {
+          confirmNativeDialog?: (message: string) => boolean;
+        };
+      };
+    }
+  ).electronAPI = {
+    stats: {
+      confirmNativeDialog: (message) => {
+        calls.push(`native-confirm:${message}`);
+        return true;
+      },
+    },
+  };
+  globalThis.confirm = ((message?: string) => {
+    calls.push(`browser-confirm:${message ?? ''}`);
+    return true;
+  }) as typeof globalThis.confirm;
+
+  const unregister = setDeleteConfirmPresenter(async (message) => {
+    calls.push(`presenter:${message}`);
+    return false;
+  });
+
+  try {
+    assert.equal(await confirmSessionDelete(), false);
+    assert.deepEqual(calls, ['presenter:Delete this session and all associated data?']);
+  } finally {
+    unregister();
+    globalThis.confirm = originalConfirm;
+    (
+      globalThis as typeof globalThis & {
+        electronAPI?: {
+          stats?: {
+            confirmNativeDialog?: (message: string) => boolean;
+          };
+        };
+      }
+    ).electronAPI = originalElectronAPI;
+  }
+});
+
+test('confirmDayGroupDelete includes the day label and count in the warning copy', async () => {
   const calls: string[] = [];
   const originalConfirm = globalThis.confirm;
   globalThis.confirm = ((message?: string) => {
@@ -32,14 +202,14 @@ test('confirmDayGroupDelete includes the day label and count in the warning copy
   }) as typeof globalThis.confirm;
 
   try {
-    assert.equal(confirmDayGroupDelete('Today', 3), true);
+    assert.equal(await confirmDayGroupDelete('Today', 3), true);
     assert.deepEqual(calls, ['Delete all 3 sessions from Today and all associated data?']);
   } finally {
     globalThis.confirm = originalConfirm;
   }
 });
 
-test('confirmDayGroupDelete uses singular for one session', () => {
+test('confirmDayGroupDelete uses singular for one session', async () => {
   const calls: string[] = [];
   const originalConfirm = globalThis.confirm;
   globalThis.confirm = ((message?: string) => {
@@ -48,14 +218,14 @@ test('confirmDayGroupDelete uses singular for one session', () => {
   }) as typeof globalThis.confirm;
 
   try {
-    assert.equal(confirmDayGroupDelete('Yesterday', 1), true);
-    assert.deepEqual(calls, ['Delete all 1 session from Yesterday and all associated data?']);
+    assert.equal(await confirmDayGroupDelete('Yesterday', 1), true);
+    assert.deepEqual(calls, ['Delete this session from Yesterday and all associated data?']);
   } finally {
     globalThis.confirm = originalConfirm;
   }
 });
 
-test('confirmBucketDelete asks about merging multiple sessions of the same episode', () => {
+test('confirmBucketDelete asks about merging multiple sessions of the same episode', async () => {
   const calls: string[] = [];
   const originalConfirm = globalThis.confirm;
   globalThis.confirm = ((message?: string) => {
@@ -64,7 +234,7 @@ test('confirmBucketDelete asks about merging multiple sessions of the same episo
   }) as typeof globalThis.confirm;
 
   try {
-    assert.equal(confirmBucketDelete('My Episode', 3), true);
+    assert.equal(await confirmBucketDelete('My Episode', 3), true);
     assert.deepEqual(calls, [
       'Delete all 3 sessions of "My Episode" from this day and all associated data?',
     ]);
@@ -73,7 +243,7 @@ test('confirmBucketDelete asks about merging multiple sessions of the same episo
   }
 });
 
-test('confirmBucketDelete uses a clean singular form for one session', () => {
+test('confirmBucketDelete uses a clean singular form for one session', async () => {
   const calls: string[] = [];
   const originalConfirm = globalThis.confirm;
   globalThis.confirm = ((message?: string) => {
@@ -82,7 +252,7 @@ test('confirmBucketDelete uses a clean singular form for one session', () => {
   }) as typeof globalThis.confirm;
 
   try {
-    assert.equal(confirmBucketDelete('Solo Episode', 1), false);
+    assert.equal(await confirmBucketDelete('Solo Episode', 1), false);
     assert.deepEqual(calls, [
       'Delete this session of "Solo Episode" from this day and all associated data?',
     ]);
@@ -91,7 +261,7 @@ test('confirmBucketDelete uses a clean singular form for one session', () => {
   }
 });
 
-test('confirmEpisodeDelete includes the episode title in the shared warning copy', () => {
+test('confirmEpisodeDelete includes the episode title in the shared warning copy', async () => {
   const calls: string[] = [];
   const originalConfirm = globalThis.confirm;
   globalThis.confirm = ((message?: string) => {
@@ -100,7 +270,7 @@ test('confirmEpisodeDelete includes the episode title in the shared warning copy
   }) as typeof globalThis.confirm;
 
   try {
-    assert.equal(confirmEpisodeDelete('Episode 4'), false);
+    assert.equal(await confirmEpisodeDelete('Episode 4'), false);
     assert.deepEqual(calls, ['Delete "Episode 4" and all its sessions?']);
   } finally {
     globalThis.confirm = originalConfirm;

stats/src/lib/delete-confirm.ts

@@ -1,30 +1,76 @@
-export function confirmSessionDelete(): boolean {
-  return globalThis.confirm('Delete this session and all associated data?');
+type NativeDialogBridge = {
+  electronAPI?: {
+    stats?: {
+      confirmNativeDialog?: (message: string) => boolean;
+      beginNativeDialog?: () => void;
+      endNativeDialog?: () => void;
+    };
+  };
+};
+
+type DeleteConfirmPresenter = (message: string) => boolean | Promise<boolean>;
+
+let deleteConfirmPresenter: DeleteConfirmPresenter | null = null;
+
+export function setDeleteConfirmPresenter(presenter: DeleteConfirmPresenter): () => void {
+  deleteConfirmPresenter = presenter;
+  return () => {
+    if (deleteConfirmPresenter === presenter) {
+      deleteConfirmPresenter = null;
+    }
+  };
 }
 
-export function confirmDayGroupDelete(dayLabel: string, count: number): boolean {
-  return globalThis.confirm(
-    `Delete all ${count} session${count === 1 ? '' : 's'} from ${dayLabel} and all associated data?`,
+async function confirmWithStatsNativeDialogLayer(message: string): Promise<boolean> {
+  if (deleteConfirmPresenter) {
+    return deleteConfirmPresenter(message);
+  }
+
+  const statsApi = (globalThis as typeof globalThis & NativeDialogBridge).electronAPI?.stats;
+  if (statsApi?.confirmNativeDialog) {
+    return statsApi.confirmNativeDialog(message);
+  }
+
+  statsApi?.beginNativeDialog?.();
+  try {
+    return globalThis.confirm(message);
+  } finally {
+    statsApi?.endNativeDialog?.();
+  }
+}
+
+export function confirmSessionDelete(): Promise<boolean> {
+  return confirmWithStatsNativeDialogLayer('Delete this session and all associated data?');
+}
+
+export function confirmDayGroupDelete(dayLabel: string, count: number): Promise<boolean> {
+  if (count === 1) {
+    return confirmWithStatsNativeDialogLayer(
+      `Delete this session from ${dayLabel} and all associated data?`,
+    );
+  }
+  return confirmWithStatsNativeDialogLayer(
+    `Delete all ${count} sessions from ${dayLabel} and all associated data?`,
   );
 }
 
-export function confirmAnimeGroupDelete(title: string, count: number): boolean {
-  return globalThis.confirm(
+export function confirmAnimeGroupDelete(title: string, count: number): Promise<boolean> {
+  return confirmWithStatsNativeDialogLayer(
     `Delete all ${count} session${count === 1 ? '' : 's'} for "${title}" and all associated data?`,
   );
 }
 
-export function confirmEpisodeDelete(title: string): boolean {
-  return globalThis.confirm(`Delete "${title}" and all its sessions?`);
+export function confirmEpisodeDelete(title: string): Promise<boolean> {
+  return confirmWithStatsNativeDialogLayer(`Delete "${title}" and all its sessions?`);
 }
 
-export function confirmBucketDelete(title: string, count: number): boolean {
+export function confirmBucketDelete(title: string, count: number): Promise<boolean> {
   if (count === 1) {
-    return globalThis.confirm(
+    return confirmWithStatsNativeDialogLayer(
       `Delete this session of "${title}" from this day and all associated data?`,
     );
   }
-  return globalThis.confirm(
+  return confirmWithStatsNativeDialogLayer(
     `Delete all ${count} sessions of "${title}" from this day and all associated data?`,
   );
 }

stats/src/lib/ipc-client.ts

@@ -62,6 +62,9 @@ interface StatsElectronAPI {
     ankiBrowse: (noteId: number) => Promise<void>;
     ankiNotesInfo: (noteIds: number[]) => Promise<StatsAnkiNoteInfo[]>;
     hideOverlay: () => void;
+    confirmNativeDialog?: (message: string) => boolean;
+    beginNativeDialog?: () => void;
+    endNativeDialog?: () => void;
   };
 }