Discovery scores AniList seeds with slot mix and isAdult filter (BL-0051)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

test/discovery.test.js

@@ -4,8 +4,9 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { generate } = require('../discovery/engine');
+const { generate, generateAsync, buildCandidates, feedForUser, mixSlots, mergeUserFeed, MAX_CANDIDATES, SLOTS } = require('../discovery/engine');
 const { DiscoveryStore } = require('../discovery/store');
+const { DiscoveryCache } = require('../discovery/cache');
 
 test('discovery is bounded, diversified, opt-in, evidence-linked and user-specific', () => {
   const { loadCatalog } = require('../greatest');
@@ -16,7 +17,7 @@ test('discovery is bounded, diversified, opt-in, evidence-linked and user-specif
   const db = { users, greatestRatings: { alice: { [greatest.entries[0].id]: 'flame' },
     bob: { [greatest.entries[20].id]: 'flame' } }, discoveryFeedback: { alice: {} }, progress: {} };
   const result = generate({ db, library: [], greatest, cacheDir: path.join(os.tmpdir(), 'nonexistent-discovery-cache') });
-  assert.equal(Object.keys(result.candidates).length, 50);
+  assert.equal(Object.keys(result.candidates).length, Math.min(2000, result.examined));
   assert.ok(result.feeds.alice.items.length > 0 && result.feeds.alice.items.length <= 20);
   assert.ok(result.feeds.bob.items.length > 0);
   assert.equal(result.feeds.off.disabled, true);
@@ -85,3 +86,225 @@ test('patch refuses a corrupt store', t => {
   assert.throws(() => store.patch({ harvest: {} }), /refusing to overwrite/);
   assert.equal(fs.readFileSync(store.file, 'utf8'), '{broken');
 });
+
+// ---- Wider pool (BL-0051): AniList seeds, new score parts, slot mix ----
+const NOW = () => new Date('2026-10-25T12:00:00Z');
+const FETCHED_AT = '2026-10-20T00:00:00.000Z';
+const NO_SCRAPER_CACHE = path.join(os.tmpdir(), 'nonexistent-discovery-cache');
+const AUTHOR = { staffId: 7, name: 'Author Seven', role: 'Story' };
+function seedRecord(id, extra = {}) {
+  return { anilistId: id, title: `Seed ${id}`, altTitles: [], format: 'MANGA', isAdult: false, status: 'completed',
+    year: 2010, averageScore: 70, popularity: 1000, trending: 0,
+    tags: [{ name: 'Action', rank: 90, kind: 'genre', isAdult: false }],
+    authors: [{ staffId: 900 + id, name: `Writer ${id}`, role: 'Story' }],
+    coverUrl: `https://img.example/${id}.jpg`, siteUrl: `https://anilist.co/manga/${id}`, ...extra };
+}
+const seed = (id, extra) => ({ anilistId: id, record: seedRecord(id, extra) });
+function harvestFixture(t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mc-discovery-harvest-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const cache = new DiscoveryCache(dir, { now: () => Date.parse(FETCHED_AT) });
+  cache.put('title', 100, seedRecord(100, { title: 'Anchor One', authors: [AUTHOR],
+    tags: [{ name: 'Drama', rank: 100, kind: 'genre', isAdult: false }, { name: 'Time Skip', rank: 80, kind: 'tag', isAdult: false }] }));
+  cache.put('recs', 100, [
+    { ...seed(201), rating: 42 },
+    { ...seed(209, { authors: [AUTHOR] }), rating: 10 },
+    { ...seed(207, { isAdult: true }), rating: 5 },
+    { ...seed(208, { tags: [{ name: 'Nudity', rank: 65, kind: 'tag', isAdult: true }] }), rating: 5 },
+    { ...seed(212), rating: 3 },
+  ]);
+  cache.put('creator', 7, [{ ...seed(202, { authors: [AUTHOR] }), role: 'Story' }, { ...seed(209, { authors: [AUTHOR] }), role: 'Story' }]);
+  cache.put('tagTop', 'genre:Drama', [seed(203, { averageScore: 80, tags: [{ name: 'Drama', rank: 90, kind: 'genre', isAdult: false }] })]);
+  cache.put('tagTop', 'tag:Time Skip', [seed(204, { averageScore: 70 })]);
+  cache.put('fresh', 'global', [seed(205, { status: 'ongoing', year: 2025 }), seed(206, { status: 'ongoing', year: 2020 }),
+    seed(210, { title: 'Owned Title', year: 2020 }), seed(211, { title: 'Queued Title' }), seed(213, { status: 'ongoing', year: 2026 })]);
+  return cache;
+}
+const fixtureGreatest = { entries: [
+  { id: 'g1', title: 'Anchor One', period: '2000s', rank: 1, note: '', metadata: { id: 100 } },
+  { id: 'g2', title: 'Voted Two', period: '1990s', rank: 2, note: '', metadata: { id: 212 } },
+] };
+function fixtureWorld(t, settings = {}) {
+  const user = { name: 'alice', settings: { discoveryEnabled: true, ...settings } };
+  const db = { users: { alice: user }, greatestRatings: { alice: { g1: 'flame', g2: 'good' } },
+    discoveryFeedback: { alice: { 'anilist:213': 'dismissed' } }, progress: {} };
+  const library = [{ id: 'm1', title: 'Owned Title', meta: { year: 2020, 'x-anilist': { id: 210 } } }];
+  return { user, db, library, greatest: fixtureGreatest, harvestCache: harvestFixture(t), queuedTitles: ['Queued Title'] };
+}
+function fixtureFeed(t, settings) {
+  const world = fixtureWorld(t, settings);
+  const candidates = buildCandidates({ greatest: world.greatest, library: world.library, cacheDir: NO_SCRAPER_CACHE, harvestCache: world.harvestCache });
+  const feed = feedForUser({ ...world, candidates, now: NOW });
+  return { world, candidates, feed, item: id => feed.items.find(item => item.candidateId === `anilist:${id}`) };
+}
+
+test('engine: empty harvest cache equals Phase A pool', t => {
+  const { loadCatalog } = require('../greatest');
+  const greatest = loadCatalog();
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mc-discovery-empty-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  const db = { users: {}, greatestRatings: {}, discoveryFeedback: {}, progress: {} };
+  const without = generate({ db, library: [], greatest, cacheDir: NO_SCRAPER_CACHE });
+  const withEmpty = generate({ db, library: [], greatest, cacheDir: NO_SCRAPER_CACHE, harvestCache: new DiscoveryCache(dir) });
+  assert.equal(MAX_CANDIDATES, 2000);
+  assert.deepEqual(Object.keys(withEmpty.candidates).sort(), Object.keys(without.candidates).sort());
+});
+
+test('harvested records join the pool and fill Greatest candidates', t => {
+  const { candidates } = fixtureFeed(t);
+  const byId = new Map(candidates.map(c => [c.id, c]));
+  for (const id of [201, 202, 203, 204, 205, 206, 207, 208, 209]) assert.ok(byId.has(`anilist:${id}`), `anilist:${id}`);
+  const fromRecs = byId.get('anilist:201');
+  assert.equal(fromRecs.isAdult, false);
+  assert.equal(fromRecs.averageScore, 70);
+  assert.deepEqual(fromRecs.tags, ['Action']);
+  assert.deepEqual(fromRecs.authors, ['Writer 201']);
+  assert.equal(fromRecs.tagRecords[0].rank, 90);
+  assert.equal(fromRecs.authorRecords[0].staffId, 1101);
+  assert.equal(fromRecs.fetchedAt, FETCHED_AT);
+  const greatestOne = byId.get('anilist:212');
+  assert.equal(greatestOne.greatestId, 'g2');
+  assert.equal(greatestOne.title, 'Voted Two');
+  assert.equal(greatestOne.isAdult, false);
+  assert.equal(greatestOne.tagRecords.length, 1);
+});
+
+test('community rec, creator, tagTop and fresh parts and reasons', t => {
+  const { item } = fixtureFeed(t);
+  const rec = item(201);
+  assert.equal(rec.scoreParts.communityRec, 3.71);
+  assert.equal(rec.group, 'recs');
+  assert.equal(rec.reason, 'AniList readers who liked Anchor One recommend this (42).');
+  const recEvidence = rec.evidence.find(e => e.id === 'rec:100:anilist:201');
+  assert.equal(recEvidence.kind, 'recommendation');
+  assert.equal(recEvidence.fetchedAt, FETCHED_AT);
+  assert.equal(recEvidence.url, 'https://anilist.co/manga/201');
+  assert.ok(rec.evidenceIds.includes('rec:100:anilist:201'));
+
+  const creator = item(202);
+  assert.equal(creator.scoreParts.sameCreator, 4);
+  assert.equal(creator.group, 'creator');
+  assert.equal(creator.reason, 'Also by Author Seven — you liked Anchor One.');
+  const creatorEvidence = creator.evidence.find(e => e.id === 'creator:7:anilist:202');
+  assert.equal(creatorEvidence.kind, 'creator');
+  assert.equal(creatorEvidence.fetchedAt, FETCHED_AT);
+
+  const top = item(203);
+  assert.equal(top.scoreParts.tagTop, 3);
+  assert.equal(top.group, 'tagTop');
+  assert.equal(top.reason, 'Top-rated in Drama, one of your most-liked tags.');
+  assert.equal(top.evidence.find(e => e.id === 'tagtop:genre:Drama:anilist:203').kind, 'tag-top');
+  assert.equal(item(204).scoreParts.tagTop, 0, 'averageScore below 75 earns no tagTop part');
+
+  const fresh = item(205);
+  assert.equal(fresh.scoreParts.fresh, 2);
+  assert.equal(fresh.group, 'fresh');
+  assert.equal(fresh.reason, 'New: started 2025, ongoing and trending.');
+  const freshEvidence = fresh.evidence.find(e => e.id === 'fresh:anilist:205');
+  assert.equal(freshEvidence.kind, 'fresh');
+  assert.equal(freshEvidence.fetchedAt, FETCHED_AT);
+  assert.equal(item(206).scoreParts.fresh, 1);
+  for (const row of [rec, creator, top, fresh]) assert.ok(row.reason.length <= 280);
+});
+
+test('isAdult filter', t => {
+  const plain = fixtureFeed(t);
+  assert.equal(plain.item(207), undefined);
+  assert.equal(plain.item(208), undefined, 'an adult tag with rank >= 60 counts as mature');
+  const mature = fixtureFeed(t, { discoveryMature: true });
+  assert.ok(mature.item(207));
+  assert.ok(mature.item(208));
+});
+
+test('multiple seeds merge reasons', t => {
+  const { item } = fixtureFeed(t);
+  const both = item(209);
+  assert.equal(both.scoreParts.sameCreator, 4);
+  assert.equal(both.scoreParts.communityRec, 2.73);
+  assert.equal(both.score, 6.73);
+  assert.equal(both.group, 'creator');
+  assert.deepEqual(both.reasons, ['Also by Author Seven — you liked Anchor One.',
+    'AniList readers who liked Anchor One recommend this (10).']);
+  assert.equal(both.reason, both.reasons[0]);
+  assert.ok(both.evidenceIds.includes('rec:100:anilist:209'));
+  assert.ok(both.evidenceIds.includes('creator:7:anilist:209'));
+});
+
+test('owned, queued, voted, dismissed still excluded', t => {
+  const { item, candidates } = fixtureFeed(t);
+  for (const id of [210, 211, 212, 213]) {
+    assert.ok(candidates.some(c => c.id === `anilist:${id}`), `anilist:${id} is in the pool`);
+    assert.equal(item(id), undefined, `anilist:${id} must not be suggested`);
+  }
+});
+
+test('slot mix', () => {
+  const row = (id, score, group, extra = {}) => ({ candidateId: `anilist:${id}`, score, group, tags: ['Drama'],
+    scoreParts: { fresh: 0 }, ...extra });
+  const rows = [];
+  for (let i = 0; i < 30; i++) rows.push(row(1000 + i, 30 - i, 'recs'));
+  rows.push(row(2001, 0.5, 'fresh', { scoreParts: { fresh: 1 } }), row(2002, 0.4, 'fresh', { scoreParts: { fresh: 1 } }));
+  rows.push(row(3001, 0.2, '1990s', { tags: ['Sports'] }), row(3002, 0.1, '1990s', { tags: [] }));
+  const picked = mixSlots(rows, { topTags: [{ name: 'Drama', kind: 'genre' }] });
+  assert.equal(SLOTS.perKind, 8);
+  assert.equal(picked.filter(r => r.group === 'recs').length, 8);
+  assert.ok(picked.some(r => r.candidateId === 'anilist:2001') && picked.some(r => r.candidateId === 'anilist:2002'));
+  assert.ok(picked.some(r => r.candidateId === 'anilist:3001') && picked.some(r => r.candidateId === 'anilist:3002'));
+  assert.equal(picked.length, 12, 'never pads up to 20');
+  assert.deepEqual(picked.map(r => r.rank), picked.map((_, i) => i + 1));
+  for (let i = 1; i < picked.length; i++) assert.ok(picked[i - 1].score >= picked[i].score);
+
+  const many = [];
+  for (let i = 0; i < 40; i++) many.push(row(4000 + i, 100 - i, ['recs', 'creator', 'tagTop', 'fresh', '1980s'][i % 5],
+    { scoreParts: { fresh: i % 5 === 3 ? 1 : 0 } }));
+  const full = mixSlots(many, { topTags: [] });
+  assert.equal(full.length, 20);
+  assert.ok(full.filter(r => r.group === '1980s').length <= SLOTS.perPeriod);
+});
+
+test('mergeUserFeed keeps other users\' referenced candidates', () => {
+  const prior = { candidates: { a: { id: 'a' }, b: { id: 'b' }, c: { id: 'c' } },
+    feeds: { alice: { items: [{ candidateId: 'a' }] }, bob: { items: [{ candidateId: 'b' }] }, off: { items: [], disabled: true } } };
+  const result = { candidates: { d: { id: 'd' }, b: { id: 'b', fresh: true } }, feeds: { alice: { items: [{ candidateId: 'd' }] } } };
+  const merged = mergeUserFeed(prior, result, 'alice');
+  assert.deepEqual(Object.keys(merged.feeds).sort(), ['alice', 'bob', 'off']);
+  assert.deepEqual(merged.feeds.alice.items, [{ candidateId: 'd' }]);
+  assert.deepEqual(merged.feeds.bob, prior.feeds.bob);
+  assert.deepEqual(Object.keys(merged.candidates).sort(), ['b', 'd']);
+  assert.equal(merged.candidates.b.fresh, true);
+});
+
+test('generateAsync matches generate and can score one user', async t => {
+  const world = fixtureWorld(t);
+  world.db.users.bob = { name: 'bob', settings: { discoveryEnabled: true } };
+  const args = { db: world.db, library: world.library, greatest: world.greatest, cacheDir: NO_SCRAPER_CACHE,
+    harvestCache: world.harvestCache, queuedTitles: world.queuedTitles, now: NOW };
+  const sync = generate(args);
+  const all = await generateAsync(args);
+  assert.deepEqual(all.feeds.alice.items, sync.feeds.alice.items);
+  assert.deepEqual(Object.keys(all.candidates), Object.keys(sync.candidates));
+  const one = await generateAsync({ ...args, onlyUser: 'alice' });
+  assert.deepEqual(Object.keys(one.feeds), ['alice']);
+  assert.deepEqual(one.feeds.alice.items, sync.feeds.alice.items);
+});
+
+test('scoring one user stays under 200 ms on 2000 candidates', t => {
+  const world = fixtureWorld(t);
+  const tagNames = ['Drama', 'Action', 'Romance', 'Time Skip', 'Comedy', 'Horror'];
+  const candidates = [];
+  for (let i = 0; i < 2000; i++) {
+    const id = 10000 + i;
+    candidates.push({ id: `anilist:${id}`, title: `Synthetic ${id}`, year: 2000 + (i % 27), type: 'MANGA',
+      status: i % 3 ? 'completed' : 'ongoing', cover: null, metadataUrl: `https://anilist.co/manga/${id}`,
+      tags: [tagNames[i % 6], tagNames[(i + 1) % 6]], authors: [`Writer ${i % 50}`], period: null, editorialRank: null,
+      greatestId: null, evidence: [], relations: [], isAdult: i % 97 === 0, averageScore: 60 + (i % 40),
+      tagRecords: [{ name: tagNames[i % 6], rank: 80, kind: 'tag', isAdult: false }],
+      authorRecords: [{ staffId: i % 50, name: `Writer ${i % 50}`, role: 'Story' }], fetchedAt: FETCHED_AT, seed: 'recs' });
+  }
+  feedForUser({ ...world, candidates, now: NOW });
+  const started = performance.now();
+  const feed = feedForUser({ ...world, candidates, now: NOW });
+  const elapsed = performance.now() - started;
+  assert.ok(feed.items.length > 0);
+  assert.ok(elapsed < 200, `took ${elapsed.toFixed(1)} ms`);
+});