feat: add app-owned YouTube subtitle flow with absPlayer-style parsing (#31)

* fix: harden preload argv parsing for popup windows

* fix: align youtube playback with shared overlay startup

* fix: unwrap mpv youtube streams for anki media mining

* docs: update docs for youtube subtitle and mining flow

* refactor: unify cli and runtime wiring for startup and youtube flow

* feat: update subtitle sidebar overlay behavior

* chore: add shared log-file source for diagnostics

* fix(ci): add changelog fragment for immersion changes

* fix: address CodeRabbit review feedback

* fix: persist canonical title from youtube metadata

* style: format stats library tab

* fix: address latest review feedback

* style: format stats library files

* test: stub launcher youtube deps in CI

* test: isolate launcher youtube flow deps

* test: stub launcher youtube deps in failing case

* test: force x11 backend in launcher ci harness

* test: address latest review feedback

* fix(launcher): preserve user YouTube ytdl raw options

* docs(backlog): update task tracking notes

* fix(immersion): special-case youtube media paths in runtime and tracking

* feat(stats): improve YouTube media metadata and picker key handling

* fix(ci): format stats media library hook

* fix: address latest CodeRabbit review items

* docs: update youtube release notes and docs

* feat: auto-load youtube subtitles before manual picker

* fix: restore app-owned youtube subtitle flow

* docs: update youtube playback docs and config copy

* refactor: remove legacy youtube launcher mode plumbing

* fix: refine youtube subtitle startup binding

* docs: clarify youtube subtitle startup behavior

* fix: address PR #31 latest review follow-ups

* fix: address PR #31 follow-up review comments

* test: harden youtube picker test harness

* udpate backlog

* fix: add timeout to youtube metadata probe

* docs: refresh youtube and stats docs

* update backlog

* update backlog

* chore: release v0.9.0

src/renderer/handlers/mouse.ts

@@ -25,6 +25,74 @@ export function createMouseHandlers(
   let popupPauseRequestId = 0;
   let pausedBySubtitleHover = false;
   let pausedByYomitanPopup = false;
+  let lastPointerPosition: { clientX: number; clientY: number } | null = null;
+  let pendingPointerResync = false;
+
+  function isElementWithinContainer(element: Element | null, container: HTMLElement): boolean {
+    if (!element) {
+      return false;
+    }
+    if (element === container) {
+      return true;
+    }
+    return typeof container.contains === 'function' ? container.contains(element) : false;
+  }
+
+  function updatePointerPosition(event: MouseEvent | PointerEvent): void {
+    lastPointerPosition = {
+      clientX: event.clientX,
+      clientY: event.clientY,
+    };
+  }
+
+  function syncHoverStateFromPoint(clientX: number, clientY: number): boolean {
+    const hoveredElement =
+      typeof document.elementFromPoint === 'function'
+        ? document.elementFromPoint(clientX, clientY)
+        : null;
+    const overPrimarySubtitle = isElementWithinContainer(hoveredElement, ctx.dom.subtitleContainer);
+    const overSecondarySubtitle = isElementWithinContainer(
+      hoveredElement,
+      ctx.dom.secondarySubContainer,
+    );
+
+    ctx.state.isOverSubtitle = overPrimarySubtitle || overSecondarySubtitle;
+    ctx.dom.secondarySubContainer.classList.toggle(
+      'secondary-sub-hover-active',
+      overSecondarySubtitle,
+    );
+
+    return ctx.state.isOverSubtitle;
+  }
+
+  function restorePointerInteractionState(): void {
+    const pointerPosition = lastPointerPosition;
+    pendingPointerResync = false;
+    if (pointerPosition) {
+      syncHoverStateFromPoint(pointerPosition.clientX, pointerPosition.clientY);
+    } else {
+      ctx.state.isOverSubtitle = false;
+      ctx.dom.secondarySubContainer.classList.remove('secondary-sub-hover-active');
+    }
+    syncOverlayMouseIgnoreState(ctx);
+
+    if (!ctx.platform.shouldToggleMouseIgnore || ctx.state.isOverSubtitle) {
+      return;
+    }
+
+    pendingPointerResync = true;
+    ctx.dom.overlay.classList.add('interactive');
+    window.electronAPI.setIgnoreMouseEvents(false);
+  }
+
+  function maybeResyncPointerHoverState(event: MouseEvent | PointerEvent): void {
+    if (!pendingPointerResync) {
+      return;
+    }
+    pendingPointerResync = false;
+    syncHoverStateFromPoint(event.clientX, event.clientY);
+    syncOverlayMouseIgnoreState(ctx);
+  }
 
   function isWithinOtherSubtitleContainer(
     relatedTarget: EventTarget | null,
@@ -222,6 +290,17 @@ export function createMouseHandlers(
     });
   }
 
+  function setupPointerTracking(): void {
+    document.addEventListener('mousemove', (event: MouseEvent) => {
+      updatePointerPosition(event);
+      maybeResyncPointerHoverState(event);
+    });
+    document.addEventListener('pointermove', (event: PointerEvent) => {
+      updatePointerPosition(event);
+      maybeResyncPointerHoverState(event);
+    });
+  }
+
   function setupSelectionObserver(): void {
     document.addEventListener('selectionchange', () => {
       const selection = window.getSelection();
@@ -283,7 +362,9 @@ export function createMouseHandlers(
     handleSecondaryMouseLeave: (event?: MouseEvent) => handleMouseLeave(event, true),
     handleMouseEnter,
     handleMouseLeave,
+    restorePointerInteractionState,
     setupDragging,
+    setupPointerTracking,
     setupResizeHandler,
     setupSelectionObserver,
     setupYomitanObserver,