feat: show mining frame toast on OSD and speed up stats session deletes

- Flash mined-frame screenshot as in-overlay image toast for OSD card notifications - Batch cover art from stored DB blobs via POST /api/stats/covers (no extra AniList fetches) - Show delete progress toast on stats home and sessions pages - Refresh only affected rollups on session delete instead of full rebuild - Rebuild lifetime summaries with aggregate SQL CTEs instead of per-session loop
2026-07-29 19:21:33 -07:00 · 2026-06-04 22:00:51 -07:00
parent ea79e331fa
commit b343f1cf5c
45 changed files with 1199 additions and 209 deletions
@@ -833,6 +833,56 @@ describe('stats server API routes', () => {
    assert.equal(res.status, 404);
  });

+  it('POST /api/stats/covers batches stored cover art without fetching missing art', async () => {
+    let ensureCoverArtCalls = 0;
+    const app = createStatsApp(
+      createMockTracker({
+        getCoverArt: async (videoId: number) =>
+          videoId === 7
+            ? {
+                videoId,
+                anilistId: null,
+                coverUrl: null,
+                coverBlob: Buffer.from([0x89, 0x50]),
+                titleRomaji: null,
+                titleEnglish: null,
+                episodesTotal: null,
+                fetchedAtMs: Date.now(),
+              }
+            : null,
+        ensureCoverArt: async () => {
+          ensureCoverArtCalls += 1;
+          return true;
+        },
+      }),
+    );
+
+    const res = await app.request('/api/stats/covers', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ animeIds: [1, 99999], videoIds: [7, 99999] }),
+    });
+
+    assert.equal(res.status, 200);
+    assert.deepEqual(await res.json(), {
+      anime: {
+        1: {
+          contentType: 'image/jpeg',
+          dataUrl: 'data:image/jpeg;base64,/9j/2Q==',
+        },
+        99999: null,
+      },
+      media: {
+        7: {
+          contentType: 'image/jpeg',
+          dataUrl: 'data:image/jpeg;base64,iVA=',
+        },
+        99999: null,
+      },
+    });
+    assert.equal(ensureCoverArtCalls, 0);
+  });
+
  it('GET /api/stats/anime/:animeId/words returns top words for an anime', async () => {
    let seenArgs: unknown[] = [];
    const app = createStatsApp(
@@ -605,6 +605,79 @@ test('split maintenance helpers update anime metadata and watched state', () =>
  }
 });

+test('deleteSessions refreshes only rollups affected by deleted sessions', () => {
+  const { db, dbPath } = createDb();
+
+  try {
+    const keepVideoId = getOrCreateVideoRecord(db, 'local:/tmp/rollup-keep.mkv', {
+      canonicalTitle: 'Rollup Keep',
+      sourcePath: '/tmp/rollup-keep.mkv',
+      sourceUrl: null,
+      sourceType: SOURCE_TYPE_LOCAL,
+    });
+    const dropVideoId = getOrCreateVideoRecord(db, 'local:/tmp/rollup-drop.mkv', {
+      canonicalTitle: 'Rollup Drop',
+      sourcePath: '/tmp/rollup-drop.mkv',
+      sourceUrl: null,
+      sourceType: SOURCE_TYPE_LOCAL,
+    });
+
+    const keepStartedAtMs = 1_700_000_000_000;
+    const dropStartedAtMs = 1_700_086_400_000;
+    const keepSessionId = startSessionRecord(db, keepVideoId, keepStartedAtMs).sessionId;
+    const dropSessionId = startSessionRecord(db, dropVideoId, dropStartedAtMs).sessionId;
+    finalizeSessionMetrics(db, keepSessionId, keepStartedAtMs, {
+      activeWatchedMs: 30_000,
+      cardsMined: 1,
+    });
+    finalizeSessionMetrics(db, dropSessionId, dropStartedAtMs, {
+      activeWatchedMs: 60_000,
+      cardsMined: 2,
+    });
+
+    const keepDay = getLocalEpochDay(db, keepStartedAtMs);
+    const dropDay = getLocalEpochDay(db, dropStartedAtMs);
+    const keepMonth = 202311;
+    const dropMonth = 202311;
+
+    const insertDaily = db.prepare(`
+      INSERT INTO imm_daily_rollups (
+        rollup_day, video_id, total_sessions, total_active_min, total_lines_seen,
+        total_tokens_seen, total_cards, CREATED_DATE, LAST_UPDATE_DATE
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const insertMonthly = db.prepare(`
+      INSERT INTO imm_monthly_rollups (
+        rollup_month, video_id, total_sessions, total_active_min, total_lines_seen,
+        total_tokens_seen, total_cards, CREATED_DATE, LAST_UPDATE_DATE
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    insertDaily.run(keepDay, keepVideoId, 1, 0.5, 3, 6, 1, keepStartedAtMs, keepStartedAtMs);
+    insertDaily.run(dropDay, dropVideoId, 1, 1, 3, 6, 2, dropStartedAtMs, dropStartedAtMs);
+    insertMonthly.run(keepMonth, keepVideoId, 1, 0.5, 3, 6, 1, keepStartedAtMs, keepStartedAtMs);
+    insertMonthly.run(dropMonth, dropVideoId, 1, 1, 3, 6, 2, dropStartedAtMs, dropStartedAtMs);
+
+    deleteSessions(db, [dropSessionId]);
+
+    const dailyRows = db
+      .prepare('SELECT rollup_day, video_id, total_cards FROM imm_daily_rollups ORDER BY video_id')
+      .all() as Array<{ rollup_day: number; video_id: number; total_cards: number }>;
+    const monthlyRows = db
+      .prepare(
+        'SELECT rollup_month, video_id, total_cards FROM imm_monthly_rollups ORDER BY video_id',
+      )
+      .all() as Array<{ rollup_month: number; video_id: number; total_cards: number }>;
+
+    assert.deepEqual(dailyRows, [{ rollup_day: keepDay, video_id: keepVideoId, total_cards: 1 }]);
+    assert.deepEqual(monthlyRows, [
+      { rollup_month: keepMonth, video_id: keepVideoId, total_cards: 1 },
+    ]);
+  } finally {
+    db.close();
+    cleanupDbPath(dbPath);
+  }
+});
+
 test('split maintenance helpers delete multiple sessions and whole videos with dependent rows', () => {
  const { db, dbPath, stmts } = createDb();

@@ -60,6 +60,34 @@ interface RetainedSessionRow {
  mediaBufferEvents: number;
 }

+const RETAINED_SESSION_METRICS_CTE = `
+  retained_sessions AS (
+    SELECT
+      s.session_id,
+      s.video_id,
+      v.anime_id,
+      s.started_at_ms,
+      s.ended_at_ms,
+      MAX(COALESCE(t.active_watched_ms, s.active_watched_ms, 0), 0) AS active_ms,
+      MAX(COALESCE(t.cards_mined, s.cards_mined, 0), 0) AS cards_mined,
+      MAX(COALESCE(t.lines_seen, s.lines_seen, 0), 0) AS lines_seen,
+      MAX(COALESCE(t.tokens_seen, s.tokens_seen, 0), 0) AS tokens_seen,
+      CASE WHEN v.watched > 0 THEN 1 ELSE 0 END AS completed
+    FROM imm_sessions s
+    JOIN imm_videos v
+      ON v.video_id = s.video_id
+    LEFT JOIN imm_session_telemetry t
+      ON t.telemetry_id = (
+        SELECT telemetry_id
+        FROM imm_session_telemetry
+        WHERE session_id = s.session_id
+        ORDER BY sample_ms DESC, telemetry_id DESC
+        LIMIT 1
+      )
+    WHERE s.ended_at_ms IS NOT NULL
+  )
+`;
+
 function hasRetainedPriorSession(
  db: DatabaseSync,
  videoId: number,
@@ -154,54 +182,150 @@ function rebuildLifetimeSummariesInternal(
  db: DatabaseSync,
  rebuiltAtMs: number,
 ): LifetimeRebuildSummary {
-  const rows = db
-    .prepare(
-      `
-      SELECT
-        session_id AS sessionId,
-        video_id AS videoId,
-        started_at_ms AS startedAtMs,
-        ended_at_ms AS endedAtMs,
-        ended_media_ms AS lastMediaMs,
-        total_watched_ms AS totalWatchedMs,
-        active_watched_ms AS activeWatchedMs,
-        lines_seen AS linesSeen,
-        tokens_seen AS tokensSeen,
-        cards_mined AS cardsMined,
-        lookup_count AS lookupCount,
-        lookup_hits AS lookupHits,
-        yomitan_lookup_count AS yomitanLookupCount,
-        pause_count AS pauseCount,
-        pause_ms AS pauseMs,
-        seek_forward_count AS seekForwardCount,
-        seek_backward_count AS seekBackwardCount,
-        media_buffer_events AS mediaBufferEvents
-      FROM imm_sessions
-      WHERE ended_at_ms IS NOT NULL
-      ORDER BY started_at_ms ASC, session_id ASC
-      `,
-    )
-    .all() as Array<
-    Omit<RetainedSessionRow, 'startedAtMs' | 'endedAtMs' | 'lastMediaMs'> & {
-      startedAtMs: number | string;
-      endedAtMs: number | string;
-      lastMediaMs: number | string | null;
-    }
-  >;
-  const sessions = rows.map((row) => ({
-    ...row,
-    startedAtMs: row.startedAtMs,
-    endedAtMs: row.endedAtMs,
-    lastMediaMs: row.lastMediaMs === null ? null : Number(row.lastMediaMs),
-  })) as RetainedSessionRow[];
+  const rebuiltAtDbMs = toDbTimestamp(rebuiltAtMs);
+  const appliedSessions = Number(
+    (
+      db
+        .prepare('SELECT COUNT(*) AS total FROM imm_sessions WHERE ended_at_ms IS NOT NULL')
+        .get() as { total: number }
+    ).total,
+  );

  resetLifetimeSummaries(db, rebuiltAtMs);
-  for (const session of sessions) {
-    applySessionLifetimeSummary(db, toRebuildSessionState(session), session.endedAtMs);
-  }
+
+  db.prepare(
+    `
+    INSERT INTO imm_lifetime_applied_sessions (
+      session_id,
+      applied_at_ms,
+      CREATED_DATE,
+      LAST_UPDATE_DATE
+    )
+    SELECT
+      session_id,
+      ended_at_ms,
+      ?,
+      ?
+    FROM imm_sessions
+    WHERE ended_at_ms IS NOT NULL
+    `,
+  ).run(rebuiltAtDbMs, rebuiltAtDbMs);
+
+  db.prepare(
+    `
+    WITH ${RETAINED_SESSION_METRICS_CTE}
+    INSERT INTO imm_lifetime_media (
+      video_id,
+      total_sessions,
+      total_active_ms,
+      total_cards,
+      total_lines_seen,
+      total_tokens_seen,
+      completed,
+      first_watched_ms,
+      last_watched_ms,
+      CREATED_DATE,
+      LAST_UPDATE_DATE
+    )
+    SELECT
+      video_id,
+      COUNT(*) AS total_sessions,
+      COALESCE(SUM(active_ms), 0) AS total_active_ms,
+      COALESCE(SUM(cards_mined), 0) AS total_cards,
+      COALESCE(SUM(lines_seen), 0) AS total_lines_seen,
+      COALESCE(SUM(tokens_seen), 0) AS total_tokens_seen,
+      MAX(completed) AS completed,
+      MIN(started_at_ms) AS first_watched_ms,
+      MAX(ended_at_ms) AS last_watched_ms,
+      ? AS CREATED_DATE,
+      ? AS LAST_UPDATE_DATE
+    FROM retained_sessions
+    GROUP BY video_id
+    `,
+  ).run(rebuiltAtDbMs, rebuiltAtDbMs);
+
+  db.prepare(
+    `
+    WITH ${RETAINED_SESSION_METRICS_CTE}
+    INSERT INTO imm_lifetime_anime (
+      anime_id,
+      total_sessions,
+      total_active_ms,
+      total_cards,
+      total_lines_seen,
+      total_tokens_seen,
+      episodes_started,
+      episodes_completed,
+      first_watched_ms,
+      last_watched_ms,
+      CREATED_DATE,
+      LAST_UPDATE_DATE
+    )
+    SELECT
+      anime_id,
+      COUNT(*) AS total_sessions,
+      COALESCE(SUM(active_ms), 0) AS total_active_ms,
+      COALESCE(SUM(cards_mined), 0) AS total_cards,
+      COALESCE(SUM(lines_seen), 0) AS total_lines_seen,
+      COALESCE(SUM(tokens_seen), 0) AS total_tokens_seen,
+      COUNT(DISTINCT video_id) AS episodes_started,
+      COUNT(DISTINCT CASE WHEN completed > 0 THEN video_id END) AS episodes_completed,
+      MIN(started_at_ms) AS first_watched_ms,
+      MAX(ended_at_ms) AS last_watched_ms,
+      ? AS CREATED_DATE,
+      ? AS LAST_UPDATE_DATE
+    FROM retained_sessions
+    WHERE anime_id IS NOT NULL
+    GROUP BY anime_id
+    `,
+  ).run(rebuiltAtDbMs, rebuiltAtDbMs);
+
+  db.prepare(
+    `
+    WITH ${RETAINED_SESSION_METRICS_CTE},
+    anime_completion AS (
+      SELECT
+        rs.anime_id,
+        MAX(a.episodes_total) AS episodes_total,
+        COUNT(DISTINCT CASE WHEN rs.completed > 0 THEN rs.video_id END) AS completed_videos
+      FROM retained_sessions rs
+      JOIN imm_anime a
+        ON a.anime_id = rs.anime_id
+      WHERE rs.anime_id IS NOT NULL
+      GROUP BY rs.anime_id
+    )
+    UPDATE imm_lifetime_global
+    SET
+      total_sessions = (SELECT COUNT(*) FROM retained_sessions),
+      total_active_ms = (SELECT COALESCE(SUM(active_ms), 0) FROM retained_sessions),
+      total_cards = (SELECT COALESCE(SUM(cards_mined), 0) FROM retained_sessions),
+      active_days = (
+        SELECT COUNT(DISTINCT CAST(
+          julianday(CAST(started_at_ms AS REAL) / 1000, 'unixepoch', 'localtime') - 2440587.5
+          AS INTEGER
+        ))
+        FROM retained_sessions
+      ),
+      episodes_started = (SELECT COUNT(DISTINCT video_id) FROM retained_sessions),
+      episodes_completed = (
+        SELECT COUNT(DISTINCT CASE WHEN completed > 0 THEN video_id END)
+        FROM retained_sessions
+      ),
+      anime_completed = (
+        SELECT COUNT(*)
+        FROM anime_completion
+        WHERE episodes_total IS NOT NULL
+          AND episodes_total > 0
+          AND completed_videos >= episodes_total
+      ),
+      last_rebuilt_ms = ?,
+      LAST_UPDATE_DATE = ?
+    WHERE global_id = 1
+    `,
+  ).run(rebuiltAtDbMs, rebuiltAtDbMs);

  return {
-    appliedSessions: sessions.length,
+    appliedSessions,
    rebuiltAtMs,
  };
 }
@@ -1,6 +1,6 @@
 import type { DatabaseSync } from './sqlite';
 import { nowMs } from './time';
-import { subtractDbTimestamp, toDbTimestamp } from './query-shared';
+import { makePlaceholders, subtractDbTimestamp, toDbTimestamp } from './query-shared';

 const ROLLUP_STATE_KEY = 'last_rollup_sample_ms';
 const DAILY_MS = 86_400_000;
@@ -20,6 +20,12 @@ interface RollupTelemetryResult {
  maxSampleMs: number | null;
 }

+export interface RollupGroup {
+  rollupDay: number;
+  rollupMonth: number;
+  videoId: number;
+}
+
 interface RawRetentionResult {
  deletedSessionEvents: number;
  deletedTelemetryRows: number;
@@ -164,6 +170,26 @@ function upsertDailyRollupsForGroups(
  }

  const upsertStmt = db.prepare(`
+    WITH matching_sessions AS (
+      SELECT *
+      FROM imm_sessions
+      WHERE CAST(julianday(CAST(started_at_ms AS REAL) / 1000, 'unixepoch', 'localtime') - 2440587.5 AS INTEGER) = ?
+        AND video_id = ?
+    ),
+    session_metrics AS (
+      SELECT
+        t.session_id,
+        MAX(t.active_watched_ms) AS max_active_ms,
+        MAX(t.lines_seen) AS max_lines,
+        MAX(t.tokens_seen) AS max_tokens,
+        MAX(t.cards_mined) AS max_cards,
+        MAX(t.lookup_count) AS max_lookups,
+        MAX(t.lookup_hits) AS max_hits
+      FROM imm_session_telemetry t
+      JOIN matching_sessions s
+        ON s.session_id = t.session_id
+      GROUP BY t.session_id
+    )
    INSERT INTO imm_daily_rollups (
      rollup_day, video_id, total_sessions, total_active_min, total_lines_seen,
      total_tokens_seen, total_cards, cards_per_hour,
@@ -197,20 +223,8 @@ function upsertDailyRollupsForGroups(
      END AS lookup_hit_rate,
      ? AS CREATED_DATE,
      ? AS LAST_UPDATE_DATE
-    FROM imm_sessions s
-    LEFT JOIN (
-      SELECT
-        t.session_id,
-        MAX(t.active_watched_ms) AS max_active_ms,
-        MAX(t.lines_seen) AS max_lines,
-        MAX(t.tokens_seen) AS max_tokens,
-        MAX(t.cards_mined) AS max_cards,
-        MAX(t.lookup_count) AS max_lookups,
-        MAX(t.lookup_hits) AS max_hits
-      FROM imm_session_telemetry t
-      GROUP BY t.session_id
-    ) sm ON s.session_id = sm.session_id
-    WHERE CAST(julianday(s.started_at_ms / 1000, 'unixepoch', 'localtime') - 2440587.5 AS INTEGER) = ? AND s.video_id = ?
+    FROM matching_sessions s
+    LEFT JOIN session_metrics sm ON s.session_id = sm.session_id
    GROUP BY rollup_day, s.video_id
    ON CONFLICT (rollup_day, video_id) DO UPDATE SET
      total_sessions = excluded.total_sessions,
@@ -226,7 +240,7 @@ function upsertDailyRollupsForGroups(
  `);

  for (const { rollupDay, videoId } of groups) {
-    upsertStmt.run(rollupNowMs, rollupNowMs, rollupDay, videoId);
+    upsertStmt.run(rollupDay, videoId, rollupNowMs, rollupNowMs);
  }
 }

@@ -240,6 +254,24 @@ function upsertMonthlyRollupsForGroups(
  }

  const upsertStmt = db.prepare(`
+    WITH matching_sessions AS (
+      SELECT *
+      FROM imm_sessions
+      WHERE CAST(strftime('%Y%m', CAST(started_at_ms AS REAL) / 1000, 'unixepoch', 'localtime') AS INTEGER) = ?
+        AND video_id = ?
+    ),
+    session_metrics AS (
+      SELECT
+        t.session_id,
+        MAX(t.active_watched_ms) AS max_active_ms,
+        MAX(t.lines_seen) AS max_lines,
+        MAX(t.tokens_seen) AS max_tokens,
+        MAX(t.cards_mined) AS max_cards
+      FROM imm_session_telemetry t
+      JOIN matching_sessions s
+        ON s.session_id = t.session_id
+      GROUP BY t.session_id
+    )
    INSERT INTO imm_monthly_rollups (
      rollup_month, video_id, total_sessions, total_active_min, total_lines_seen,
      total_tokens_seen, total_cards, CREATED_DATE, LAST_UPDATE_DATE
@@ -254,18 +286,8 @@ function upsertMonthlyRollupsForGroups(
      COALESCE(SUM(COALESCE(sm.max_cards, s.cards_mined)), 0) AS total_cards,
      ? AS CREATED_DATE,
      ? AS LAST_UPDATE_DATE
-    FROM imm_sessions s
-    LEFT JOIN (
-      SELECT
-        t.session_id,
-        MAX(t.active_watched_ms) AS max_active_ms,
-        MAX(t.lines_seen) AS max_lines,
-        MAX(t.tokens_seen) AS max_tokens,
-        MAX(t.cards_mined) AS max_cards
-      FROM imm_session_telemetry t
-      GROUP BY t.session_id
-    ) sm ON s.session_id = sm.session_id
-    WHERE CAST(strftime('%Y%m', s.started_at_ms / 1000, 'unixepoch', 'localtime') AS INTEGER) = ? AND s.video_id = ?
+    FROM matching_sessions s
+    LEFT JOIN session_metrics sm ON s.session_id = sm.session_id
    GROUP BY rollup_month, s.video_id
    ON CONFLICT (rollup_month, video_id) DO UPDATE SET
      total_sessions = excluded.total_sessions,
@@ -278,10 +300,82 @@ function upsertMonthlyRollupsForGroups(
  `);

  for (const { rollupMonth, videoId } of groups) {
-    upsertStmt.run(rollupNowMs, rollupNowMs, rollupMonth, videoId);
+    upsertStmt.run(rollupMonth, videoId, rollupNowMs, rollupNowMs);
  }
 }

+export function getRollupGroupsForSessions(db: DatabaseSync, sessionIds: number[]): RollupGroup[] {
+  if (sessionIds.length === 0) {
+    return [];
+  }
+
+  const placeholders = makePlaceholders(sessionIds);
+  const rows = db
+    .prepare(
+      `
+        SELECT DISTINCT
+          CAST(julianday(CAST(started_at_ms AS REAL) / 1000, 'unixepoch', 'localtime') - 2440587.5 AS INTEGER) AS rollup_day,
+          CAST(strftime('%Y%m', CAST(started_at_ms AS REAL) / 1000, 'unixepoch', 'localtime') AS INTEGER) AS rollup_month,
+          video_id
+        FROM imm_sessions
+        WHERE session_id IN (${placeholders})
+        UNION
+        SELECT DISTINCT
+          CAST(CAST(started_at_ms AS REAL) / 86400000 AS INTEGER) AS rollup_day,
+          CAST(strftime('%Y%m', CAST(started_at_ms AS REAL) / 1000, 'unixepoch') AS INTEGER) AS rollup_month,
+          video_id
+        FROM imm_sessions
+        WHERE session_id IN (${placeholders})
+      `,
+    )
+    .all(...sessionIds, ...sessionIds) as RollupGroupRow[];
+
+  return rows.map((row) => ({
+    rollupDay: row.rollup_day,
+    rollupMonth: row.rollup_month,
+    videoId: row.video_id,
+  }));
+}
+
+export function refreshRollupsForGroupsInTransaction(
+  db: DatabaseSync,
+  groups: RollupGroup[],
+): void {
+  if (groups.length === 0) {
+    return;
+  }
+
+  const rollupNowMs = toDbTimestamp(nowMs());
+  const dailyGroups = dedupeGroups(
+    groups.map((group) => ({
+      rollupDay: group.rollupDay,
+      videoId: group.videoId,
+    })),
+  );
+  const monthlyGroups = dedupeGroups(
+    groups.map((group) => ({
+      rollupMonth: group.rollupMonth,
+      videoId: group.videoId,
+    })),
+  );
+  const deleteDailyStmt = db.prepare(
+    'DELETE FROM imm_daily_rollups WHERE rollup_day = ? AND video_id = ?',
+  );
+  const deleteMonthlyStmt = db.prepare(
+    'DELETE FROM imm_monthly_rollups WHERE rollup_month = ? AND video_id = ?',
+  );
+
+  for (const { rollupDay, videoId } of dailyGroups) {
+    deleteDailyStmt.run(rollupDay, videoId);
+  }
+  for (const { rollupMonth, videoId } of monthlyGroups) {
+    deleteMonthlyStmt.run(rollupMonth, videoId);
+  }
+
+  upsertDailyRollupsForGroups(db, dailyGroups, rollupNowMs);
+  upsertMonthlyRollupsForGroups(db, monthlyGroups, rollupNowMs);
+}
+
 function getAffectedRollupGroups(
  db: DatabaseSync,
  lastRollupSampleMs: number | string,
@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import type { DatabaseSync } from './sqlite';
 import { buildCoverBlobReference, normalizeCoverBlobBytes } from './storage';
 import { rebuildLifetimeSummariesInTransaction } from './lifetime';
-import { rebuildRollupsInTransaction } from './maintenance';
+import { getRollupGroupsForSessions, refreshRollupsForGroupsInTransaction } from './maintenance';
 import { nowMs } from './time';
 import { PartOfSpeech, type MergedToken } from '../../../types';
 import { shouldExcludeTokenFromVocabularyPersistence } from '../tokenizer/annotation-stage';
@@ -474,13 +474,14 @@ export function deleteSession(db: DatabaseSync, sessionId: number): void {
  const sessionIds = [sessionId];
  const affectedWordIds = getAffectedWordIdsForSessions(db, sessionIds);
  const affectedKanjiIds = getAffectedKanjiIdsForSessions(db, sessionIds);
+  const affectedRollupGroups = getRollupGroupsForSessions(db, sessionIds);

  db.exec('BEGIN IMMEDIATE');
  try {
    deleteSessionsByIds(db, sessionIds);
    refreshLexicalAggregates(db, affectedWordIds, affectedKanjiIds);
    rebuildLifetimeSummariesInTransaction(db);
-    rebuildRollupsInTransaction(db);
+    refreshRollupsForGroupsInTransaction(db, affectedRollupGroups);
    db.exec('COMMIT');
  } catch (error) {
    db.exec('ROLLBACK');
@@ -492,13 +493,14 @@ export function deleteSessions(db: DatabaseSync, sessionIds: number[]): void {
  if (sessionIds.length === 0) return;
  const affectedWordIds = getAffectedWordIdsForSessions(db, sessionIds);
  const affectedKanjiIds = getAffectedKanjiIdsForSessions(db, sessionIds);
+  const affectedRollupGroups = getRollupGroupsForSessions(db, sessionIds);

  db.exec('BEGIN IMMEDIATE');
  try {
    deleteSessionsByIds(db, sessionIds);
    refreshLexicalAggregates(db, affectedWordIds, affectedKanjiIds);
    rebuildLifetimeSummariesInTransaction(db);
-    rebuildRollupsInTransaction(db);
+    refreshRollupsForGroupsInTransaction(db, affectedRollupGroups);
    db.exec('COMMIT');
  } catch (error) {
    db.exec('ROLLBACK');
@@ -536,7 +538,6 @@ export function deleteVideo(db: DatabaseSync, videoId: number): void {
    db.prepare('DELETE FROM imm_videos WHERE video_id = ?').run(videoId);
    refreshLexicalAggregates(db, affectedWordIds, affectedKanjiIds);
    rebuildLifetimeSummariesInTransaction(db);
-    rebuildRollupsInTransaction(db);
    db.exec('COMMIT');
  } catch (error) {
    db.exec('ROLLBACK');
@@ -27,6 +27,16 @@ type StatsExcludedWordPayload = {
  reading: string;
 };

+type StatsCoverImagePayload = {
+  contentType: 'image/jpeg';
+  dataUrl: string;
+} | null;
+
+type StatsCoverBatchBody = {
+  animeIds?: unknown;
+  videoIds?: unknown;
+};
+
 function parseIntQuery(raw: string | undefined, fallback: number, maxLimit?: number): number {
  if (raw === undefined) return fallback;
  const n = Number(raw);
@@ -73,6 +83,31 @@ function parseExcludedWordsBody(body: unknown): StatsExcludedWordPayload[] | nul
  return words;
 }

+function parsePositiveIdList(raw: unknown, maxItems = 100): number[] {
+  if (!Array.isArray(raw)) return [];
+
+  const ids = new Set<number>();
+  for (const rawId of raw) {
+    const id = typeof rawId === 'number' ? rawId : typeof rawId === 'string' ? Number(rawId) : NaN;
+    if (Number.isFinite(id) && id > 0) {
+      ids.add(Math.floor(id));
+      if (ids.size >= maxItems) break;
+    }
+  }
+
+  return Array.from(ids).sort((a, b) => a - b);
+}
+
+function coverImagePayload(
+  art: { coverBlob?: Uint8Array | null } | null | undefined,
+): StatsCoverImagePayload {
+  if (!art?.coverBlob) return null;
+  return {
+    contentType: 'image/jpeg',
+    dataUrl: `data:image/jpeg;base64,${Buffer.from(art.coverBlob).toString('base64')}`,
+  };
+}
+
 function resolveStatsNoteFieldName(
  noteInfo: StatsServerNoteInfo,
  ...preferredNames: (string | undefined)[]
@@ -707,6 +742,27 @@ export function createStatsApp(
    return c.json({ ok: true });
  });

+  app.post('/api/stats/covers', async (c) => {
+    const body = (await c.req.json().catch(() => null)) as StatsCoverBatchBody | null;
+    const animeIds = parsePositiveIdList(body?.animeIds);
+    const videoIds = parsePositiveIdList(body?.videoIds);
+    const anime: Record<string, StatsCoverImagePayload> = {};
+    const media: Record<string, StatsCoverImagePayload> = {};
+
+    await Promise.all(
+      animeIds.map(async (animeId) => {
+        anime[String(animeId)] = coverImagePayload(await tracker.getAnimeCoverArt(animeId));
+      }),
+    );
+    await Promise.all(
+      videoIds.map(async (videoId) => {
+        media[String(videoId)] = coverImagePayload(await tracker.getCoverArt(videoId));
+      }),
+    );
+
+    return c.json({ anime, media });
+  });
+
  app.get('/api/stats/anime/:animeId/cover', async (c) => {
    const animeId = parseIntQuery(c.req.param('animeId'), 0);
    if (animeId <= 0) return c.body(null, 404);