fix(overlay): keep Hachidori attention from pausing playback

Hachidori's hachidori-popup-shown/hidden pair means "the reader needs
mouse events", which includes a left press anywhere on the overlay that
may start a selection. SubMiner treated it as popup visibility, so a
click paused and resumed mpv, and holding the button kept it paused.
The host element only exists after the first lookup, so the first
attempt (gate on an open popup pane when a host exists) still paused
on clicks before any lookup.

Once a Hachidori event has been seen, popup auto-pause now requires an
unhidden popup pane in the host's shadow root, and rechecks after each
successful lookup so drag-select popups still pause.

src/renderer/handlers/mouse.test.ts

@@ -4,6 +4,11 @@ import test from 'node:test';
 import type { SubtitleSidebarConfig } from '../../types';
 import { createMouseHandlers } from './mouse.js';
 import {
+  HACHIDORI_HOST_SELECTOR,
+  HACHIDORI_POPUP_HIDDEN_EVENT,
+  HACHIDORI_POPUP_SELECTOR,
+  HACHIDORI_POPUP_SHOWN_EVENT,
+  YOMITAN_LOOKUP_EVENT,
   YOMITAN_POPUP_HIDDEN_EVENT,
   YOMITAN_POPUP_HOST_SELECTOR,
   YOMITAN_POPUP_MOUSE_ENTER_EVENT,
@@ -722,6 +727,210 @@ test('popup open pauses and popup close resumes when yomitan popup auto-pause is
   }
 });
 
+// Hachidori publishes one attention signal for an open popup and for a press on
+// subtitle text that may become a selection, so its popup pane is the stub's
+// source of truth for what is on screen.
+async function withHachidoriReader(
+  run: (reader: {
+    emit: (event: string) => void;
+    setAttention: (active: boolean) => void;
+    setPopupOpen: (open: boolean) => void;
+    setHostAttached: (attached: boolean) => void;
+  }) => Promise<void>,
+): Promise<void> {
+  const previousWindow = (globalThis as { window?: unknown }).window;
+  const previousDocument = (globalThis as { document?: unknown }).document;
+  const previousMutationObserver = (globalThis as { MutationObserver?: unknown }).MutationObserver;
+  const previousNode = (globalThis as { Node?: unknown }).Node;
+  const windowListeners = new Map<string, Array<() => void>>();
+  const pane = { hidden: true };
+  let attention = false;
+  let hostAttached = true;
+  const host = {
+    tagName: 'HACHIDORI-HOST',
+    getAttribute: (name: string) =>
+      name === 'data-subminer-yomitan-popup-visible' ? String(attention) : null,
+    shadowRoot: {
+      querySelectorAll: (selector: string) => (selector === HACHIDORI_POPUP_SELECTOR ? [pane] : []),
+    },
+  };
+
+  Object.defineProperty(globalThis, 'window', {
+    configurable: true,
+    value: {
+      addEventListener: (type: string, listener: () => void) => {
+        const bucket = windowListeners.get(type) ?? [];
+        bucket.push(listener);
+        windowListeners.set(type, bucket);
+      },
+      electronAPI: {
+        setIgnoreMouseEvents: () => {},
+      },
+      focus: () => {},
+      innerHeight: 1000,
+      getSelection: () => null,
+      setTimeout,
+      clearTimeout,
+    },
+  });
+  Object.defineProperty(globalThis, 'document', {
+    configurable: true,
+    value: {
+      querySelector: () => null,
+      querySelectorAll: (selector: string) => {
+        if (!hostAttached) return [];
+        if (selector === HACHIDORI_HOST_SELECTOR || selector === YOMITAN_POPUP_HOST_SELECTOR) {
+          return [host];
+        }
+        if (selector === YOMITAN_POPUP_VISIBLE_HOST_SELECTOR) {
+          return attention ? [host] : [];
+        }
+        return [];
+      },
+      body: {},
+      elementFromPoint: () => null,
+      addEventListener: () => {},
+    },
+  });
+  Object.defineProperty(globalThis, 'MutationObserver', {
+    configurable: true,
+    value: class {
+      observe() {}
+    },
+  });
+  Object.defineProperty(globalThis, 'Node', {
+    configurable: true,
+    value: {
+      ELEMENT_NODE: 1,
+    },
+  });
+
+  try {
+    await run({
+      emit: (event) => {
+        for (const listener of windowListeners.get(event) ?? []) {
+          listener();
+        }
+      },
+      setAttention: (active) => {
+        attention = active;
+      },
+      setPopupOpen: (open) => {
+        pane.hidden = !open;
+      },
+      setHostAttached: (attached) => {
+        hostAttached = attached;
+      },
+    });
+  } finally {
+    Object.defineProperty(globalThis, 'window', { configurable: true, value: previousWindow });
+    Object.defineProperty(globalThis, 'document', { configurable: true, value: previousDocument });
+    Object.defineProperty(globalThis, 'MutationObserver', {
+      configurable: true,
+      value: previousMutationObserver,
+    });
+    Object.defineProperty(globalThis, 'Node', { configurable: true, value: previousNode });
+  }
+}
+
+function createPopupAutoPauseHandlers(
+  ctx: ReturnType<typeof createMouseTestContext>,
+  mpvCommands: Array<(string | number)[]>,
+) {
+  return createMouseHandlers(ctx as never, {
+    modalStateReader: {
+      isAnySettingsModalOpen: () => false,
+      isAnyModalOpen: () => false,
+    },
+    applyYPercent: () => {},
+    getCurrentYPercent: () => 10,
+    persistSubtitlePositionPatch: () => {},
+    getSubtitleHoverAutoPauseEnabled: () => false,
+    getYomitanPopupAutoPauseEnabled: () => true,
+    getPlaybackPaused: async () => false,
+    sendMpvCommand: (command: (string | number)[]) => {
+      mpvCommands.push(command);
+    },
+  });
+}
+
+test('Hachidori press on subtitle text does not pause before a popup opens', async () => {
+  await withHachidoriReader(async (reader) => {
+    const mpvCommands: Array<(string | number)[]> = [];
+    const handlers = createPopupAutoPauseHandlers(createMouseTestContext(), mpvCommands);
+    handlers.setupYomitanObserver();
+
+    reader.setAttention(true);
+    reader.emit(HACHIDORI_POPUP_SHOWN_EVENT);
+    await waitForNextTick();
+    reader.setAttention(false);
+    reader.emit(HACHIDORI_POPUP_HIDDEN_EVENT);
+    await waitForNextTick();
+
+    assert.deepEqual(mpvCommands, []);
+  });
+});
+
+test('Hachidori press before any lookup does not pause while its host is unattached', async () => {
+  await withHachidoriReader(async (reader) => {
+    const mpvCommands: Array<(string | number)[]> = [];
+    const handlers = createPopupAutoPauseHandlers(createMouseTestContext(), mpvCommands);
+    handlers.setupYomitanObserver();
+
+    // Hachidori attaches its host on the first lookup, so a press anywhere on
+    // the overlay before that claims attention with nothing in the DOM.
+    reader.setHostAttached(false);
+    reader.emit(HACHIDORI_POPUP_SHOWN_EVENT);
+    await waitForNextTick();
+    reader.emit(HACHIDORI_POPUP_HIDDEN_EVENT);
+    await waitForNextTick();
+
+    assert.deepEqual(mpvCommands, []);
+  });
+});
+
+test('Hachidori selection lookup pauses once its popup opens and resumes on close', async () => {
+  await withHachidoriReader(async (reader) => {
+    const mpvCommands: Array<(string | number)[]> = [];
+    const handlers = createPopupAutoPauseHandlers(createMouseTestContext(), mpvCommands);
+    handlers.setupYomitanObserver();
+
+    reader.setAttention(true);
+    reader.emit(HACHIDORI_POPUP_SHOWN_EVENT);
+    await waitForNextTick();
+    assert.deepEqual(mpvCommands, []);
+
+    // The drag's attention carries over to its lookup, so no second shown event arrives.
+    reader.setPopupOpen(true);
+    reader.emit(YOMITAN_LOOKUP_EVENT);
+    await waitForNextTick();
+    assert.deepEqual(mpvCommands, [['set_property', 'pause', 'yes']]);
+
+    reader.setPopupOpen(false);
+    reader.setAttention(false);
+    reader.emit(HACHIDORI_POPUP_HIDDEN_EVENT);
+    assert.deepEqual(mpvCommands, [
+      ['set_property', 'pause', 'yes'],
+      ['set_property', 'pause', 'no'],
+    ]);
+  });
+});
+
+test('Hachidori hover popup pauses when shown', async () => {
+  await withHachidoriReader(async (reader) => {
+    const mpvCommands: Array<(string | number)[]> = [];
+    const handlers = createPopupAutoPauseHandlers(createMouseTestContext(), mpvCommands);
+    handlers.setupYomitanObserver();
+
+    reader.setPopupOpen(true);
+    reader.setAttention(true);
+    reader.emit(HACHIDORI_POPUP_SHOWN_EVENT);
+    await waitForNextTick();
+
+    assert.deepEqual(mpvCommands, [['set_property', 'pause', 'yes']]);
+  });
+});
+
 test('nested popup close reasserts interactive state and focus when another popup remains visible on Windows', async () => {
   const ctx = createMouseTestContext();
   const previousWindow = (globalThis as { window?: unknown }).window;

src/renderer/handlers/mouse.ts

@@ -4,7 +4,9 @@ import {
   YOMITAN_POPUP_MOUSE_ENTER_EVENT,
   YOMITAN_POPUP_MOUSE_LEAVE_EVENT,
   registerDictionaryPopupVisibilityListener,
+  registerYomitanLookupListener,
   PRIMARY_SUB_VISIBLE_ON_YOMITAN_POPUP_CLASS,
+  isHachidoriPopupOpen,
   isYomitanPopupVisible,
   isYomitanPopupIframe,
 } from '../yomitan-popup.js';
@@ -34,6 +36,7 @@ export function createMouseHandlers(
   let yomitanPopupVisible = false;
   let hoverPauseRequestId = 0;
   let popupPauseRequestId = 0;
+  let hachidoriReaderSeen = false;
   let pausedBySubtitleHover = false;
   let pausedByYomitanPopup = false;
   let lastPointerPosition: { clientX: number; clientY: number } | null = null;
@@ -256,8 +259,19 @@ export function createMouseHandlers(
     options.sendMpvCommand(['set_property', 'pause', 'no']);
   }
 
+  // Hachidori also claims attention for a left press anywhere on the overlay
+  // that may become a selection, so once its events identify the reader only
+  // an open popup pane should pause playback.
+  function canPauseForYomitanPopup(): boolean {
+    return (
+      yomitanPopupVisible &&
+      options.getYomitanPopupAutoPauseEnabled() &&
+      (!hachidoriReaderSeen || (typeof document !== 'undefined' && isHachidoriPopupOpen(document)))
+    );
+  }
+
   async function maybePauseForYomitanPopup(): Promise<void> {
-    if (!yomitanPopupVisible || !options.getYomitanPopupAutoPauseEnabled()) {
+    if (!canPauseForYomitanPopup()) {
       return;
     }
 
@@ -277,11 +291,7 @@ export function createMouseHandlers(
       return;
     }
 
-    if (
-      requestId !== popupPauseRequestId ||
-      !yomitanPopupVisible ||
-      !options.getYomitanPopupAutoPauseEnabled()
-    ) {
+    if (requestId !== popupPauseRequestId || !canPauseForYomitanPopup()) {
       return;
     }
     if (paused !== false) return;
@@ -469,7 +479,8 @@ export function createMouseHandlers(
   function setupYomitanObserver(): void {
     reconcilePopupInteraction({ allowPause: true });
 
-    registerDictionaryPopupVisibilityListener('shown', () => {
+    registerDictionaryPopupVisibilityListener('shown', (reader) => {
+      if (reader === 'hachidori') hachidoriReaderSeen = true;
       reconcilePopupInteraction({
         assumeVisible: true,
         allowPause: true,
@@ -481,6 +492,12 @@ export function createMouseHandlers(
       disablePopupInteractionIfIdle();
     });
 
+    // A Hachidori selection opens its popup while the drag's attention claim is
+    // still held, so no second shown event arrives; its lookup marks the open.
+    registerYomitanLookupListener(window, () => {
+      reconcilePopupInteraction({ allowPause: true });
+    });
+
     window.addEventListener(YOMITAN_POPUP_MOUSE_ENTER_EVENT, () => {
       ctx.state.isOverYomitanPopup = true;
       reconcilePopupInteraction({ assumeVisible: true, reclaimFocus: true });

src/renderer/yomitan-popup.ts

@@ -10,17 +10,39 @@ export const YOMITAN_POPUP_MOUSE_LEAVE_EVENT = 'yomitan-popup-mouse-leave';
 export const YOMITAN_POPUP_COMMAND_EVENT = 'subminer-yomitan-popup-command';
 export const YOMITAN_LOOKUP_EVENT = 'subminer-yomitan-lookup';
 export const PRIMARY_SUB_VISIBLE_ON_YOMITAN_POPUP_CLASS = 'primary-sub-visible-on-yomitan-popup';
+// Hachidori's shown/hidden pair means "the reader needs mouse events", which
+// also covers a left press on subtitle text that may start a selection. Its
+// popup panes live in the host's open shadow root.
+export const HACHIDORI_POPUP_SHOWN_EVENT = 'hachidori-popup-shown';
+export const HACHIDORI_POPUP_HIDDEN_EVENT = 'hachidori-popup-hidden';
+export const HACHIDORI_HOST_SELECTOR = 'hachidori-host';
+export const HACHIDORI_POPUP_SELECTOR = '.gsm-hoshidicts-popup';
+
+export type DictionaryReader = 'yomitan' | 'hachidori';
 
 // Only the active backend injects a reader. Consume its native attention events.
 export function registerDictionaryPopupVisibilityListener(
   state: 'shown' | 'hidden',
-  listener: () => void,
+  listener: (reader: DictionaryReader) => void,
   target: EventTarget = window,
 ): () => void {
-  const events = [`yomitan-popup-${state}`, `hachidori-popup-${state}`];
-  for (const event of events) target.addEventListener(event, listener);
+  const events: Array<[string, DictionaryReader]> =
+    state === 'shown'
+      ? [
+          [YOMITAN_POPUP_SHOWN_EVENT, 'yomitan'],
+          [HACHIDORI_POPUP_SHOWN_EVENT, 'hachidori'],
+        ]
+      : [
+          [YOMITAN_POPUP_HIDDEN_EVENT, 'yomitan'],
+          [HACHIDORI_POPUP_HIDDEN_EVENT, 'hachidori'],
+        ];
+  const wrapped = events.map(([event, reader]) => {
+    const handler = (): void => listener(reader);
+    target.addEventListener(event, handler);
+    return [event, handler] as const;
+  });
   return () => {
-    for (const event of events) target.removeEventListener(event, listener);
+    for (const [event, handler] of wrapped) target.removeEventListener(event, handler);
   };
 }
 
@@ -86,6 +108,20 @@ function queryPopupElements<T extends Element>(
   return [];
 }
 
+/**
+ * Whether a Hachidori popup pane is on screen. Auto-pause reads this because
+ * the host's visible marker only tracks Hachidori's attention signal. Hachidori
+ * attaches its host on the first lookup, so no host means no popup.
+ */
+export function isHachidoriPopupOpen(root: ParentNode | null | undefined = document): boolean {
+  const hosts = queryPopupElements<HTMLElement>(root, HACHIDORI_HOST_SELECTOR);
+  return hosts.some((host) =>
+    queryPopupElements<HTMLElement>(host.shadowRoot, HACHIDORI_POPUP_SELECTOR).some(
+      (pane) => !pane.hidden,
+    ),
+  );
+}
+
 export function isYomitanPopupVisible(root: ParentNode | null | undefined = document): boolean {
   const visiblePopupHosts = queryPopupElements<HTMLElement>(
     root,