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/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);