fix: unblock autoplay on tokenization-ready and defer annotation loading

src/main/runtime/composers/mpv-runtime-composer.test.ts

@@ -521,8 +521,8 @@ test('composeMpvRuntimeHandlers runs tokenization warmup once across sequential
 
   assert.deepEqual(tokenizeCalls, ['first', 'second']);
   assert.equal(yomitanWarmupCalls, 1);
-  assert.equal(prewarmJlptCalls, 1);
-  assert.equal(prewarmFrequencyCalls, 1);
+  assert.equal(prewarmJlptCalls, 0);
+  assert.equal(prewarmFrequencyCalls, 0);
 });
 
 test('composeMpvRuntimeHandlers does not block first tokenization on dictionary or MeCab warmup', async () => {
@@ -658,3 +658,151 @@ test('composeMpvRuntimeHandlers does not block first tokenization on dictionary
   await tokenizePromise;
   await composed.startTokenizationWarmups();
 });
+
+test(
+  'composeMpvRuntimeHandlers shows annotation loading OSD after tokenization-ready when dictionary warmup is still pending',
+  async () => {
+    const jlptDeferred = createDeferred();
+    const frequencyDeferred = createDeferred();
+    const osdMessages: string[] = [];
+
+    const composed = composeMpvRuntimeHandlers<
+      { connect: () => void; on: () => void },
+      { onTokenizationReady?: (text: string) => void },
+      { text: string }
+    >({
+      bindMpvMainEventHandlersMainDeps: {
+        appState: {
+          initialArgs: null,
+          overlayRuntimeInitialized: true,
+          mpvClient: null,
+          immersionTracker: null,
+          subtitleTimingTracker: null,
+          currentSubText: '',
+          currentSubAssText: '',
+          playbackPaused: null,
+          previousSecondarySubVisibility: null,
+        },
+        getQuitOnDisconnectArmed: () => false,
+        scheduleQuitCheck: () => {},
+        quitApp: () => {},
+        reportJellyfinRemoteStopped: () => {},
+        syncOverlayMpvSubtitleSuppression: () => {},
+        maybeRunAnilistPostWatchUpdate: async () => {},
+        logSubtitleTimingError: () => {},
+        broadcastToOverlayWindows: () => {},
+        onSubtitleChange: () => {},
+        refreshDiscordPresence: () => {},
+        ensureImmersionTrackerInitialized: () => {},
+        updateCurrentMediaPath: () => {},
+        restoreMpvSubVisibility: () => {},
+        getCurrentAnilistMediaKey: () => null,
+        resetAnilistMediaTracking: () => {},
+        maybeProbeAnilistDuration: () => {},
+        ensureAnilistMediaGuess: () => {},
+        syncImmersionMediaState: () => {},
+        updateCurrentMediaTitle: () => {},
+        resetAnilistMediaGuessState: () => {},
+        reportJellyfinRemoteProgress: () => {},
+        updateSubtitleRenderMetrics: () => {},
+      },
+      mpvClientRuntimeServiceFactoryMainDeps: {
+        createClient: class {
+          connect(): void {}
+          on(): void {}
+        },
+        getSocketPath: () => '/tmp/mpv.sock',
+        getResolvedConfig: () => ({ auto_start_overlay: false }),
+        isAutoStartOverlayEnabled: () => false,
+        setOverlayVisible: () => {},
+        isVisibleOverlayVisible: () => false,
+        getReconnectTimer: () => null,
+        setReconnectTimer: () => {},
+      },
+      updateMpvSubtitleRenderMetricsMainDeps: {
+        getCurrentMetrics: () => BASE_METRICS,
+        setCurrentMetrics: () => {},
+        applyPatch: (current, patch) => ({ next: { ...current, ...patch }, changed: true }),
+        broadcastMetrics: () => {},
+      },
+      tokenizer: {
+        buildTokenizerDepsMainDeps: {
+          getYomitanExt: () => null,
+          getYomitanParserWindow: () => null,
+          setYomitanParserWindow: () => {},
+          getYomitanParserReadyPromise: () => null,
+          setYomitanParserReadyPromise: () => {},
+          getYomitanParserInitPromise: () => null,
+          setYomitanParserInitPromise: () => {},
+          isKnownWord: () => false,
+          recordLookup: () => {},
+          getKnownWordMatchMode: () => 'headword',
+          getNPlusOneEnabled: () => false,
+          getMinSentenceWordsForNPlusOne: () => 3,
+          getJlptLevel: () => null,
+          getJlptEnabled: () => true,
+          getFrequencyDictionaryEnabled: () => true,
+          getFrequencyDictionaryMatchMode: () => 'headword',
+          getFrequencyRank: () => null,
+          getYomitanGroupDebugEnabled: () => false,
+          getMecabTokenizer: () => null,
+        },
+        createTokenizerRuntimeDeps: (deps) =>
+          deps as unknown as { onTokenizationReady?: (text: string) => void },
+        tokenizeSubtitle: async (text, deps) => {
+          deps.onTokenizationReady?.(text);
+          return { text };
+        },
+        createMecabTokenizerAndCheckMainDeps: {
+          getMecabTokenizer: () => null,
+          setMecabTokenizer: () => {},
+          createMecabTokenizer: () => ({ id: 'mecab' }),
+          checkAvailability: async () => {},
+        },
+        prewarmSubtitleDictionariesMainDeps: {
+          ensureJlptDictionaryLookup: async () => jlptDeferred.promise,
+          ensureFrequencyDictionaryLookup: async () => frequencyDeferred.promise,
+          showMpvOsd: (message) => {
+            osdMessages.push(message);
+          },
+        },
+      },
+      warmups: {
+        launchBackgroundWarmupTaskMainDeps: {
+          now: () => 0,
+          logDebug: () => {},
+          logWarn: () => {},
+        },
+        startBackgroundWarmupsMainDeps: {
+          getStarted: () => false,
+          setStarted: () => {},
+          isTexthookerOnlyMode: () => false,
+          ensureYomitanExtensionLoaded: async () => undefined,
+          shouldWarmupMecab: () => false,
+          shouldWarmupYomitanExtension: () => false,
+          shouldWarmupSubtitleDictionaries: () => false,
+          shouldWarmupJellyfinRemoteSession: () => false,
+          shouldAutoConnectJellyfinRemote: () => false,
+          startJellyfinRemoteSession: async () => {},
+        },
+      },
+    });
+
+    const warmupPromise = composed.startTokenizationWarmups();
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    assert.deepEqual(osdMessages, []);
+
+    await composed.tokenizeSubtitle('first line');
+    assert.deepEqual(osdMessages, ['Loading subtitle annotations |']);
+
+    jlptDeferred.resolve();
+    frequencyDeferred.resolve();
+    await warmupPromise;
+    await new Promise<void>((resolve) => setImmediate(resolve));
+
+    assert.deepEqual(osdMessages, [
+      'Loading subtitle annotations |',
+      'Subtitle annotations loaded',
+    ]);
+  },
+);

src/main/runtime/composers/mpv-runtime-composer.ts

@@ -141,6 +141,12 @@ export function composeMpvRuntimeHandlers<
       options.tokenizer.buildTokenizerDepsMainDeps.getFrequencyDictionaryEnabled() !== false;
     return nPlusOneEnabled || jlptEnabled || frequencyEnabled;
   };
+  const shouldWarmupAnnotationDictionaries = (): boolean => {
+    const jlptEnabled = options.tokenizer.buildTokenizerDepsMainDeps.getJlptEnabled() !== false;
+    const frequencyEnabled =
+      options.tokenizer.buildTokenizerDepsMainDeps.getFrequencyDictionaryEnabled() !== false;
+    return jlptEnabled || frequencyEnabled;
+  };
   let tokenizationWarmupInFlight: Promise<void> | null = null;
   let tokenizationPrerequisiteWarmupInFlight: Promise<void> | null = null;
   let tokenizationPrerequisiteWarmupCompleted = false;
@@ -174,7 +180,9 @@ export function composeMpvRuntimeHandlers<
         ) {
           warmupTasks.push(createMecabTokenizerAndCheck().catch(() => {}));
         }
-        warmupTasks.push(prewarmSubtitleDictionaries({ showLoadingOsd: true }).catch(() => {}));
+        if (shouldWarmupAnnotationDictionaries()) {
+          warmupTasks.push(prewarmSubtitleDictionaries().catch(() => {}));
+        }
         await Promise.all(warmupTasks);
         tokenizationWarmupCompleted = true;
       })().finally(() => {
@@ -186,9 +194,19 @@ export function composeMpvRuntimeHandlers<
   const tokenizeSubtitle = async (text: string): Promise<TTokenizedSubtitle> => {
     if (!tokenizationWarmupCompleted) void startTokenizationWarmups();
     await ensureTokenizationPrerequisites();
+    const tokenizerMainDeps = buildTokenizerDepsHandler();
+    if (shouldWarmupAnnotationDictionaries()) {
+      const onTokenizationReady = tokenizerMainDeps.onTokenizationReady;
+      tokenizerMainDeps.onTokenizationReady = (tokenizedText: string): void => {
+        onTokenizationReady?.(tokenizedText);
+        if (!tokenizationWarmupCompleted) {
+          void prewarmSubtitleDictionaries({ showLoadingOsd: true }).catch(() => {});
+        }
+      };
+    }
     return options.tokenizer.tokenizeSubtitle(
       text,
-      options.tokenizer.createTokenizerRuntimeDeps(buildTokenizerDepsHandler()),
+      options.tokenizer.createTokenizerRuntimeDeps(tokenizerMainDeps),
     );
   };
 

src/main/runtime/subtitle-tokenization-main-deps.test.ts

@@ -167,22 +167,28 @@ test('dictionary prewarm can show OSD while awaiting background-started load', a
   assert.deepEqual(osdMessages, ['Loading subtitle annotations |', 'Subtitle annotations loaded']);
 });
 
-test('dictionary prewarm does not show OSD when notifications are disabled', async () => {
-  const osdMessages: string[] = [];
+test(
+  'dictionary prewarm shows OSD when loading indicator is requested even if notification predicate is disabled',
+  async () => {
+    const osdMessages: string[] = [];
 
-  const prewarm = createPrewarmSubtitleDictionariesMainHandler({
-    ensureJlptDictionaryLookup: async () => undefined,
-    ensureFrequencyDictionaryLookup: async () => undefined,
-    shouldShowOsdNotification: () => false,
-    showMpvOsd: (message) => {
-      osdMessages.push(message);
-    },
-  });
+    const prewarm = createPrewarmSubtitleDictionariesMainHandler({
+      ensureJlptDictionaryLookup: async () => undefined,
+      ensureFrequencyDictionaryLookup: async () => undefined,
+      shouldShowOsdNotification: () => false,
+      showMpvOsd: (message) => {
+        osdMessages.push(message);
+      },
+    });
 
-  await prewarm({ showLoadingOsd: true });
+    await prewarm({ showLoadingOsd: true });
 
-  assert.deepEqual(osdMessages, []);
-});
+    assert.deepEqual(osdMessages, [
+      'Loading subtitle annotations |',
+      'Subtitle annotations loaded',
+    ]);
+  },
+);
 
 test('dictionary prewarm clears loading OSD timer even if notifications are disabled before completion', async () => {
   const clearedTimers: unknown[] = [];

src/main/runtime/subtitle-tokenization-main-deps.ts

@@ -48,6 +48,7 @@ export function createBuildTokenizerDepsMainHandler(deps: TokenizerMainDeps) {
     getFrequencyRank: (text: string) => deps.getFrequencyRank(text),
     getYomitanGroupDebugEnabled: () => deps.getYomitanGroupDebugEnabled(),
     getMecabTokenizer: () => deps.getMecabTokenizer(),
+    onTokenizationReady: (text: string) => deps.onTokenizationReady?.(text),
   });
 }
 
@@ -81,7 +82,6 @@ export function createPrewarmSubtitleDictionariesMainHandler(deps: {
   let loadingOsdFrame = 0;
   let loadingOsdTimer: unknown = null;
   const showMpvOsd = deps.showMpvOsd;
-  const shouldShowOsdNotification = deps.shouldShowOsdNotification ?? (() => false);
   const setIntervalHandler =
     deps.setInterval ??
     ((callback: () => void, delayMs: number): unknown => setInterval(callback, delayMs));
@@ -91,7 +91,7 @@ export function createPrewarmSubtitleDictionariesMainHandler(deps: {
   const spinnerFrames = ['|', '/', '-', '\\'];
 
   const beginLoadingOsd = (): boolean => {
-    if (!showMpvOsd || !shouldShowOsdNotification()) {
+    if (!showMpvOsd) {
       return false;
     }
     loadingOsdDepth += 1;