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

import assert from 'node:assert/strict';
import test from 'node:test';
import type { MpvSubtitleRenderMetrics } from '../../../types';
import { composeMpvRuntimeHandlers } from './mpv-runtime-composer';

const BASE_METRICS: MpvSubtitleRenderMetrics = {
  subPos: 100,
  subFontSize: 36,
  subScale: 1,
  subMarginY: 0,
  subMarginX: 0,
  subFont: '',
  subSpacing: 0,
  subBold: false,
  subItalic: false,
  subBorderSize: 0,
  subShadowOffset: 0,
  subAssOverride: 'yes',
  subScaleByWindow: true,
  subUseMargins: true,
  osdHeight: 0,
  osdDimensions: null,
};

function createDeferred(): { promise: Promise<void>; resolve: () => void } {
  let resolve!: () => void;
  const promise = new Promise<void>((nextResolve) => {
    resolve = nextResolve;
  });
  return { promise, resolve };
}

test('composeMpvRuntimeHandlers returns callable handlers and forwards to injected deps', async () => {
  const calls: string[] = [];
  let started = false;
  let metrics = BASE_METRICS;
  let mecabTokenizer: { id: string } | null = null;

  class FakeMpvClient {
    connected = false;

    constructor(
      public socketPath: string,
      public options: unknown,
    ) {
      const autoStartOverlay = (options as { autoStartOverlay: boolean }).autoStartOverlay;
      calls.push(`create-client:${socketPath}`);
      calls.push(`auto-start:${String(autoStartOverlay)}`);
    }

    on(): void {}

    connect(): void {
      this.connected = true;
      calls.push('client-connect');
    }
  }

  const composed = composeMpvRuntimeHandlers<
    FakeMpvClient,
    { isKnownWord: (text: string) => boolean },
    { 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: FakeMpvClient,
      getSocketPath: () => '/tmp/mpv.sock',
      getResolvedConfig: () => ({ auto_start_overlay: false }),
      isAutoStartOverlayEnabled: () => true,
      setOverlayVisible: () => {},
      isVisibleOverlayVisible: () => false,
      getReconnectTimer: () => null,
      setReconnectTimer: () => {},
    },
    updateMpvSubtitleRenderMetricsMainDeps: {
      getCurrentMetrics: () => metrics,
      setCurrentMetrics: (next) => {
        metrics = next;
        calls.push('set-metrics');
      },
      applyPatch: (current, patch) => {
        calls.push('apply-metrics-patch');
        return { next: { ...current, ...patch }, changed: true };
      },
      broadcastMetrics: () => {
        calls.push('broadcast-metrics');
      },
    },
    tokenizer: {
      buildTokenizerDepsMainDeps: {
        getYomitanExt: () => null,
        getYomitanParserWindow: () => null,
        setYomitanParserWindow: () => {},
        getYomitanParserReadyPromise: () => null,
        setYomitanParserReadyPromise: () => {},
        getYomitanParserInitPromise: () => null,
        setYomitanParserInitPromise: () => {},
        isKnownWord: (text) => text === 'known',
        recordLookup: () => {},
        getKnownWordMatchMode: () => 'headword',
        getMinSentenceWordsForNPlusOne: () => 3,
        getJlptLevel: () => null,
        getJlptEnabled: () => true,
        getFrequencyDictionaryEnabled: () => true,
        getFrequencyDictionaryMatchMode: () => 'headword',
        getFrequencyRank: () => null,
        getYomitanGroupDebugEnabled: () => false,
        getMecabTokenizer: () => null,
      },
      createTokenizerRuntimeDeps: (deps) => {
        calls.push('create-tokenizer-runtime-deps');
        return { isKnownWord: (text: string) => deps.isKnownWord(text) };
      },
      tokenizeSubtitle: async (text, deps) => {
        calls.push(`tokenize:${text}`);
        deps.isKnownWord('known');
        return { text };
      },
      createMecabTokenizerAndCheckMainDeps: {
        getMecabTokenizer: () => mecabTokenizer,
        setMecabTokenizer: (next) => {
          mecabTokenizer = next as { id: string };
          calls.push('set-mecab');
        },
        createMecabTokenizer: () => {
          calls.push('create-mecab');
          return { id: 'mecab' };
        },
        checkAvailability: async () => {
          calls.push('check-mecab');
        },
      },
      prewarmSubtitleDictionariesMainDeps: {
        ensureJlptDictionaryLookup: async () => {
          calls.push('prewarm-jlpt');
        },
        ensureFrequencyDictionaryLookup: async () => {
          calls.push('prewarm-frequency');
        },
      },
    },
    warmups: {
      launchBackgroundWarmupTaskMainDeps: {
        now: () => 100,
        logDebug: () => {
          calls.push('warmup-debug');
        },
        logWarn: () => {
          calls.push('warmup-warn');
        },
      },
      startBackgroundWarmupsMainDeps: {
        getStarted: () => started,
        setStarted: (next) => {
          started = next;
          calls.push(`set-started:${String(next)}`);
        },
        isTexthookerOnlyMode: () => false,
        ensureYomitanExtensionLoaded: async () => {
          calls.push('warmup-yomitan');
        },
        shouldWarmupMecab: () => true,
        shouldWarmupYomitanExtension: () => true,
        shouldWarmupSubtitleDictionaries: () => true,
        shouldWarmupJellyfinRemoteSession: () => true,
        shouldAutoConnectJellyfinRemote: () => false,
        startJellyfinRemoteSession: async () => {
          calls.push('warmup-jellyfin');
        },
      },
    },
  });

  assert.equal(typeof composed.bindMpvClientEventHandlers, 'function');
  assert.equal(typeof composed.createMpvClientRuntimeService, 'function');
  assert.equal(typeof composed.updateMpvSubtitleRenderMetrics, 'function');
  assert.equal(typeof composed.tokenizeSubtitle, 'function');
  assert.equal(typeof composed.createMecabTokenizerAndCheck, 'function');
  assert.equal(typeof composed.prewarmSubtitleDictionaries, 'function');
  assert.equal(typeof composed.startTokenizationWarmups, 'function');
  assert.equal(typeof composed.launchBackgroundWarmupTask, 'function');
  assert.equal(typeof composed.startBackgroundWarmups, 'function');

  const client = composed.createMpvClientRuntimeService();
  assert.equal(client.connected, true);

  composed.updateMpvSubtitleRenderMetrics({ subPos: 90 });
  await composed.startTokenizationWarmups();
  const tokenized = await composed.tokenizeSubtitle('subtitle text');
  await composed.createMecabTokenizerAndCheck();
  await composed.prewarmSubtitleDictionaries();
  composed.startBackgroundWarmups();

  assert.deepEqual(tokenized, { text: 'subtitle text' });
  assert.equal(metrics.subPos, 90);
  assert.ok(calls.includes('create-client:/tmp/mpv.sock'));
  assert.ok(calls.includes('auto-start:true'));
  assert.ok(calls.includes('client-connect'));
  assert.ok(calls.includes('apply-metrics-patch'));
  assert.ok(calls.includes('set-metrics'));
  assert.ok(calls.includes('broadcast-metrics'));
  assert.ok(calls.includes('create-tokenizer-runtime-deps'));
  assert.ok(calls.includes('tokenize:subtitle text'));
  assert.ok(calls.includes('create-mecab'));
  assert.ok(calls.includes('set-mecab'));
  assert.ok(calls.includes('check-mecab'));
  assert.ok(calls.includes('prewarm-jlpt'));
  assert.ok(calls.includes('prewarm-frequency'));
  assert.ok(calls.includes('set-started:true'));
  assert.ok(calls.includes('warmup-yomitan'));
  assert.ok(calls.indexOf('create-mecab') < calls.indexOf('set-started:true'));
});

test('composeMpvRuntimeHandlers skips MeCab warmup when all POS-dependent annotations are disabled', async () => {
  const calls: string[] = [];
  let mecabTokenizer: { id: string } | null = null;

  class FakeMpvClient {
    connected = false;
    constructor(
      public socketPath: string,
      public options: unknown,
    ) {}
    on(): void {}
    connect(): void {
      this.connected = true;
    }
  }

  const composed = composeMpvRuntimeHandlers<
    FakeMpvClient,
    { isKnownWord: (text: string) => boolean },
    { 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: FakeMpvClient,
      getSocketPath: () => '/tmp/mpv.sock',
      getResolvedConfig: () => ({ auto_start_overlay: false }),
      isAutoStartOverlayEnabled: () => true,
      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: () => false,
        getFrequencyDictionaryEnabled: () => false,
        getFrequencyDictionaryMatchMode: () => 'headword',
        getFrequencyRank: () => null,
        getYomitanGroupDebugEnabled: () => false,
        getMecabTokenizer: () => null,
      },
      createTokenizerRuntimeDeps: () => ({ isKnownWord: () => false }),
      tokenizeSubtitle: async (text) => ({ text }),
      createMecabTokenizerAndCheckMainDeps: {
        getMecabTokenizer: () => mecabTokenizer,
        setMecabTokenizer: (next) => {
          mecabTokenizer = next as { id: string };
          calls.push('set-mecab');
        },
        createMecabTokenizer: () => {
          calls.push('create-mecab');
          return { id: 'mecab' };
        },
        checkAvailability: async () => {
          calls.push('check-mecab');
        },
      },
      prewarmSubtitleDictionariesMainDeps: {
        ensureJlptDictionaryLookup: async () => {},
        ensureFrequencyDictionaryLookup: async () => {},
      },
    },
    warmups: {
      launchBackgroundWarmupTaskMainDeps: {
        now: () => 0,
        logDebug: () => {},
        logWarn: () => {},
      },
      startBackgroundWarmupsMainDeps: {
        getStarted: () => false,
        setStarted: () => {},
        isTexthookerOnlyMode: () => false,
        ensureYomitanExtensionLoaded: async () => {},
        shouldWarmupMecab: () => false,
        shouldWarmupYomitanExtension: () => false,
        shouldWarmupSubtitleDictionaries: () => false,
        shouldWarmupJellyfinRemoteSession: () => false,
        shouldAutoConnectJellyfinRemote: () => false,
        startJellyfinRemoteSession: async () => {},
      },
    },
  });

  await composed.startTokenizationWarmups();

  assert.deepEqual(calls, []);
});

test('composeMpvRuntimeHandlers runs tokenization warmup once across sequential tokenize calls', async () => {
  let yomitanWarmupCalls = 0;
  let prewarmJlptCalls = 0;
  let prewarmFrequencyCalls = 0;
  const tokenizeCalls: string[] = [];

  const composed = composeMpvRuntimeHandlers<
    { connect: () => void; on: () => void },
    { isKnownWord: () => boolean },
    { 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: () => false,
        getFrequencyDictionaryEnabled: () => false,
        getFrequencyDictionaryMatchMode: () => 'headword',
        getFrequencyRank: () => null,
        getYomitanGroupDebugEnabled: () => false,
        getMecabTokenizer: () => null,
      },
      createTokenizerRuntimeDeps: () => ({ isKnownWord: () => false }),
      tokenizeSubtitle: async (text) => {
        tokenizeCalls.push(text);
        return { text };
      },
      createMecabTokenizerAndCheckMainDeps: {
        getMecabTokenizer: () => null,
        setMecabTokenizer: () => {},
        createMecabTokenizer: () => ({ id: 'mecab' }),
        checkAvailability: async () => {},
      },
      prewarmSubtitleDictionariesMainDeps: {
        ensureJlptDictionaryLookup: async () => {
          prewarmJlptCalls += 1;
        },
        ensureFrequencyDictionaryLookup: async () => {
          prewarmFrequencyCalls += 1;
        },
      },
    },
    warmups: {
      launchBackgroundWarmupTaskMainDeps: {
        now: () => 0,
        logDebug: () => {},
        logWarn: () => {},
      },
      startBackgroundWarmupsMainDeps: {
        getStarted: () => false,
        setStarted: () => {},
        isTexthookerOnlyMode: () => false,
        ensureYomitanExtensionLoaded: async () => {
          yomitanWarmupCalls += 1;
        },
        shouldWarmupMecab: () => false,
        shouldWarmupYomitanExtension: () => false,
        shouldWarmupSubtitleDictionaries: () => false,
        shouldWarmupJellyfinRemoteSession: () => false,
        shouldAutoConnectJellyfinRemote: () => false,
        startJellyfinRemoteSession: async () => {},
      },
    },
  });

  await composed.tokenizeSubtitle('first');
  await composed.tokenizeSubtitle('second');

  assert.deepEqual(tokenizeCalls, ['first', 'second']);
  assert.equal(yomitanWarmupCalls, 1);
  assert.equal(prewarmJlptCalls, 0);
  assert.equal(prewarmFrequencyCalls, 0);
});

test('composeMpvRuntimeHandlers does not block first tokenization on dictionary or MeCab warmup', async () => {
  const jlptDeferred = createDeferred();
  const frequencyDeferred = createDeferred();
  const mecabDeferred = createDeferred();
  let tokenizeResolved = false;

  const composed = composeMpvRuntimeHandlers<
    { connect: () => void; on: () => void },
    { isKnownWord: () => boolean },
    { 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: () => true,
        getMinSentenceWordsForNPlusOne: () => 3,
        getJlptLevel: () => null,
        getJlptEnabled: () => true,
        getFrequencyDictionaryEnabled: () => true,
        getFrequencyDictionaryMatchMode: () => 'headword',
        getFrequencyRank: () => null,
        getYomitanGroupDebugEnabled: () => false,
        getMecabTokenizer: () => null,
      },
      createTokenizerRuntimeDeps: () => ({ isKnownWord: () => false }),
      tokenizeSubtitle: async (text) => ({ text }),
      createMecabTokenizerAndCheckMainDeps: {
        getMecabTokenizer: () => null,
        setMecabTokenizer: () => {},
        createMecabTokenizer: () => ({ id: 'mecab' }),
        checkAvailability: async () => mecabDeferred.promise,
      },
      prewarmSubtitleDictionariesMainDeps: {
        ensureJlptDictionaryLookup: async () => jlptDeferred.promise,
        ensureFrequencyDictionaryLookup: async () => frequencyDeferred.promise,
      },
    },
    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 tokenizePromise = composed.tokenizeSubtitle('first line').then(() => {
    tokenizeResolved = true;
  });
  await new Promise<void>((resolve) => setImmediate(resolve));
  assert.equal(tokenizeResolved, true);

  jlptDeferred.resolve();
  frequencyDeferred.resolve();
  mecabDeferred.resolve();
  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',
    ]);
  },
);