Log in with ident

tracker

All repositories: gitoria

Readme Code Pull requests Releases Tickets Settings

Commit1704ec45

1704ec45tracker#17 (mission 057): season caret down/up, skeleton rows while a season loads, sessionless showSeasonEpisodes face (no page re-mount), client-only close; gate 214, tests/realdata-057.mjs, README + STATUSmre2026-10-01 12:39

1704ec45/tests/browser.mjs

142.2 KB

// tests/browser.mjs — THE GATE of tracker.worldapi.org#1: this app's own server on its own storage, its OWN ident
// (a copy of ident's code without .env, codes to a mail sink: tests/identkit.mjs, same as calendar's gate), a real
// headless Chrome. Proves: signed out (header shows "Log in with ident") -> sign in -> the header selector shows
// signed in, "Log out" appears, the page itself stays empty -> sign out -> signed out again (a reload confirms it).
//
// node tests/browser.mjs (TRACKER_GATE_PORT server, default 8700; TRACKER_GATE_IDENT_PORT ident, default 8701;
// TRACKER_GATE_CHROME "8702-8709" = Chrome debug ports; TRACKER_GATE_TMDB_PORT the fake
// TMDB, default 8710)
import { spawn, execFileSync } from 'node:child_process';
import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { launchBrowser } from './cdp.mjs';
import { startIdent } from './identkit.mjs';
import { startFakeTmdb, PNG } from './faketmdb.mjs';
if (!process.env.HL_CHROME && existsSync('/opt/google/chrome/chrome')) process.env.HL_CHROME = '/opt/google/chrome/chrome';
const HERE = dirname(fileURLToPath(import.meta.url));
const APP = resolve(HERE, '..');
const PORT = Number(process.env.TRACKER_GATE_PORT || 8700);
const [CH_FROM, CH_TO] = (process.env.TRACKER_GATE_CHROME || '8702-8709').split('-').map(Number);
const IDENT_PORT = Number(process.env.TRACKER_GATE_IDENT_PORT || 8701);
const TMDB_PORT = Number(process.env.TRACKER_GATE_TMDB_PORT || 8710);
const BASE = `http://127.0.0.1:${PORT}`;
const STORE = join(APP, '.scratch', 'gate-store');
const IDENT_DIR = process.env.TRACKER_GATE_IDENT_DIR || [resolve(APP, '../ident.worldapi.org'), '/media/STORAGE/projects/ident.worldapi.org'].find(d => existsSync(join(d, 'project.hl')));
const SCRATCH = join(APP, '.scratch');
const SESSIONS = join(SCRATCH, 'gate-sessions');
rmSync(SESSIONS, { recursive: true, force: true });
rmSync(STORE, { recursive: true, force: true });
mkdirSync(SESSIONS, { recursive: true });
let failures = 0, passes = 0;
function check(label, ok, detail = '') {
console.log(`${ok ? 'ok ' : 'FAIL'} ${label}${ok ? '' : ' — ' + detail}`);
if (ok) passes++; else failures++;
}
let ident = null, server = null, browser = null, log = '', tmdb = null;
async function stopServer() {
if (server) {
const s = server;
try { s.kill('SIGTERM'); } catch {}
await new Promise(r => { if (s.exitCode !== null || s.signalCode !== null) return r(); s.once('exit', r); setTimeout(r, 3000); });
server = null;
}
}
async function stop() {
if (ident) { try { await ident.stop(); } catch {} ident = null; }
if (browser) { try { await browser.close(); } catch {} browser = null; }
await stopServer();
if (tmdb) { try { await tmdb.stop(); } catch {} tmdb = null; }
}
// tracker.worldapi.org#9: what the fake TMDB (tests/faketmdb.mjs) knows about the two fixture shows (tmdbId 1001,
// 1002, tests/seed-show.hl). Show 1: season 0 (must NOT be synced — the show has no season 0), S1 with the two
// fixture episodes (no tmdbId locally → matched by number; E2 renamed "Second Episode") + a new E3 (released),
// S2 unchanged, a NEW S3 (E1 released, E2 upcoming 2098-06-01). Show 2 (no seasons yet): a NEW S1 E1 (upcoming
// 2097-01-01). Both have a poster.
// tracker.worldapi.org#12: TMDB's external_ids — show 1 a DIFFERENT imdb id than the stored tt0000001 (must not overwrite)
// + a tvdb id (fills); show 2 an imdb id (fills) + a different tvdb id than the stored 4002 (must not overwrite). The movie
// 1003 (only via /movie/): an imdb id. The fake TVmaze knows imdb tt0000001 → 501 and thetvdb 4002 → 502 (tt0000002 is unknown).
const gateTmdbMovies = () => ({ 1003: { id: 1003, title: 'Gate Test Movie', poster_path: '/gate3.png', external_ids: { imdb_id: 'tt0000003', wikidata_id: 'Q1' } },
// tracker.worldapi.org#14: a movie only TMDB has — imported from the search
1005: { id: 1005, title: 'Gate Import Movie', poster_path: '/gate5.png', release_date: '2001-05-05', overview: 'an imported movie', genres: [{ id: 18, name: 'Drama' }], external_ids: { imdb_id: 'tt0000005' } },
// mission 054 (tests/seed-adult.hl): what TMDB says about the titles whose adult flag we don't know yet; 1120 is unknown (404)
1011: { id: 1011, title: 'Adult Gate Movie', adult: true, poster_path: '/flag11.png' },
1012: { id: 1012, title: 'Flagless Gate Movie', adult: false, poster_path: '/flag12.png', external_ids: { imdb_id: 'tt0001012' } },
1013: { id: 1013, title: 'Flagless Adult Movie', adult: true, poster_path: '/flag13.png', external_ids: {} },
...Object.fromEntries(Array.from({ length: 10 }, (_, k) => [1101 + k, { id: 1101 + k, title: 'Backfill Movie ' + String(k + 1).padStart(2, '0'), adult: false, poster_path: `/bf${k + 1}.png`, external_ids: {} }])) });
// tracker.worldapi.org#15: TVmaze's episode lists — at first the SAME as TMDB's (same numbers, same days, + a special without
// a number that must be ignored), so the first syncs take nothing from TVmaze; the "TVmaze merge" block below changes them.
const gateTvmazeEpisodes = () => ({
501: [{ id: 8001, season: 1, number: 1, name: 'Pilot', airdate: '2020-01-01' }, { id: 8002, season: 1, number: 2, name: 'Second Episode', airdate: '2020-06-15' },
{ id: 8003, season: 1, number: 3, name: 'Third', airdate: '2020-09-01' }, { id: 8004, season: 2, number: 1, name: 'Season Two Opener', airdate: '2099-01-01' },
{ id: 8005, season: 3, number: 1, name: 'Third Season Start', airdate: '2021-05-05' }, { id: 8006, season: 3, number: 2, name: 'Coming Soon', airdate: '2098-06-01' },
{ id: 8099, season: 3, number: null, name: 'A TVmaze Special', airdate: '2021-06-01', type: 'significant_special' }],
502: [{ id: 8101, season: 1, number: 1, name: 'Brand New', airdate: '2097-01-01' }],
});
const gateTvmaze = () => ({ imdb: { tt0000001: 501 }, thetvdb: { 4002: 502, 4004: 504 }, episodes: gateTvmazeEpisodes() });
// tracker.worldapi.org#14: TMDB's search/multi for "gate": the two titles we HAVE (tv 1001, movie 1003 — left out of the web
// list), a person (dropped), and three new ones: tv 1004 + movie 1005 (importable) and tv 1006 (in the search, but its details
// answer 404 — the failed import)
const gateSearch = () => ({ gate: [
{ media_type: 'tv', id: 1001, name: 'Gate Test Show', first_air_date: '2024-01-01', poster_path: '/gate1.png', overview: 'have it' },
{ media_type: 'tv', id: 1004, name: 'Gate Import Show', first_air_date: '2023-02-02', poster_path: '/gate4.png', overview: 'new series' },
{ media_type: 'person', id: 77, name: 'Gate Person' },
{ media_type: 'movie', id: 1003, title: 'Gate Test Movie', release_date: '1996-11-18', poster_path: '/gate3.png' },
{ media_type: 'movie', id: 1005, title: 'Gate Import Movie', release_date: '2001-05-05', poster_path: null, overview: 'new movie' },
{ media_type: 'tv', id: 1006, name: 'Gate Broken Show', first_air_date: '', poster_path: '/gate6.png' },
// mission 054: an ADULT title in TMDB's answer (despite include_adult=false) — never in our web list
{ media_type: 'movie', id: 1030, title: 'Gate Adult Web', adult: true, release_date: '2002-02-02', poster_path: '/gate30.png' }] });
// tracker.worldapi.org#16: TMDB's people. Test Actor (3002): facts + a photo; credits = two titles we HAVE (tv 1001, movie 1003),
// new ones — a movie as cast AND crew ("Hero / Director"), a series, an ADULT movie (stored, never shown), an undated one (last),
// a crew-only one, and 80 more movies (87 titles → 3 batches of 40 after the TMDB step). Second Actor (3003): two titles that
// exist by then. Complete Person (3001) must never be asked.
const gatePersons = () => {
const bulk = [];
for (let i = 1; i <= 80; i++) bulk.push({ media_type: 'movie', id: 2100 + i, title: 'Bulk Film ' + String(i).padStart(2, '0'), release_date: '2005-01-01', character: 'Extra', adult: false, poster_path: null, genre_ids: [] });
return {
3002: { id: 3002, name: 'Test Actor', biography: 'Test Actor bio from TMDB.', birthday: '1970-05-06', deathday: null, place_of_birth: 'Fixture Town', profile_path: '/face2.png', imdb_id: 'nm0000002', adult: false,
combined_credits: {
cast: [
{ media_type: 'tv', id: 1001, name: 'Gate Test Show', first_air_date: '2024-01-01', character: 'Someone', poster_path: '/gate1.png' },
{ media_type: 'movie', id: 1003, title: 'Gate Test Movie', release_date: '1996-11-18', character: 'Cameo', poster_path: '/gate3.png' },
{ media_type: 'movie', id: 2001, title: 'Person Film One', release_date: '2010-05-05', character: 'Hero', adult: false, poster_path: '/pf1.png', genre_ids: [18], overview: 'a film of the person', original_language: 'en' },
{ media_type: 'tv', id: 2002, name: 'Person Series', first_air_date: '2015-03-03', character: 'Lead', adult: false, poster_path: null, genre_ids: [18, 10765] },
{ media_type: 'movie', id: 2003, title: 'Hidden Adult Film', release_date: '2012-01-01', character: 'X', adult: true, poster_path: null },
{ media_type: 'movie', id: 2004, title: 'Announced Film', release_date: '', character: 'Villain', adult: false, poster_path: null },
...bulk],
crew: [
{ media_type: 'movie', id: 2001, title: 'Person Film One', release_date: '2010-05-05', job: 'Director', adult: false, poster_path: '/pf1.png' },
{ media_type: 'movie', id: 2005, title: 'Directed Only', release_date: '2018-08-08', job: 'Writer', adult: false, poster_path: null }] } },
3003: { id: 3003, name: 'Second Actor', biography: '', birthday: null, deathday: null, place_of_birth: null, profile_path: null,
combined_credits: { cast: [{ media_type: 'movie', id: 2001, title: 'Person Film One', release_date: '2010-05-05', character: 'Sidekick', poster_path: '/pf1.png' },
{ media_type: 'tv', id: 1001, name: 'Gate Test Show', first_air_date: '2024-01-01', character: 'Guest', poster_path: '/gate1.png' },
// TMDB's credit says not adult, but OUR record of it is (adult = true, stored by Test Actor's fill): still hidden
{ media_type: 'movie', id: 2003, title: 'Hidden Adult Film', release_date: '2012-01-01', character: 'Y', adult: false }], crew: [] } },
3001: { id: 3001, name: 'Complete Person', combined_credits: { cast: [{ media_type: 'movie', id: 2999, title: 'Must Not Appear', release_date: '2000-01-01' }], crew: [] } },
};
};
const gateTmdbShows = () => ({
1001: { id: 1001, name: 'Gate Test Show', overview: 'TMDB overview', status: 'Returning Series', poster_path: '/gate1.png', external_ids: { imdb_id: 'tt9999999', tvdb_id: 4001, tvrage_id: null }, seasons: [
{ id: 90, season_number: 0, name: 'Specials', air_date: '2019-01-01', episodes: [{ id: 5000, episode_number: 1, name: 'A Special', air_date: '2019-01-01' }] },
{ id: 91, season_number: 1, name: 'Season 1', air_date: '2020-01-01', episodes: [
{ id: 5001, episode_number: 1, name: 'Pilot', air_date: '2020-01-01' },
{ id: 5002, episode_number: 2, name: 'Second Episode', air_date: '2020-06-15' },
{ id: 5003, episode_number: 3, name: 'Third', air_date: '2020-09-01' }] },
{ id: 92, season_number: 2, name: 'Season 2', air_date: '2099-01-01', episodes: [{ id: 5004, episode_number: 1, name: 'Season Two Opener', air_date: '2099-01-01' }] },
{ id: 93, season_number: 3, name: 'Season 3', air_date: '2021-05-05', episodes: [
{ id: 5005, episode_number: 1, name: 'Third Season Start', air_date: '2021-05-05' },
{ id: 5006, episode_number: 2, name: 'Coming Soon', air_date: '2098-06-01' }] }] },
// tracker.worldapi.org#14: NOT in our database — imported from the search (no one follows it, the sync never asks for it)
1004: { id: 1004, name: 'Gate Import Show', overview: 'an imported series', status: 'Returning Series', poster_path: '/gate4.png', first_air_date: '2023-02-02',
original_language: 'en', genres: [{ id: 18, name: 'Drama' }, { id: 10765, name: 'Sci-Fi & Fantasy' }], external_ids: { imdb_id: 'tt0000004', tvdb_id: 4004 }, seasons: [
{ id: 95, season_number: 1, name: 'Season 1', air_date: '2023-02-02', episodes: [
{ id: 8001, episode_number: 1, name: 'Imported One', air_date: '2023-02-02' }, { id: 8002, episode_number: 2, name: 'Imported Two', air_date: '2023-02-09' }] }] },
// mission 054: a series whose adult flag we don't know yet (tests/seed-adult.hl) — TMDB says not adult
1014: { id: 1014, name: 'Flagless Gate Series', adult: false, overview: 'flagless', status: 'Ended', poster_path: '/flag14.png', external_ids: { imdb_id: 'tt0001014', tvdb_id: 4014 }, seasons: [
{ id: 96, season_number: 1, name: 'Season 1', air_date: '2001-03-03', episodes: [{ id: 9601, episode_number: 1, name: 'Flagless Pilot', air_date: '2001-03-03' }] }] },
1002: { id: 1002, name: 'Unwatched Gate Show', overview: 'second', status: 'Returning Series', poster_path: '/gate2.png', external_ids: { imdb_id: 'tt0000002', tvdb_id: 4999 }, seasons: [
{ id: 94, season_number: 1, name: 'Season 1', air_date: '2097-01-01', episodes: [{ id: 7001, episode_number: 1, name: 'Brand New', air_date: '2097-01-01' }] }] },
});
async function main() {
ident = await startIdent({ identDir: IDENT_DIR, workDir: join(STORE, 'ident'), port: IDENT_PORT });
const alice = await ident.signIn('[email protected]');
const APPKEY = await ident.registerApp(alice, 'tracker (gate)', [BASE]);
check('ident: our own ident runs (a copy without .env), tracker is registered', /^pk_[0-9a-f]{32}$/.test(APPKEY.key) && !existsSync(join(STORE, 'ident', 'ident-code', '.env')));
// tracker.worldapi.org#5: learn alice's per-app identity (a throwaway code, consumed here) so the
// fixture below can seed a follow for the SAME user the real login flow will later resolve to
// (users.hl `ensureUser` matches an existing users.db row by `identity`, reusing its id) — this is
// the only way to give /unwatched a known followed show before the browser ever signs in.
const preCode = await ident.selectorCode(alice, APPKEY, BASE);
const aliceIdentity = await ident.exchange(APPKEY, preCode);
// tracker.worldapi.org#4/#5: a tiny fixture show (tests/seed-show.hl) — written BEFORE the server
// starts, self-assigned ids only (never update(), see that file's header)
const MPACKDB = join(STORE, 'mpackdb');
mkdirSync(MPACKDB, { recursive: true });
const seedOut = execFileSync(join(APP, 'bin/hybriel'), ['tests/seed-show.hl'], { cwd: APP, env: { ...process.env, TRACKER_STORAGE: MPACKDB, TRACKER_SEED_IDENTITY: aliceIdentity } }).toString();
check('seed: the fixture show was written, alice follows it', seedOut.includes('gate-test-show') && seedOut.includes('follows it'), seedOut);
// tracker.worldapi.org#8: the fixture show's poster FILE exists (a 1×1 png), the second show has none →
// /my/shows must give the first its own /posters/sh1.png and the second the one placeholder URL /posters/none
mkdirSync(join(MPACKDB, 'posters'), { recursive: true });
writeFileSync(join(MPACKDB, 'posters', 'sh1.png'), Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64'));
// tracker.worldapi.org#9: the fake TMDB. EVERY run of the app/tool in this gate points at it with the gate's own
// token — the runtime loads the project's real .env (TMDB_READ_TOKEN) by itself, the environment given here wins
tmdb = await startFakeTmdb({ port: TMDB_PORT, shows: gateTmdbShows(), movies: gateTmdbMovies(), tvmaze: gateTvmaze(), search: gateSearch(), persons: gatePersons() });
const TMDB_ENV = { TMDB_READ_TOKEN: 'gate-token', TMDB_BASE_URL: tmdb.base + '/3', TMDB_IMAGE_URL: tmdb.base + '/t/p', TVMAZE_BASE_URL: tmdb.base + '/tvmaze' };
const startServer = async (extra = {}) => {
log = '';
server = spawn(join(APP, 'bin/hybriel'), ['project.hl'], { cwd: APP, env: { ...process.env, TRACKER_PORT: String(PORT), TRACKER_SESSIONS: SESSIONS + '/', TRACKER_STORAGE: MPACKDB, TRACKER_WATCH: '0',
TRACKER_URL: BASE, IDENT_URL: ident.base, IDENT_EXCHANGE_URL: ident.base, TRACKER_KEY: APPKEY.key, TRACKER_SECRET: APPKEY.secret, ...TMDB_ENV, TRACKER_SYNC: '0', TRACKER_BACKFILL: '0', ...extra }, stdio: ['ignore', 'pipe', 'pipe'] });
server.stdout.on('data', d => log += d); server.stderr.on('data', d => log += d);
for (let i = 0; ; i++) {
try { if ((await fetch(BASE + '/')).ok) break; } catch {}
if (i > 80) throw new Error('tracker did not come up\n' + log);
await new Promise(r => setTimeout(r, 250));
}
};
await startServer();
check('tracker is up', true);
browser = await launchBrowser({ debugPortRange: [CH_FROM, CH_TO] });
const page = await browser.newPage();
globalThis.__gatePage = page;
page.captureNetwork();
await page.captureWs(); // tracker#17: which faces a season click sends (wsSent)
// tracker#17: a FAKE DELAY for one face — while `window.__delayFace = { name, ms }` is set, an outgoing websocket frame
// naming that face is sent `ms` later (the real socket, only held back), so the gate sees the state BEFORE the answer
await page.addInitScript(`(() => {
const Native = window.WebSocket;
if (!Native) return;
window.WebSocket = class extends Native {
send(d) {
const f = window.__delayFace;
if (f && String(d).includes(f.name)) { setTimeout(() => super.send(d), f.ms); return; }
return super.send(d);
}
};
})()`);
const ev = (e) => page.evaluate(e);
const hydrated = () => page.waitFor('!!window.__hl && window.__hl.socket && window.__hl.socket.readyState === 1', { timeout: 15000, label: 'hydrated' });
// mission 047: every check icon AND season caret on the page is a real SVG element (not XHTML) and actually drawn
const svgState = () => ev(`JSON.stringify((() => {
const svgs = Array.from(document.querySelectorAll('button.checkicon svg, season-caret svg'));
const shapes = Array.from(document.querySelectorAll('button.checkicon svg circle, button.checkicon svg path, season-caret svg path'));
return { svgs: svgs.length, badNs: svgs.concat(shapes).filter(e => e.namespaceURI !== 'http://www.w3.org/2000/svg').length,
undrawn: Array.from(document.querySelectorAll('button.checkicon svg circle')).filter(c => !(c.getBoundingClientRect().width > 0)).length };
})())`);
const svgOk = (st) => { const v = JSON.parse(st); return v.svgs > 0 && v.badNs === 0 && v.undrawn === 0; };
// the caret's direction per season row, top to bottom (tracker#17): 'down' (closed, no transform) or 'up' (open,
// rotate(180deg) = matrix(-1, 0, 0, -1, 0, 0)); waits out the caret's .15 s transition first
const carets = async () => { await new Promise(r => setTimeout(r, 250)); return ev(`JSON.stringify(Array.from(document.querySelectorAll('season-row')).map(r => {
const t = getComputedStyle(r.querySelector('season-caret')).transform;
if (t === 'none') return 'down';
const m = t.startsWith('matrix(') ? t.slice(7, -1).split(',').map(Number) : [];
return m.length === 6 && Math.abs(m[0] + 1) < 1e-6 && Math.abs(m[3] + 1) < 1e-6 && Math.abs(m[1]) < 1e-6 ? 'up' : t;
}))`); };
// tracker.worldapi.org#12: the header's link icons as [label, href, target, rel], in order
const extLinks = () => ev(`JSON.stringify(Array.from(document.querySelectorAll('show-links a.extlink')).map(a => [a.textContent, a.getAttribute('href'), a.getAttribute('target'), a.getAttribute('rel')]))`);
const linksAre = (got, want) => JSON.stringify(JSON.parse(got)) === JSON.stringify(want.map(([l, h]) => [l, h, '_blank', 'noopener']));
const TMDB_TV = 'https://www.themoviedb.org/tv/', TMDB_MOVIE = 'https://www.themoviedb.org/movie/', IMDB = 'https://www.imdb.com/title/', TVDB = 'https://thetvdb.com/dereferrer/series/', TVMAZE = 'https://www.tvmaze.com/shows/';
// a click on a link icon: a NEW tab opens at that address (no access to this one: noopener), this tab stays where it is.
// The new tab is closed again at once (it would load the real site).
const clickOpensNewTab = async (sel) => {
const seen = new Map();
const off = browser.conn.onEvent((m) => {
if ((m.method === 'Target.targetCreated' || m.method === 'Target.targetInfoChanged') && m.params.targetInfo.type === 'page') seen.set(m.params.targetInfo.targetId, m.params.targetInfo);
});
await browser.conn.send('Target.setDiscoverTargets', { discover: true });
const known = new Set(seen.keys());
const before = await ev('location.href');
await page.click(sel);
const fresh = () => [...seen.values()].find(i => !known.has(i.targetId) && i.url && i.url !== 'about:blank');
for (let i = 0; i < 100 && !fresh(); i++) await new Promise(r => setTimeout(r, 50));
const tab = fresh();
off();
await browser.conn.send('Target.setDiscoverTargets', { discover: false });
if (tab) await browser.conn.send('Target.closeTarget', { targetId: tab.targetId }).catch(() => {});
return { url: tab ? tab.url : null, canAccessOpener: tab ? tab.canAccessOpener : null, stayed: (await ev('location.href')) === before };
};
// tracker.worldapi.org#13: the poster tiles of a row/grid as "title|year|href|poster"
const tilesOf = (sel) => ev(`JSON.stringify(Array.from(document.querySelectorAll(${JSON.stringify(sel)} + ' a.tile')).map(a => [a.querySelector('tile-title').textContent, a.querySelector('tile-year').textContent, a.getAttribute('href'), a.querySelector('img.tile-poster').getAttribute('src')].join('|')))`).then(JSON.parse);
const titlesOf = async (sel) => (await tilesOf(sel)).map(t => t.split('|')[0]);
const movieRange = (from, to) => { const o = []; for (let i = from; i >= to; i--) o.push('Pager Movie ' + String(i).padStart(2, '0')); return o; };
const pagerState = () => ev(`JSON.stringify({ items: Array.from(document.querySelectorAll('pagination li')).map(l => l.textContent.trim()), current: (document.querySelector('pagination li.current') || { textContent: '' }).textContent.trim() })`).then(JSON.parse);
// hybriel 64527baa (in the vendored ff51cf46): a face taking `session` also answers with a sync of every member derived
// from session — a handler that ALSO appended the returned row would show it twice. After every face-driven change:
// each row (by its button value) once. Waits 400 ms first so a late sync has landed.
const rowsOnce = async (sel) => { await new Promise(r => setTimeout(r, 400)); return JSON.parse(await ev(`JSON.stringify((() => { const v = Array.from(document.querySelectorAll(${JSON.stringify(sel)})).map(b => b.value); return { n: v.length, unique: new Set(v).size === v.length, values: v }; })())`)); };
const modalOpen = () => ev(`!!(document.querySelector('dialog#signin') && document.querySelector('dialog#signin').open)`);
const loginAs = async (who) => {
const code = await ident.selectorCode(who, APPKEY, BASE);
await page.goto(BASE + '/login/callback?ident_code=' + code);
await page.waitForSelector('#logout');
await hydrated();
};
// ---- signed out: header shows the selector + "Log in with ident", the page itself is empty ----
await page.goto(BASE + '/');
await hydrated();
check('signed out: the identity selector is in the header', await ev(`!!document.querySelector('#selector')`));
check('signed out: "Log in with ident" shows, no "Log out"', (await ev(`!!document.querySelector('#loginbutton')`)) && !(await ev(`!!document.querySelector('#logout')`)));
// mission 056: signed out on a phone the header is ONE row ("choose ident" + "Log in" never wrap); " with ident" from 40rem on
const headerRow = () => ev(`JSON.stringify((() => { const h = document.querySelector('application-header').getBoundingClientRect();
const parts = [document.querySelector('application-header .brand'), document.querySelector('#searchlink'), document.querySelector('#selector'), document.querySelector('#loginbutton')].map(e => e.getBoundingClientRect());
return { h: Math.round(h.height), oneRow: parts.every(r => r.top >= h.top && r.bottom <= h.bottom && r.top < parts[0].bottom && r.bottom > parts[0].top), right: Math.round(Math.max(...parts.map(r => r.right))),
sw: document.documentElement.scrollWidth, text: document.querySelector('#loginbutton').innerText.trim(), choose: document.querySelector('#selector').shadowRoot.querySelector('[part~="button"]').getBoundingClientRect().height }; })())`).then(JSON.parse);
const rows56 = {};
for (const [w, mobile] of [[320, true], [390, true], [1280, false]]) {
await page.send('Emulation.setDeviceMetricsOverride', { width: w, height: 800, deviceScaleFactor: mobile ? 2 : 1, mobile });
await page.goto(BASE + '/');
await hydrated();
await page.waitFor(`!!document.querySelector('#selector').shadowRoot && !!document.querySelector('#selector').shadowRoot.querySelector('[part~="button"]')`, { timeout: 5000, label: 'selector drawn' });
rows56[w] = await headerRow();
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `header-signed-out-${w}.png`), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
}
await page.send('Emulation.clearDeviceMetricsOverride', {});
await page.goto(BASE + '/');
await hydrated();
check('signed out: the header is ONE row at 320/390/1280 px (≤ 56 px high, nothing below the brand, no sideways scroll); a phone says "Log in", a wide screen "Log in with ident"',
[320, 390, 1280].every(w => rows56[w].oneRow && rows56[w].h <= 56 && rows56[w].sw <= w && rows56[w].right <= w && rows56[w].choose <= 40) && rows56[320].text === 'Log in' && rows56[390].text === 'Log in' && rows56[1280].text === 'Log in with ident', JSON.stringify(rows56));
// ---- tracker.worldapi.org#13: the homepage signed OUT — no icon tiles, the text, "Movies" (→ /movies) with the 10
// latest RELEASED movies (not the 2099 one), "Shows" (→ /shows) with the series by newest released episode ----
check('home signed out: no icon tiles, no centered sign-in; the text about the site (with the sign-in hint)', (await ev(`document.querySelectorAll('a.hometile').length`)) === 0
&& /keeps track of the series and movies you follow/.test(await ev(`document.querySelector('home-intro').textContent`)) && /Log in with ident/.test(await ev(`document.querySelector('home-intro').textContent`)));
check('home: the headings "Movies" and "Shows" link to /movies and /shows', (await ev(`[document.querySelector('#home-movies h2 a'), document.querySelector('#home-shows h2 a')].map(a => a.textContent + ' ' + a.getAttribute('href')).join(',')`)) === 'Movies /movies,Shows /shows');
let tl = await tilesOf('#home-movies');
check('home: the 10 latest RELEASED movies, newest first (Pager Movie 30…21; the 2099 one is not out yet), each poster + title + year → its page',
JSON.stringify(tl.map(t => t.split('|')[0])) === JSON.stringify(movieRange(30, 21)) && tl[0] === 'Pager Movie 30|2001|/shows/pager-movie-30|/posters/none', JSON.stringify(tl));
tl = await tilesOf('#home-shows');
check('home: the series by newest RELEASED episode (Pager Older Series 2021-01-01, Gate Test Show 2020-06-15; one with no released episode is left out)',
JSON.stringify(tl) === JSON.stringify(['Pager Older Series|2019|/shows/pager-older-series|/posters/none', 'Gate Test Show|2024|/shows/gate-test-show|/posters/sh1.png']), JSON.stringify(tl));
check('home: every tile poster loaded (the placeholder or the real file)', await ev(`new Promise(r => setTimeout(r, 300)).then(() => Array.from(document.querySelectorAll('img.tile-poster')).filter(i => i.getBoundingClientRect().right <= innerWidth).every(i => i.complete && i.naturalWidth > 0))`));
// ---- tracker.worldapi.org#4: /shows/:slug signed OUT — the header/genres/cast show, no checks ----
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('signed out: the show header renders (title, genre, cast)', (await ev(`document.querySelector('show-header h1').textContent`)) === 'Gate Test Show'
&& (await ev(`document.querySelector('.genre-pill').textContent`)) === 'Drama'
&& (await ev(`document.querySelector('.artist-link').textContent`)) === 'Test Actor');
// ---- tracker.worldapi.org#12: link icons only for the ids the show has (before any sync: show 1 has tmdb + imdb) ----
let lk = await extLinks();
check('link icons: show 1 (tmdbId + imdbId only) has exactly TMDB (tv/1001) and IMDb (tt0000001), each target=_blank rel=noopener',
linksAre(lk, [['TMDB', TMDB_TV + '1001'], ['IMDb', IMDB + 'tt0000001/']]), lk);
check('link icons: monochrome badges (one colour for all, no image), small (≤ 1.6rem high)',
(await ev(`(() => { const a = Array.from(document.querySelectorAll('a.extlink')); const c = a.map(e => getComputedStyle(e)); return a.length > 0 && new Set(c.map(x => x.backgroundColor + x.color)).size === 1 && a.every(e => !e.querySelector('img') && e.getBoundingClientRect().height <= 25.6) })()`)));
const nt = await clickOpensNewTab('a.extlink[data-site="imdb"]');
check('link icons: a click opens the show on IMDb in a NEW tab without access to this one (noopener); this page stays', nt.url === IMDB + 'tt0000001/' && nt.canAccessOpener === false && nt.stayed, JSON.stringify(nt));
await page.goto(BASE + '/shows/unwatched-gate-show');
await hydrated();
lk = await extLinks();
check('link icons: show 2 (tmdbId + tvdbId only) has exactly TMDB and TheTVDB (dereferrer/series/4002)', linksAre(lk, [['TMDB', TMDB_TV + '1002'], ['TVDB', TVDB + '4002']]), lk);
await page.goto(BASE + '/shows/gate-test-movie');
await hydrated();
lk = await extLinks();
check('link icons: a movie (tmdbId only) has exactly TMDB as /movie/1003', linksAre(lk, [['TMDB', TMDB_MOVIE + '1003']]), lk);
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('signed out: the latest season (2) is expanded, season 1 collapsed', (await ev(`document.querySelectorAll('episode-row').length`)) === 1);
// mission 047: signed out the checks and "Follow" are VISIBLE; a click opens the sign-in modal and writes nothing
check('signed out (mission 047): the season + episode checks are visible (drawn SVG) and so is "Follow"',
(await ev(`document.querySelectorAll('button.checkicon').length`)) === 3 && svgOk(await svgState())
&& (await ev(`document.querySelector('#follow').textContent`)) === 'Follow' && (await ev(`document.querySelector('#follow').getBoundingClientRect().width > 0`)), await svgState());
check('signed out: the sign-in modal is closed at first', !(await modalOpen()));
await page.click('button.checkicon[value="ep0000000000ep0e3"]');
await page.waitFor(`document.querySelector('dialog#signin').open`, { timeout: 5000, label: 'modal after a check click' }).catch(() => {});
check('signed out: a check click opens the modal "You need to sign in to follow shows and mark episodes" with a sign-in link (ident login) and Close',
(await modalOpen()) && (await ev(`document.querySelector('dialog#signin p').textContent`)) === 'You need to sign in to follow shows and mark episodes.'
&& (await ev(`document.querySelector('#signin-link').getAttribute('href')`)).startsWith(ident.base + '/login?key=')
&& (await ev(`document.querySelector('#signin-link').getBoundingClientRect().width > 0`))
&& (await ev(`Array.from(document.querySelectorAll('dialog#signin footer button')).map(b => b.textContent).join()`)) === 'Close',
await ev(`document.querySelector('dialog#signin') ? document.querySelector('dialog#signin').outerHTML.slice(0, 600) : 'no dialog'`));
if (process.env.TRACKER_GATE_SHOTS) { mkdirSync(process.env.TRACKER_GATE_SHOTS, { recursive: true }); writeFileSync(join(process.env.TRACKER_GATE_SHOTS, 'signed-out-modal-1280.png'), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64')); }
await page.click('dialog#signin footer button');
await page.waitFor(`!document.querySelector('dialog#signin').open`, { timeout: 5000, label: 'modal closed' }).catch(() => {});
check('signed out: Close closes the modal; the check stayed unwatched (nothing written)', !(await modalOpen())
&& (await ev(`document.querySelector('button.checkicon[value="ep0000000000ep0e3"]').getAttribute('class')`)) === 'checkicon regular');
await page.click('#follow');
await page.waitFor(`document.querySelector('dialog#signin').open`, { timeout: 5000, label: 'modal after Follow' }).catch(() => {});
check('signed out: "Follow" opens the same modal and stays "Follow"', (await modalOpen()) && (await ev(`document.querySelector('#follow').textContent`)) === 'Follow');
await page.click('dialog#signin footer button');
await page.click('button.checkicon[value="se000000000se0s1"]');
await page.waitFor(`document.querySelector('dialog#signin').open`, { timeout: 5000, label: 'modal after a season check' }).catch(() => {});
check('signed out: a SEASON check opens the modal too', await modalOpen());
await page.click('dialog#signin footer button');
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('signed out: after a reload every check is still unwatched (the clicks wrote nothing)',
(await ev(`Array.from(document.querySelectorAll('button.checkicon')).every(b => b.getAttribute('class') === 'checkicon regular')`)));
// ---- tracker.worldapi.org#5: /my/unwatched signed OUT — no rows, no checks ----
await page.goto(BASE + '/my/unwatched');
await hydrated();
check('signed out: /my/unwatched shows no rows and asks to sign in', (await ev(`document.querySelectorAll('unwatched-row').length`)) === 0
&& (await ev(`document.querySelector('.muted').textContent`)) === 'Sign in to see the shows you follow.');
// ---- tracker.worldapi.org#6: /my/schedule signed OUT — no rows, no checks ----
await page.goto(BASE + '/my/schedule');
await hydrated();
check('signed out: /my/schedule shows no rows and asks to sign in', (await ev(`document.querySelectorAll('schedule-row').length`)) === 0
&& (await ev(`document.querySelector('.muted').textContent`)) === 'Sign in to see the shows you follow.');
// ---- tracker.worldapi.org#7: /my/shows signed OUT — no rows, the same sign-in message ----
await page.goto(BASE + '/my/shows');
await hydrated();
check('signed out: /my/shows shows no rows and asks to sign in', (await ev(`document.querySelectorAll('my-show-row').length`)) === 0
&& (await ev(`document.querySelector('.muted').textContent`)) === 'Sign in to see the shows you follow.');
// ==== tracker.worldapi.org#14: THE SEARCH, signed OUT — the header's magnifier, our database as you type, "Fetch from web"
// (the fake TMDB's search/multi), "Add" → the sign-in modal ====
const searchFor = () => ev(`document.querySelector('search-page') ? document.querySelector('search-page').getAttribute('data-for') : null`);
const searchTitles = () => ev(`JSON.stringify(Array.from(document.querySelectorAll('#titles search-row')).map(r => [r.querySelector('.search-title').textContent, r.querySelector('.search-title').getAttribute('href'), r.querySelector('search-type').textContent]))`);
const searchPeople = () => ev(`JSON.stringify(Array.from(document.querySelectorAll('#people .search-person')).map(a => [a.textContent, a.getAttribute('href')]))`);
const webList = () => ev(`JSON.stringify(Array.from(document.querySelectorAll('web-row')).map(r => [r.querySelector('web-title').textContent, r.querySelector('button.add').value, r.querySelector('search-type').textContent]))`);
const typeSearch = async (text) => {
await page.type('#searchinput', text, { clear: true });
await page.waitFor(`document.querySelector('search-page').getAttribute('data-for') === ${JSON.stringify(text)}`, { timeout: 10000, label: 'results for ' + text });
};
const GATE_TITLES = [['Gate Test Show (2024)', '/shows/gate-test-show', 'Series'], ['Gate Test Movie (1996)', '/shows/gate-test-movie', 'Movie'], ['Unwatched Gate Show (2025)', '/shows/unwatched-gate-show', 'Series']];
check('search: the header has the magnifier (a drawn SVG) linking to /search',
(await ev(`document.querySelector('#searchlink').getAttribute('href')`)) === '/search'
&& (await ev(`(() => { const s = document.querySelector('#searchlink svg'); return s.namespaceURI === 'http://www.w3.org/2000/svg' && s.querySelector('circle').getBoundingClientRect().width > 0 })()`)));
await ev(`window.__w052 = 'same document'`);
await page.click('#searchlink');
await page.waitFor(`location.pathname === '/search' && !!document.querySelector('#searchinput')`, { timeout: 10000, label: 'search page' });
check('search: the magnifier opens /search (client-side), an empty search field and "Search our shows, movies and people."',
(await ev('window.__w052')) === 'same document' && (await ev(`document.querySelector('#searchinput').value`)) === ''
&& (await ev(`document.querySelector('#searchnote').textContent`)) === 'Search our shows, movies and people.' && !(await ev(`!!document.querySelector('#fetchweb')`)));
await typeSearch('g');
check('search: one letter → "Type at least 2 letters.", no "Fetch from web"', (await ev(`document.querySelector('#searchnote').textContent`)) === 'Type at least 2 letters.' && !(await ev(`!!document.querySelector('#fetchweb')`)));
await page.type('#searchinput', 'ate');
await page.waitFor(`document.querySelector('search-page').getAttribute('data-for') === 'gate'`, { timeout: 10000, label: 'results for gate' });
let st14 = await searchTitles();
check('search: typing "gate" lists our titles at once — name start first, the year, Series/Movie, linking to the show; the address follows (/search/gate)',
st14 === JSON.stringify(GATE_TITLES) && (await ev('location.pathname')) === '/search/gate' && (await ev('window.__w052')) === 'same document', st14);
await typeSearch('test act');
check('search: people too — "test act" finds the person "Test Actor" (/person/Test-Actor) and no title', (await searchPeople()) === JSON.stringify([['Test Actor', '/person/Test-Actor']]) && (await searchTitles()) === '[]', await searchPeople());
await typeSearch('GATE tést');
check('search: case and accents do not matter ("GATE tést" = gate test); the address carries the text encoded',
(await searchTitles()) === JSON.stringify(GATE_TITLES.slice(0, 2)) && (await ev('location.pathname')) === '/search/GATE%20t%C3%A9st', (await searchTitles()) + ' ' + (await ev('location.pathname')));
await typeSearch('zzqq');
check('search: nothing found → "Nothing in our database yet." and "Fetch from web"', (await ev(`document.querySelector('#searchnote').textContent`)) === 'Nothing in our database yet.' && (await ev(`!!document.querySelector('#fetchweb')`)));
await page.goto(BASE + '/search/GATE%20t%C3%A9st');
await hydrated();
check('search: the address alone (reload / shared link) renders the same results on the server, the text in the field',
(await ev(`document.querySelector('#searchinput').value`)) === 'GATE tést' && (await searchTitles()) === JSON.stringify(GATE_TITLES.slice(0, 2)) && (await searchFor()) === 'GATE tést');
const bad14 = await fetch(BASE + '/search/x%zz');
const bad14b = await fetch(BASE + '/search/%E0%80');
check('search: a malformed address is no error — /search/x%zz 200 with the text taken literally, /search/%E0%80 (broken UTF-8) 200',
bad14.status === 200 && (await bad14.text()).includes('value="x%zz"') && bad14b.status === 200 && (await bad14b.text()).includes('<search-page'), bad14.status + ' ' + bad14b.status);
await typeSearch('gate/te');
check('search: a "/" in the text goes into the address as a space (an encoded / would split the path) — and that address reloads to the same titles',
(await ev('location.pathname')) === '/search/gate%20te' && (await searchTitles()) === JSON.stringify(GATE_TITLES.slice(0, 2)), await ev('location.pathname'));
await page.goto(BASE + '/search/gate%20te');
await hydrated();
check('search: … reloaded', (await searchTitles()) === JSON.stringify(GATE_TITLES.slice(0, 2)) && (await ev(`document.querySelector('#searchinput').value`)) === 'gate te');
await page.goto(BASE + '/search/gate');
await hydrated();
const searchesBefore = tmdb.searchRequests.length;
await page.click('#fetchweb');
await page.waitFor(`document.querySelectorAll('web-row').length > 0 || !!document.querySelector('#webnote')`, { timeout: 10000, label: 'web results' });
let wl = await webList();
const GATE_WEB = [['Gate Import Show (2023)', 'tv:1004', 'Series'], ['Gate Import Movie (2001)', 'movie:1005', 'Movie'], ['Gate Broken Show', 'tv:1006', 'Series']];
check('search: "Fetch from web" (signed out too) lists TMDB\'s titles WE DON\'T HAVE — not tv 1001 / movie 1003 (ours), no person; one search/multi request with the token',
wl === JSON.stringify(GATE_WEB) && tmdb.searchRequests.length === searchesBefore + 1 && tmdb.searchRequests[searchesBefore].path === '/3/search/multi?query=gate&include_adult=false&page=1'
&& tmdb.searchRequests[searchesBefore].authorization === 'Bearer gate-token', wl + ' ' + JSON.stringify(tmdb.searchRequests));
check('search: the web rows\' small posters come from TMDB\'s image host (w92); one without a poster gets /posters/none',
(await ev(`JSON.stringify(Array.from(document.querySelectorAll('web-row img')).map(i => i.getAttribute('src')))`)) === JSON.stringify([tmdb.base + '/t/p/w92/gate4.png', '/posters/none', tmdb.base + '/t/p/w92/gate6.png']));
const requestsBefore = tmdb.requests.length;
await page.click('web-row button.add[value="tv:1004"]');
await page.waitFor(`document.querySelector('dialog#signin').open`, { timeout: 5000, label: 'modal after Add' }).catch(() => {});
check('search: signed out, "Add" opens the sign-in modal ("You need to sign in to add titles.", sign-in link) and sends nothing',
(await modalOpen()) && (await ev(`document.querySelector('dialog#signin p').textContent`)) === 'You need to sign in to add titles.'
&& (await ev(`document.querySelector('#signin-link').getAttribute('href')`)).startsWith(ident.base + '/login?key=') && tmdb.requests.length === requestsBefore);
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, 'search-signed-out-modal-1280.png'), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
await page.click('dialog#signin footer button');
await page.waitFor(`!document.querySelector('dialog#signin').open`, { timeout: 5000, label: 'modal closed' }).catch(() => {});
check('search: Close closes it; the web list is still there', !(await modalOpen()) && (await webList()) === JSON.stringify(GATE_WEB));
// ---- tracker.worldapi.org#3: no bottom border on the header, no border on filled buttons ----
check('the header has no bottom border', (await ev(`getComputedStyle(document.querySelector('application-header')).borderBottomWidth`)) === '0px');
check('"Log in with ident" has no border', (await ev(`getComputedStyle(document.querySelector('#loginbutton')).borderTopWidth`)) === '0px');
check('the ident selector\'s "choose ident" button has no border', (await ev(`getComputedStyle(document.querySelector('#selector').shadowRoot.querySelector('[part~="button"]')).borderTopWidth`)) === '0px');
// ---- tracker.worldapi.org#8: the old addresses answer a permanent redirect to the /my/ ones ----
for (const [from, to] of [['/unwatched', '/my/unwatched'], ['/schedule', '/my/schedule']]) {
const m = await fetch(BASE + from, { redirect: 'manual' });
check(`${from} answers 301 → ${to}`, m.status === 301 && m.headers.get('location') === to, m.status + ' ' + m.headers.get('location'));
}
await page.goto(BASE + '/unwatched');
await hydrated();
check('the browser following /unwatched lands on /my/unwatched', (await ev(`location.pathname`)) === '/my/unwatched' && !!(await ev(`document.querySelector('unwatched-page')`)));
// ---- tracker.worldapi.org#8: the show page says "1 episode" for one, "2 episodes" for two ----
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('show page: season counts "1 episode" (singular) and "2 episodes"', JSON.stringify(await ev(`Array.from(document.querySelectorAll('season-count')).map(e => e.textContent)`)) === JSON.stringify(['1 episode', '2 episodes']),
JSON.stringify(await ev(`Array.from(document.querySelectorAll('season-count')).map(e => e.textContent)`)));
let r = await fetch(BASE + '/login/callback', { redirect: 'manual' });
check('login: /login/callback without a code → /login/failed', r.status === 302 && r.headers.get('location') === '/login/failed');
// ---- sign in: the header selector flips to signed in, "Log out" appears, page stays empty ----
await loginAs(alice);
check('signed in: the selector is still in the header, now signed in', (await ev(`!!document.querySelector('#selector')`)) && (await ev(`document.querySelector('#selector').classList.contains('in')`)));
check('signed in: "Log out" shows, no "Log in with ident"', (await ev(`!!document.querySelector('#logout')`)) && !(await ev(`!!document.querySelector('#loginbutton')`)));
check('home signed in: four icon tiles → /my/unwatched, /my/schedule, /my/shows, /my/movies, each with a drawn svg icon; the text + both rows below them, no sign-in hint',
(await ev(`Array.from(document.querySelectorAll('home-nav a.hometile')).map(a => a.textContent.trim() + ' ' + a.getAttribute('href') + ' ' + (a.querySelector('svg').namespaceURI === 'http://www.w3.org/2000/svg' && a.querySelector('svg').getBoundingClientRect().width > 30)).join(',')`))
=== 'Unwatched /my/unwatched true,Schedule /my/schedule true,Shows /my/shows true,Movies /my/movies true'
&& (await ev(`document.querySelector('home-nav').getBoundingClientRect().bottom <= document.querySelector('home-intro').getBoundingClientRect().top && document.querySelector('home-intro').getBoundingClientRect().bottom <= document.querySelector('#home-movies').getBoundingClientRect().top`))
&& !/Log in with ident/.test(await ev(`document.querySelector('home-intro').textContent`)) && (await ev(`document.querySelectorAll('#home-movies a.tile').length`)) === 10);
await ev(`window.__w050 = 'same document'`);
await page.click('a.hometile[href="/my/movies"]');
await page.waitFor(`location.pathname === '/my/movies' && !!document.querySelector('my-movies-page')`, { timeout: 10000, label: 'icon → /my/movies' });
check('home: the Movies icon leads to /my/movies (client-side, no reload); nothing followed yet → "You follow no movies yet."', (await ev('window.__w050')) === 'same document'
&& (await ev(`document.querySelector('my-movies-page p.muted').textContent`)) === 'You follow no movies yet.');
check('"Log out" has no border (only inverted buttons have one)', (await ev(`getComputedStyle(document.querySelector('#logout')).borderTopWidth`)) === '0px');
check('the ident selector\'s signed-in status has no border', (await ev(`(() => { const e = document.querySelector('#selector').shadowRoot.querySelector('[part~="status"]'); return e ? getComputedStyle(e).borderTopWidth : '0px' })()`)) === '0px');
check('the header brand "tracker" has font weight 100', (await ev(`getComputedStyle(document.querySelector('application-header .brand')).fontWeight`)) === '100');
// ---- tracker.worldapi.org#5: /unwatched signed IN — only already-released, unwatched episodes of
// followed shows, newest release first; a click removes the row. Run BEFORE the show-page checks
// below (which toggle these same fixture episodes watched) so all three still start unwatched here.
await page.goto(BASE + '/my/unwatched');
await hydrated();
const unwatchedRowTexts = () => ev(`Array.from(document.querySelectorAll('.unwatched-show')).map(e => e.textContent)`);
check('signed in: /my/unwatched lists only already-released episodes, newest release first (not the future one), titles with the year',
JSON.stringify(await unwatchedRowTexts()) === JSON.stringify(['Gate Test Show (2024)', 'Gate Test Show (2024)'])
&& (await ev(`document.querySelectorAll('unwatched-row').length`)) === 2);
check('signed in: /my/unwatched shows show title, the episode as S01E02 + title and release date, linking to the show',
(await ev(`document.querySelector('unwatched-row unwatched-episode').textContent`)) === 'S01E02 · Second'
&& (await ev(`document.querySelector('unwatched-row unwatched-date').textContent`)) === '2020-06-15'
&& (await ev(`document.querySelector('unwatched-row .unwatched-show').getAttribute('href')`)) === '/shows/gate-test-show');
check('signed in: /my/unwatched starts with regular (unwatched) check icons', (await ev(`document.querySelectorAll('unwatched-row button.checkicon.regular').length`)) === 2);
await page.click('unwatched-row button.checkicon');
await page.waitFor(`document.querySelectorAll('unwatched-row').length === 1`, { timeout: 10000, label: 'unwatched row removed' });
let once = await rowsOnce('unwatched-row button.checkicon');
check('session-sync: after the /my/unwatched click (face unwatchedToggle) every row appears once', once.unique && once.n === 1, JSON.stringify(once));
check('click an unwatched episode\'s check: it disappears from the list', (await ev(`document.querySelectorAll('unwatched-row').length`)) === 1
&& (await ev(`document.querySelector('unwatched-episode').textContent`)) === 'S01E01 · Pilot');
await page.goto(BASE + '/my/unwatched');
await hydrated();
check('reload: the watch from /my/unwatched is server-side, not just client state', (await ev(`document.querySelectorAll('unwatched-row').length`)) === 1
&& (await ev(`document.querySelector('unwatched-episode').textContent`)) === 'S01E01 · Pilot');
// ---- tracker.worldapi.org#7: /my/shows signed IN — followed shows, newest follow first, small
// poster, title linking to the show, the last watched episode (only ep 2 "Second" is watched so far)
const myShows = () => ev(`Array.from(document.querySelectorAll('my-show-row')).map(r => ({
title: r.querySelector('.myshow-title') && r.querySelector('.myshow-title').textContent,
href: r.querySelector('.myshow-title') && r.querySelector('.myshow-title').getAttribute('href'),
poster: r.querySelector('img.myshow-poster') && r.querySelector('img.myshow-poster').getAttribute('src'),
posterLoaded: !!(r.querySelector('img.myshow-poster') && r.querySelector('img.myshow-poster').complete && r.querySelector('img.myshow-poster').naturalWidth > 0),
episode: r.querySelector('my-show-episode') ? r.querySelector('my-show-episode').textContent : null }))`);
const waitPostersLoaded = () => page.waitFor(`Array.from(document.querySelectorAll('img.myshow-poster')).every(i => i.complete && i.naturalWidth > 0)`, { timeout: 10000, label: 'posters loaded' });
await page.goto(BASE + '/my/shows');
await hydrated();
await waitPostersLoaded();
let ms = await myShows();
check('signed in: /my/shows lists both followed shows, newest follow first, with the year (2025 from `release` — that show has no `year`)', JSON.stringify(ms.map(m => m.title)) === JSON.stringify(['Unwatched Gate Show (2025)', 'Gate Test Show (2024)']), JSON.stringify(ms));
check('signed in: /my/shows titles link to the show pages', ms.length === 2 && ms[0].href === '/shows/unwatched-gate-show' && ms[1].href === '/shows/gate-test-show', JSON.stringify(ms));
check('signed in: /my/shows shows a loaded poster per row (its own file, else the one placeholder URL /posters/none)', ms.length === 2 && ms.every(m => m.posterLoaded) && ms[1].poster === '/posters/sh1.png' && ms[0].poster === '/posters/none', JSON.stringify(ms));
check('signed in: /my/shows shows the last watched episode as S01E02, none for the never-watched show', ms.length === 2 && ms[1].episode === 'S01E02' && ms[0].episode === null, JSON.stringify(ms));
check('/my/shows: the poster is small (2.5rem wide)', (await ev(`getComputedStyle(document.querySelector('img.myshow-poster')).width`)) === '40px');
// ---- tracker.worldapi.org#6: /schedule signed IN — only NOT-yet-released episodes of followed
// shows, soonest first, no check icons at all (read-only page, unaffected by any watch toggle above)
await page.goto(BASE + '/my/schedule');
await hydrated();
check('signed in: /my/schedule lists only the not-yet-released episode, title with the year', (await ev(`document.querySelectorAll('schedule-row').length`)) === 1
&& (await ev(`document.querySelector('.schedule-show').textContent`)) === 'Gate Test Show (2024)');
check('signed in: /my/schedule shows show title, the episode as S02E01 + title, release date, linking to the show, no checks',
(await ev(`document.querySelector('schedule-row schedule-episode').textContent`)) === 'S02E01 · Season Two Opener'
&& (await ev(`document.querySelector('schedule-row schedule-date').textContent`)) === '2099-01-01'
&& (await ev(`document.querySelector('schedule-row .schedule-show').getAttribute('href')`)) === '/shows/gate-test-show'
&& (await ev(`document.querySelectorAll('schedule-row button.checkicon').length`)) === 0);
// ---- tracker.worldapi.org#4: /shows/:slug signed IN — check icons, episode toggle, season toggle,
// collapse/expand, and a reload proves the watch really is server-side ----
const EP3 = 'ep0000000000ep0e3'; // season 2 (expanded by default), episode 1 "Season Two Opener"
const EP1 = 'ep0000000000ep0e1'; // season 1 (collapsed by default), episode 1 "Pilot"
const EP2 = 'ep0000000000ep0e2'; // season 1, episode 2 "Second"
const SEASON1 = 'se000000000se0s1';
const checkClass = (id) => ev(`document.querySelector('button.checkicon[value="${id}"]').getAttribute('class')`);
const clickValue = (sel, id) => page.click(`${sel}[value="${id}"]`);
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('signed in: episode check icons show, starting "regular" (not watched)', (await checkClass(EP3)) === 'checkicon regular');
await clickValue('button.checkicon', EP3);
await page.waitFor(`document.querySelector('button.checkicon[value="${EP3}"]').getAttribute('class') === 'checkicon solid'`, { timeout: 10000, label: 'ep3 solid' });
check('click an episode check: it turns solid', (await checkClass(EP3)) === 'checkicon solid');
check('season 1 starts collapsed (no episode rows of it yet)', (await ev(`document.querySelectorAll('episode-row').length`)) === 1);
await clickValue('button.checkicon', SEASON1);
await page.waitFor(`document.querySelector('button.checkicon[value="${SEASON1}"]').getAttribute('class') === 'checkicon solid'`, { timeout: 10000, label: 'season1 solid' });
check('click a season check: the season itself turns solid', (await checkClass(SEASON1)) === 'checkicon solid');
await clickValue('button.season-toggle', SEASON1);
await page.waitForSelector(`button.checkicon[value="${EP1}"]`, { timeout: 10000 });
check('expanding season 1 shows its episodes already solid (the season check watched them too)',
(await checkClass(EP1)) === 'checkicon solid' && (await checkClass(EP2)) === 'checkicon solid');
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('reload: episode 3\'s watch is server-side, not just client state', (await checkClass(EP3)) === 'checkicon solid');
await clickValue('button.season-toggle', SEASON1);
await page.waitForSelector(`button.checkicon[value="${EP1}"]`, { timeout: 10000 });
check('reload: season 1\'s bulk watch is server-side too', (await checkClass(EP1)) === 'checkicon solid' && (await checkClass(EP2)) === 'checkicon solid' && (await checkClass(SEASON1)) === 'checkicon solid');
// ---- mission 047, the creator's additions on the show page (signed in) ----
check('episodes are not indented: an episode\'s check is exactly under its season\'s check (same left edge)',
(await ev(`Math.abs(document.querySelector('episode-row button.checkicon').getBoundingClientRect().left - document.querySelector('season-row button.checkicon').getBoundingClientRect().left) < 0.5`)));
check('artist links are orange #ce9178 (not red)', (await ev(`getComputedStyle(document.querySelector('.artist-link')).color`)) === 'rgb(206, 145, 120)');
check('an unwatched check is the inverted solid icon: accent outline circle AND accent check mark; watched = filled accent disc, dark check',
(await ev(`(() => { const b = document.querySelector('button.checkicon.regular'); const c = getComputedStyle(b.querySelector('circle')), p = getComputedStyle(b.querySelector('path'));
return c.stroke === 'rgb(78, 201, 176)' && c.fill !== 'rgb(78, 201, 176)' && p.stroke === 'rgb(78, 201, 176)' })()`))
&& (await ev(`(() => { const b = document.querySelector('button.checkicon.solid'); const c = getComputedStyle(b.querySelector('circle')), p = getComputedStyle(b.querySelector('path'));
return c.fill === 'rgb(78, 201, 176)' && p.stroke === 'rgb(15, 20, 25)' })()`)));
// ---- tracker.worldapi.org#7: /my/shows again — S02E01 was watched BEFORE season 1's bulk watch, so
// this proves "last" = the highest season/episode watched, not the most recently watched one
await page.goto(BASE + '/my/shows');
await hydrated();
ms = await myShows();
check('/my/shows: the last episode is the HIGHEST watched (S02E01), not the most recent watch; the other show still none',
ms.length === 2 && ms[1].episode === 'S02E01' && ms[0].episode === null, JSON.stringify(ms));
// ---- mission 047 (the creator: "i dont see the check marks"): a CLIENT-SIDE navigation /my/shows → click the show
// title builds the show page in the browser; its check <svg> must be an SVG element (the old vendored build made it
// in the XHTML namespace: nothing drawn, circle width 0). A window marker proves no full page load happened.
await ev(`window.__w047 = 'same document'`);
await page.click(`a.myshow-title[href="/shows/gate-test-show"]`);
await page.waitFor(`location.pathname === '/shows/gate-test-show' && !!document.querySelector('button.checkicon svg circle')`, { timeout: 10000, label: 'show page after client-side navigation' });
const svgNs = await ev(`JSON.stringify({ marker: window.__w047 || null, ns: document.querySelector('button.checkicon svg').namespaceURI,
circleNs: document.querySelector('button.checkicon svg circle').namespaceURI,
circleWidth: document.querySelector('button.checkicon svg circle').getBoundingClientRect().width })`);
const sv = JSON.parse(svgNs);
check('client-side navigation /my/shows → show page: the check svg is in the SVG namespace and its circle is drawn (width > 0)',
sv.marker === 'same document' && sv.ns === 'http://www.w3.org/2000/svg' && sv.circleNs === 'http://www.w3.org/2000/svg' && sv.circleWidth > 0, svgNs);
lk = await extLinks();
check('client-side navigation: the link icons are there too (TMDB + IMDb)', linksAre(lk, [['TMDB', TMDB_TV + '1001'], ['IMDb', IMDB + 'tt0000001/']]), lk);
// mission 047 #11: the checks also vanished after expanding/collapsing a season — same cause; and the caret flips
let cs = await carets();
check('season caret at the header\'s right edge (tracker#17): UP for the open season 2, DOWN for the closed season 1',
cs === JSON.stringify(['up', 'down']) && (await ev(`(() => { const r = document.querySelector('season-row'); return Math.abs(r.getBoundingClientRect().right - r.querySelector('season-caret').getBoundingClientRect().right) < 2 })()`)), cs);
await clickValue('button.season-toggle', SEASON1);
await page.waitForSelector(`button.checkicon[value="${EP1}"]`, { timeout: 10000 });
let st = await svgState();
cs = await carets();
check('after EXPANDING season 1 (client-side): every check + caret is a drawn SVG, season 1\'s caret now points UP', svgOk(st) && cs === JSON.stringify(['up', 'up']), st + ' ' + cs);
once = await rowsOnce('show-seasons button.checkicon');
check('after EXPANDING (face showSeasonEpisodes) every season/episode row appears once (2 seasons + 3 episodes), no skeleton left', once.unique && once.n === 5 && (await ev(`document.querySelectorAll('skeleton-row').length`)) === 0, JSON.stringify(once));
await clickValue('button.checkicon', EP1);
await page.waitFor(`document.querySelector('button.checkicon[value="${EP1}"]').getAttribute('class') === 'checkicon regular'`, { timeout: 10000, label: 'ep1 regular' });
st = await svgState();
check('after an EPISODE click: every check is still a drawn SVG', svgOk(st), st);
once = await rowsOnce('show-seasons button.checkicon');
check('session-sync: after an EPISODE click (face showToggleEpisode) every row appears once', once.unique && once.n === 5, JSON.stringify(once));
await clickValue('button.checkicon', EP1);
await page.waitFor(`document.querySelector('button.checkicon[value="${EP1}"]').getAttribute('class') === 'checkicon solid'`, { timeout: 10000, label: 'ep1 solid again' });
await clickValue('button.season-toggle', SEASON1);
await page.waitFor(`!document.querySelector('button.checkicon[value="${EP1}"]')`, { timeout: 10000, label: 'season 1 collapsed' });
st = await svgState();
cs = await carets();
check('after COLLAPSING season 1 again: every check + caret is a drawn SVG, its caret points DOWN again', svgOk(st) && cs === JSON.stringify(['up', 'down']), st + ' ' + cs);
// ---- tracker#17: SKELETON rows while a season's episodes load. The face's frame is held back 1.5 s (`__delayFace`), so
// the state right after the click is the one BEFORE the answer. Season 1 has 2 episodes → 2 skeleton rows.
const skeletonState = () => ev(`JSON.stringify((() => { const sk = Array.from(document.querySelectorAll('skeleton-row'));
const ep = document.querySelector('episode-row'), t = sk[0] && sk[0].querySelector('skeleton-title');
return { n: sk.length, ep1: !!document.querySelector('button.checkicon[value="${EP1}"]'), anim: t ? getComputedStyle(t).animationName : null,
parts: sk.every(r => r.querySelector('skeleton-check') && r.querySelector('skeleton-number') && r.querySelector('skeleton-title')),
h: sk[0] ? Math.round(sk[0].getBoundingClientRect().height) : 0, epH: ep ? Math.round(ep.getBoundingClientRect().height) : 0,
checkW: sk[0] ? Math.round(sk[0].querySelector('skeleton-check').getBoundingClientRect().width) : 0,
afterSeason1: sk[0] ? sk[0].previousElementSibling.querySelector('button.season-toggle').value === '${SEASON1}' : false }; })())`).then(JSON.parse);
const delayFace = (ms) => ev(`window.__delayFace = ${ms ? `{ name: 'showSeasonEpisodes', ms: ${ms} }` : 'null'}`);
for (const [w, h, mobile] of [[390, 844, true], [1280, 900, false]]) {
await page.send('Emulation.setDeviceMetricsOverride', { width: w, height: h, deviceScaleFactor: mobile ? 2 : 1, mobile });
await delayFace(1500);
await clickValue('button.season-toggle', SEASON1);
await page.waitFor(`document.querySelectorAll('skeleton-row').length > 0`, { timeout: 1000, label: 'skeleton' }).catch(() => {});
await ev(`document.querySelector('skeleton-row') && document.querySelector('skeleton-row').scrollIntoView({ block: 'center' })`);
let sk = await skeletonState();
cs = await carets();
check(`${w} px (tracker#17): right after the click, before the answer — 2 skeleton rows (season 1 has 2 episodes) under season 1, in the episode row's shape (check disc, number, title; same height), shimmering; no episode yet; caret already UP`,
sk.n === 2 && !sk.ep1 && sk.anim === 'tracker-shimmer' && sk.parts && Math.abs(sk.h - sk.epH) <= 1 && sk.checkW === 32 && sk.afterSeason1 && cs === JSON.stringify(['up', 'up']), JSON.stringify(sk) + ' ' + cs);
if (process.env.TRACKER_GATE_SHOTS) { mkdirSync(process.env.TRACKER_GATE_SHOTS, { recursive: true }); writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `show-skeleton-${w}.png`), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64')); }
await page.waitForSelector(`button.checkicon[value="${EP1}"]`, { timeout: 10000 });
sk = await skeletonState();
once = await rowsOnce('show-seasons button.checkicon');
check(`${w} px (tracker#17): after the answer the skeleton is gone and the real rows are there once each (2 seasons + 3 episodes, hybriel#121), still solid`,
sk.n === 0 && once.unique && once.n === 5 && (await checkClass(EP1)) === 'checkicon solid' && (await checkClass(EP2)) === 'checkicon solid', JSON.stringify(sk) + ' ' + JSON.stringify(once));
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `show-open-${w}.png`), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
await clickValue('button.season-toggle', SEASON1);
await page.waitFor(`!document.querySelector('button.checkicon[value="${EP1}"]')`, { timeout: 10000, label: 'season 1 closed' });
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `show-closed-${w}.png`), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
}
await page.send('Emulation.clearDeviceMetricsOverride', {});
// closed again WHILE loading: the late answer must not bring the rows back
const sent0 = (await page.wsSent()).length;
await delayFace(1200);
await clickValue('button.season-toggle', SEASON1);
await page.waitFor(`document.querySelectorAll('skeleton-row').length === 2`, { timeout: 1000, label: 'skeleton 2' }).catch(() => {});
await clickValue('button.season-toggle', SEASON1);
await new Promise(r => setTimeout(r, 1800));
once = await rowsOnce('show-seasons button.checkicon');
cs = await carets();
check('tracker#17: a season closed again while loading stays closed after the late answer (only season 2\'s episode, no skeleton, caret down)',
once.n === 3 && !once.values.includes(EP1) && (await ev(`document.querySelectorAll('skeleton-row').length`)) === 0 && cs === JSON.stringify(['up', 'down']), JSON.stringify(once) + ' ' + cs);
await delayFace(0);
// closing asks the server nothing; opening sends exactly the one sessionless face (no showRows)
const sentNow = (await page.wsSent()).slice(sent0);
check('tracker#17: opening sends only showSeasonEpisodes (never the session face showRows), closing sends nothing',
sentNow.filter(f => f.includes('showSeasonEpisodes')).length === 1 && !sentNow.some(f => f.includes('showRows')), JSON.stringify(sentNow));
// ---- mission 047 #12: FOLLOW on the show page — "Following" filled; a click unfollows ("Follow", outlined in the
// accent), the show leaves /my/shows; a click follows again (follow date = now) → the top of /my/shows; reloads keep it
const followState = () => ev(`JSON.stringify((() => { const b = document.querySelector('#follow'); const c = getComputedStyle(b);
return { text: b.textContent, cls: b.getAttribute('class'), bg: c.backgroundColor, border: c.borderTopWidth + ' ' + c.borderTopColor }; })())`);
let fs = JSON.parse(await followState());
check('follow: alice follows the show → "Following", the filled accent button (no border)', fs.text === 'Following' && fs.cls === 'follow' && fs.bg === 'rgb(78, 201, 176)' && fs.border.startsWith('0px'), JSON.stringify(fs));
await page.click('#follow');
await page.waitFor(`document.querySelector('#follow').textContent === 'Follow'`, { timeout: 10000, label: 'unfollowed' }).catch(() => {});
fs = JSON.parse(await followState());
check('follow: a click unfollows → "Follow", outlined (1px accent border, transparent)', fs.text === 'Follow' && fs.cls === 'follow inverted' && fs.border === '1px rgb(78, 201, 176)' && fs.bg === 'rgba(0, 0, 0, 0)', JSON.stringify(fs));
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('follow: the unfollow survives a reload', (await ev(`document.querySelector('#follow').textContent`)) === 'Follow');
await page.goto(BASE + '/my/shows');
await hydrated();
ms = await myShows();
check('follow: the unfollowed show is gone from /my/shows', ms.length === 1 && ms[0].href === '/shows/unwatched-gate-show', JSON.stringify(ms));
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
await page.click('#follow');
await page.waitFor(`document.querySelector('#follow').textContent === 'Following'`, { timeout: 10000, label: 'followed' }).catch(() => {});
check('follow: a click follows again → "Following"', (await ev(`document.querySelector('#follow').textContent`)) === 'Following');
await new Promise(r => setTimeout(r, 400));
check('session-sync: after the Follow toggles (face showToggleFollow) ONE Follow button, one show header, every season row once',
(await ev(`document.querySelectorAll('#follow').length === 1 && document.querySelectorAll('show-header').length === 1`)) && (await rowsOnce('season-row button.checkicon')).unique);
await page.goto(BASE + '/my/shows');
await hydrated();
ms = await myShows();
check('follow: followed just now → the TOP of /my/shows (newest follow first), after a reload', ms.length === 2 && ms[0].href === '/shows/gate-test-show' && ms[1].href === '/shows/unwatched-gate-show', JSON.stringify(ms));
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
check('follow: "Following" survives a reload', (await ev(`document.querySelector('#follow').textContent`)) === 'Following');
// ==== tracker.worldapi.org#13: /movies, /shows (24 per page, the copied pagination, the page in the PATH) and
// /my/movies (the Follow button on a movie's page) ====
await page.goto(BASE + '/');
await hydrated();
await ev(`window.__w050 = 'same document'`);
await page.click('#home-movies h2 a');
await page.waitFor(`location.pathname === '/movies' && document.querySelectorAll('a.tile').length === 24`, { timeout: 10000, label: 'heading → /movies' });
let titles = await titlesOf('tile-grid');
check('/movies (the homepage heading, client-side): page 1 = 24 movies, release date desc — the 2099 one first, then Pager Movie 30…08',
(await ev('window.__w050')) === 'same document' && JSON.stringify(titles) === JSON.stringify(['Pager Future Movie', ...movieRange(30, 8)]), JSON.stringify(titles));
let pg = await pagerState();
check('/movies: the pagination says "1 2 Next", 1 current (no Previous on the first page); "33 movies … page 1 of 2"',
JSON.stringify(pg) === JSON.stringify({ items: ['1', '2', 'Next'], current: '1' }) && /^33 movies, newest first · page 1 of 2$/.test(await ev(`document.querySelector('.list-count').textContent`)), JSON.stringify(pg));
await ev(`Array.from(document.querySelectorAll('pagination button')).find(b => b.textContent.trim() === 'Next').click()`);
await page.waitFor(`location.pathname === '/movies/page/2' && document.querySelectorAll('a.tile').length === 9`, { timeout: 10000, label: 'Next → page 2' });
titles = await titlesOf('tile-grid');
pg = await pagerState();
check('/movies "Next": the address is /movies/page/2 (client-side), the last 9: Pager Movie 07…01, the 1996 fixture movie, the undated one last; "Previous 1 2", 2 current; title says page 2',
(await ev('window.__w050')) === 'same document' && JSON.stringify(titles) === JSON.stringify([...movieRange(7, 1), 'Gate Test Movie', 'Pager Undated Movie'])
&& JSON.stringify(pg) === JSON.stringify({ items: ['Previous', '1', '2'], current: '2' }) && (await ev('document.title')) === 'Movies, page 2 — tracker', JSON.stringify({ titles, pg }));
await ev(`Array.from(document.querySelectorAll('pagination button')).find(b => b.textContent.trim() === '1').click()`);
await page.waitFor(`location.pathname === '/movies' && document.querySelectorAll('a.tile').length === 24`, { timeout: 10000, label: '1 → /movies' });
check('/movies: the page number "1" goes back to /movies (page 1)', (await pagerState()).current === '1' && (await titlesOf('tile-grid'))[0] === 'Pager Future Movie');
await ev('history.back()');
await page.waitFor(`location.pathname === '/movies/page/2' && document.querySelectorAll('a.tile').length === 9`, { timeout: 10000, label: 'Back → page 2' });
check('/movies: the browser\'s Back returns to /movies/page/2 with page 2 shown', (await pagerState()).current === '2' && (await ev('window.__w050')) === 'same document');
await page.goto(BASE + '/movies/page/2');
await hydrated();
check('/movies/page/2 loaded directly: the same 9 movies, 2 current', (await ev(`document.querySelectorAll('a.tile').length`)) === 9 && (await pagerState()).current === '2');
await page.goto(BASE + '/movies/page/99');
await hydrated();
const p99 = await pagerState();
await page.goto(BASE + '/movies/page/abc');
await hydrated();
check('/movies: a page past the end shows the last page, a page that is no number the first', p99.current === '2' && (await pagerState()).current === '1');
await page.goto(BASE + '/');
await hydrated();
await ev(`window.__w050 = 'same document'`);
await page.click('#home-shows h2 a');
await page.waitFor(`location.pathname === '/shows' && !!document.querySelector('tile-grid a.tile')`, { timeout: 10000, label: 'heading → /shows' });
tl = await tilesOf('tile-grid');
check('/shows (the homepage heading): every series (no movies) by newest released episode, the one with none released last; one page → no pagination at all',
(await ev('window.__w050')) === 'same document' && JSON.stringify(tl.map(t => t.split('|')[0])) === JSON.stringify(['Pager Older Series', 'Gate Test Show', 'Unwatched Gate Show'])
&& (await ev(`document.querySelectorAll('pagination').length`)) === 0, JSON.stringify(tl));
// a movie's page has the Follow button (the show page) → /my/movies; /my/shows stays series only
await page.click('a.tile[href="/shows/gate-test-show"]');
await page.waitFor(`location.pathname === '/shows/gate-test-show' && !!document.querySelector('#follow')`, { timeout: 10000, label: 'tile → show page' });
check('/shows: a tile opens the show page (client-side)', (await ev('window.__w050')) === 'same document');
await page.goto(BASE + '/shows/gate-test-movie');
await hydrated();
check('a movie\'s page has the Follow button ("Follow": alice does not follow it yet)', (await ev(`document.querySelector('#follow').textContent`)) === 'Follow');
await page.click('#follow');
await page.waitFor(`document.querySelector('#follow').textContent === 'Following'`, { timeout: 10000, label: 'movie followed' }).catch(() => {});
await page.goto(BASE + '/my/movies');
await hydrated();
const myMovies = await ev(`JSON.stringify(Array.from(document.querySelectorAll('my-show-row')).map(r => [r.querySelector('a.myshow-title').textContent, r.querySelector('a.myshow-title').getAttribute('href'), r.querySelector('img.myshow-poster').getAttribute('src')].join('|')))`);
check('/my/movies: the movie alice just followed — title with year, its page, the poster (placeholder URL)', myMovies === JSON.stringify(['Gate Test Movie (1996)|/shows/gate-test-movie|/posters/none']), myMovies);
await page.goto(BASE + '/my/shows');
await hydrated();
ms = await myShows();
check('/my/shows stays SERIES only: the followed movie is not there', ms.length === 2 && ms.every(m => m.href !== '/shows/gate-test-movie'), JSON.stringify(ms));
// ---- mission 047, MOBILE FIRST: at a phone's 390 px the header is ONE row (brand + ident selector + "Log out"), and
// no page scrolls sideways; at 1280 px the same pages. Screenshots of both widths with TRACKER_GATE_SHOTS.
const pages = [['home', '/'], ['show', '/shows/gate-test-show'], ['my-shows', '/my/shows'], ['my-unwatched', '/my/unwatched'], ['my-schedule', '/my/schedule'],
['movies', '/movies'], ['movies-page-2', '/movies/page/2'], ['shows-list', '/shows'], ['my-movies', '/my/movies'], ['search', '/search/gate']];
if (process.env.TRACKER_GATE_SHOTS) mkdirSync(process.env.TRACKER_GATE_SHOTS, { recursive: true });
for (const [w, h, mobile] of [[390, 844, true], [1280, 900, false]]) {
await page.send('Emulation.setDeviceMetricsOverride', { width: w, height: h, deviceScaleFactor: mobile ? 2 : 1, mobile });
const bad = [];
for (const [name, path] of pages) {
await page.goto(BASE + path);
await hydrated();
const m = JSON.parse(await ev(`JSON.stringify((() => {
const hd = document.querySelector('application-header').getBoundingClientRect();
const mid = (s) => { const r = document.querySelector(s).getBoundingClientRect(); return r.top + r.height / 2; };
const mids = ['application-header .brand', '#selector', '#logout'].map(mid);
const wd = (s) => Math.round(document.querySelector(s).getBoundingClientRect().width);
return { headerH: hd.height, spread: Math.max(...mids) - Math.min(...mids), scrollW: document.documentElement.scrollWidth, widths: ['application-header .brand', '#userbox', '#selector', '#logout'].map(wd) };
})())`));
if (m.spread > 8 || m.headerH > 64 || m.scrollW > w) bad.push(name + ' ' + JSON.stringify(m));
if (name === 'show') {
// mission 047 #8: phone = title first, then the poster at the full content width, then genres/plot/cast;
// desktop unchanged = poster left (10rem), title right of it
const L = JSON.parse(await ev(`JSON.stringify((() => { const b = (s) => { const r = document.querySelector(s).getBoundingClientRect(); return { l: r.left, r: r.right, t: r.top, b: r.bottom, w: r.width }; };
const main = document.querySelector('main'); const cs = getComputedStyle(main);
return { h1: b('show-header h1'), follow: b('#follow'), links: b('show-links'), poster: b('show-poster img'), genres: b('show-genres'), summary: b('show-summary'), cast: b('show-cast'),
content: main.getBoundingClientRect().width - parseFloat(cs.paddingLeft) - parseFloat(cs.paddingRight) }; })())`));
const ok = mobile
? L.h1.b <= L.links.t && L.links.b <= L.poster.t && Math.abs(L.poster.w - L.content) < 1 && L.poster.b <= L.genres.t && L.genres.b <= L.summary.t && L.summary.b <= L.cast.t && L.follow.t < L.poster.t
: Math.abs(L.poster.w - 160) < 1 && L.poster.r <= L.h1.l && L.h1.t < L.poster.b && L.poster.t <= L.genres.t && L.poster.r <= L.links.l && L.h1.b <= L.links.t && L.links.b <= L.genres.t;
check(`${w} px: show page layout — ${mobile ? 'title (+ Follow) first, the link icons under it, then the poster at the full content width, then genres, plot, cast' : 'poster left (10rem), the title right of it, the link icons under the title'}`, ok, JSON.stringify(L));
}
if (process.env.TRACKER_GATE_SHOTS) {
if (name === 'my-shows' || name === 'my-movies') await waitPostersLoaded();
// #13: every poster tile in view loaded
await page.waitFor(`Array.from(document.querySelectorAll('img.tile-poster')).filter(i => { const r = i.getBoundingClientRect(); return r.top < innerHeight && r.bottom > 0 && r.left < innerWidth && r.right > 0 }).every(i => i.complete && i.naturalWidth > 0)`, { timeout: 10000, label: 'tiles loaded' });
const shot = await page.send('Page.captureScreenshot', { format: 'png' });
writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `${name}-${w}.png`), Buffer.from(shot.data, 'base64'));
}
}
check(`${w} px: on every page the header is one row (brand, ident selector, "Log out" side by side, ≤ 64 px high) and nothing scrolls sideways`, bad.length === 0, bad.join('; '));
}
await page.send('Emulation.clearDeviceMetricsOverride', {});
// ==== tracker.worldapi.org#9: THE TMDB SYNC, against the fake TMDB — first the tool (app stopped: hl:mpackdb is
// one process per storage), twice (idempotent), then the pages; then the app's own daily run ====
check('sync: the app ran with the daily sync switched off until now (TRACKER_SYNC=0), no TMDB request yet', log.includes('tmdb sync: off (TRACKER_SYNC=0)') && tmdb.requests.length === 0, log);
await page.goto('about:blank'); // leave the app first: an open page would log websocket reconnect errors
await stopServer();
// spawned, not execFileSync: the fake TMDB lives in THIS node process and must keep answering meanwhile
const runTool = () => new Promise((ok) => {
const p = spawn(join(APP, 'bin/hybriel'), ['tools/sync-tmdb.hl', '--limit', '5'], { cwd: APP, env: { ...process.env, TRACKER_STORAGE: MPACKDB, ...TMDB_ENV }, stdio: ['ignore', 'pipe', 'pipe'] });
let o = '';
p.stdout.on('data', d => o += d); p.stderr.on('data', d => o += d);
p.on('exit', () => ok(o));
});
let out = await runTool();
let done = (out.match(/tmdb sync done: .*/) || [''])[0];
check('sync tool: 3 followed shows (2 series + a movie another user follows) → 2 new seasons (show 1 S3, show 2 S1), 4 new episodes, the 3 fixture episodes updated (tmdbId by S/E number, E2 renamed), 3 posters, 5 ids filled, 3 TVmaze lookups + 2 TVmaze episode lists (#15: they agree with TMDB → nothing taken), 0 errors',
done.includes('shows=3 newSeasons=2 newEpisodes=4 updatedEpisodes=3') && done.includes('posters=3 ids=5') && done.includes('tvmazeRequests=5 errors=0 tvmazeEpisodes=0 tvmazeSeasons=0 tvmazeFilled=0 tvmazeSkipped=0'), out);
// per show, in this order (the order BETWEEN shows follows the follow table, which the follow test above reshuffled)
const perShow = [['/3/tv/1001?append_to_response=external_ids', '/3/tv/1001?append_to_response=season/1,season/2,season/3', '/t/p/w342/gate1.png'],
['/3/tv/1002?append_to_response=external_ids', '/3/tv/1002?append_to_response=season/1', '/t/p/w342/gate2.png'], ['/3/movie/1003?append_to_response=external_ids', '/t/p/w342/gate3.png']];
const paths = tmdb.requests.map(q => q.path);
check('sync tool: every TMDB call carried the Bearer token, season 0 was never asked for; per show ONE details request that also brings external_ids (no extra request), one for its seasons, the poster; the movie only via /movie/, never /tv/1003',
tmdb.requests.filter(q => q.path.startsWith('/3/')).every(q => q.authorization === 'Bearer gate-token') && !paths.some(p => p.includes('season/0'))
&& JSON.stringify([...paths].sort()) === JSON.stringify(perShow.flat().sort()) && perShow.every(list => list.every((p, i) => i === 0 || paths.indexOf(list[i - 1]) < paths.indexOf(p))),
JSON.stringify(paths));
check('sync tool: TVmaze asked only for shows without a TVmaze id: show 1 by imdb (hit), show 2 by imdb (404) then by thetvdb (hit); then (#15) each series\' episode list by the found id; never for the movie',
JSON.stringify([...tmdb.tvmazeRequests].sort()) === JSON.stringify(['/tvmaze/lookup/shows?imdb=tt0000001', '/tvmaze/lookup/shows?imdb=tt0000002', '/tvmaze/lookup/shows?thetvdb=4002', '/tvmaze/shows/501', '/tvmaze/shows/502', '/tvmaze/shows/501/episodes', '/tvmaze/shows/502/episodes'].sort()),
JSON.stringify(tmdb.tvmazeRequests));
const tvmazeBefore = tmdb.tvmazeRequests.length;
out = await runTool();
done = (out.match(/tmdb sync done: .*/) || [''])[0];
check('sync tool again: idempotent — nothing new, nothing updated, no poster downloaded again, no id filled, no TVmaze lookup (every show has its TVmaze id now) — only the 2 episode lists, nothing taken from them',
done.includes('newSeasons=0 newEpisodes=0 updatedEpisodes=0 updatedSeasons=0 posters=0 ids=0') && done.includes('tvmazeRequests=2 errors=0 tvmazeEpisodes=0 tvmazeSeasons=0 tvmazeFilled=0 tvmazeSkipped=0')
&& JSON.stringify(tmdb.tvmazeRequests.slice(tvmazeBefore).sort()) === JSON.stringify(['/tvmaze/shows/501/episodes', '/tvmaze/shows/502/episodes']), out);
await startServer();
await page.goto(BASE + '/my/schedule');
await hydrated();
const scheduleRows = () => ev(`Array.from(document.querySelectorAll('schedule-row')).map(r => r.querySelector('.schedule-show').textContent + ' | ' + r.querySelector('schedule-episode').textContent + ' | ' + r.querySelector('schedule-date').textContent)`);
let rows = await scheduleRows();
check('after the sync: /my/schedule lists the new upcoming episodes of both shows, soonest first', JSON.stringify(rows) === JSON.stringify([
'Unwatched Gate Show (2025) | S01E01 · Brand New | 2097-01-01', 'Gate Test Show (2024) | S03E02 · Coming Soon | 2098-06-01', 'Gate Test Show (2024) | S02E01 · Season Two Opener | 2099-01-01']), JSON.stringify(rows));
await page.goto(BASE + '/my/unwatched');
await hydrated();
rows = await ev(`Array.from(document.querySelectorAll('unwatched-row')).map(r => r.querySelector('unwatched-episode').textContent + ' | ' + r.querySelector('unwatched-date').textContent)`);
check('after the sync: /my/unwatched lists the newly released episodes (S03E01, S01E03), newest first', JSON.stringify(rows) === JSON.stringify(['S03E01 · Third Season Start | 2021-05-05', 'S01E03 · Third | 2020-09-01']), JSON.stringify(rows));
await page.goto(BASE + '/my/shows');
await hydrated();
await waitPostersLoaded();
ms = await myShows();
check('after the sync: /my/shows shows both real posters (/posters/sh2.png is new), loaded', ms.length === 2 && ms.every(m => m.posterLoaded) && ms[0].poster === '/posters/sh1.png' && ms[1].poster === '/posters/sh2.png', JSON.stringify(ms));
r = await fetch(BASE + '/posters/sh2.png');
const posterBytes = Buffer.from(await r.arrayBuffer());
check('the downloaded poster is served by /posters/… byte for byte (image/png), stored in storage (mpackdb/posters/)', r.status === 200 && r.headers.get('content-type') === 'image/png' && posterBytes.equals(PNG) && existsSync(join(MPACKDB, 'posters', 'sh2.png')));
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
const seasonCounts = await ev(`Array.from(document.querySelectorAll('season-row')).map(e => e.querySelector('season-label').textContent + ': ' + e.querySelector('season-count').textContent)`);
check('after the sync: the show page has S3 (new) S2 S1, no season 0, no duplicated episode (S1 has 3)', JSON.stringify(seasonCounts) === JSON.stringify(['Season 3: 2 episodes', 'Season 2: 1 episode', 'Season 1: 3 episodes']), JSON.stringify(seasonCounts));
check('after the sync: the latest season shows its new episodes, the poster is the downloaded one',
JSON.stringify(await ev(`Array.from(document.querySelectorAll('episode-row episode-title')).map(e => e.textContent)`)) === JSON.stringify(['Third Season Start', 'Coming Soon'])
&& (await ev(`document.querySelector('show-poster img').getAttribute('src')`)) === '/posters/sh1.png' && (await ev(`document.querySelector('show-poster img').naturalWidth`)) > 0);
await clickValue('button.season-toggle', SEASON1);
await page.waitForSelector(`button.checkicon[value="${EP1}"]`, { timeout: 10000 });
const s1 = await ev(`Array.from(document.querySelectorAll('episode-row')).map(e => e.querySelector('episode-number').textContent + ' ' + e.querySelector('episode-title').textContent + ' ' + e.querySelector('button.checkicon').getAttribute('class'))`);
check('after the sync: S1 keeps its episodes (same ids, still watched), E2 renamed from TMDB, E3 new and unwatched',
s1.includes('1 Pilot checkicon solid') && s1.includes('2 Second Episode checkicon solid') && s1.includes('3 Third checkicon regular') && s1.length === 5, JSON.stringify(s1));
// ---- tracker.worldapi.org#12: after the sync every show has the ids it lacked — the stored ones unchanged ----
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
lk = await extLinks();
check('after the sync: show 1 has all four icons — its OWN imdb id kept (tt0000001, not TMDB\'s tt9999999), tvdb 4001 + TVmaze 501 filled',
linksAre(lk, [['TMDB', TMDB_TV + '1001'], ['IMDb', IMDB + 'tt0000001/'], ['TVDB', TVDB + '4001'], ['TVmaze', TVMAZE + '501']]), lk);
await page.goto(BASE + '/shows/unwatched-gate-show');
await hydrated();
lk = await extLinks();
check('after the sync: show 2 has all four — imdb tt0000002 filled, its OWN tvdb 4002 kept (not 4999), TVmaze 502 (found by thetvdb after imdb missed)',
linksAre(lk, [['TMDB', TMDB_TV + '1002'], ['IMDb', IMDB + 'tt0000002/'], ['TVDB', TVDB + '4002'], ['TVmaze', TVMAZE + '502']]), lk);
await page.goto(BASE + '/shows/gate-test-movie');
await hydrated();
lk = await extLinks();
check('after the sync: the movie has TMDB (/movie/1003) + IMDb (tt0000003 filled), no TheTVDB/TVmaze, no seasons',
linksAre(lk, [['TMDB', TMDB_MOVIE + '1003'], ['IMDb', IMDB + 'tt0000003/']]) && (await ev(`document.querySelectorAll('season-row').length`)) === 0, lk);
// ---- tracker.worldapi.org#13: the public lists are built at start — after the sync (tool, then a restart) show 1's new
// S03E01 (2021-05-05) puts it before Pager Older Series (2021-01-01); show 2 has only an upcoming episode: still last
await page.goto(BASE + '/shows');
await hydrated();
tl = await titlesOf('tile-grid');
check('after the sync + restart: /shows by newest released episode — Gate Test Show (S03E01 2021-05-05) first now, its synced poster; Unwatched Gate Show (only upcoming) last',
JSON.stringify(tl) === JSON.stringify(['Gate Test Show', 'Pager Older Series', 'Unwatched Gate Show']) && (await tilesOf('tile-grid'))[0].endsWith('|/posters/sh1.png'), JSON.stringify(tl));
if (process.env.TRACKER_GATE_SHOTS) {
await page.send('Emulation.setDeviceMetricsOverride', { width: 390, height: 844, deviceScaleFactor: 2, mobile: true });
for (const [name, path] of [['synced-show-390', '/shows/gate-test-show'], ['synced-movie-390', '/shows/gate-test-movie']]) {
await page.goto(BASE + path);
await hydrated();
writeFileSync(join(process.env.TRACKER_GATE_SHOTS, name + '.png'), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
}
await page.send('Emulation.setDeviceMetricsOverride', { width: 1280, height: 900, deviceScaleFactor: 1, mobile: false });
for (const [name, path] of [['synced-show', '/shows/gate-test-show'], ['synced-movie', '/shows/gate-test-movie'], ['synced-my-shows', '/my/shows'], ['synced-my-unwatched', '/my/unwatched'], ['synced-my-schedule', '/my/schedule']]) {
await page.goto(BASE + path);
await hydrated();
if (name === 'synced-my-shows') await waitPostersLoaded();
const shot = await page.send('Page.captureScreenshot', { format: 'png' });
writeFileSync(join(process.env.TRACKER_GATE_SHOTS, name + '.png'), Buffer.from(shot.data, 'base64'));
}
await page.send('Emulation.clearDeviceMetricsOverride', {});
}
// ---- THE DAILY RUN INSIDE THE APP: TRACKER_SYNC_HOUR = this very UTC hour, so the app's own clock starts the
// run right after boot. TMDB now has one more episode and answers slowly (700 ms per request): the run takes
// seconds, and pages asked for meanwhile must still be answered between two shows, never after the whole run.
await page.goto('about:blank');
await stopServer();
tmdb.shows[1001].seasons[3].episodes.push({ id: 5007, episode_number: 3, name: 'Added Live', air_date: '2096-03-03' });
// tracker.worldapi.org#13: and show 2 an episode that is ALREADY OUT — the running app must move it to the top of /shows
tmdb.shows[1002].seasons[0].episodes.push({ id: 7002, episode_number: 2, name: 'Out Already', air_date: '2022-02-02' });
tmdb.delayMs = 700;
const before = tmdb.requests.length, tvmazeBeforeRun = tmdb.tvmazeRequests.length;
await startServer({ TRACKER_SYNC: '1', TRACKER_SYNC_HOUR: String(new Date().getUTCHours()) });
const lat = [];
const t0 = Date.now();
while (!log.includes('tmdb sync done') && Date.now() - t0 < 30000) {
const a = Date.now();
await fetch(BASE + '/');
lat.push({ at: a - t0, ms: Date.now() - a, running: log.includes('tmdb sync: start') && !log.includes('tmdb sync done') });
await new Promise(r => setTimeout(r, 150));
}
const runDone = (log.match(/tmdb sync done: .*/) || [''])[0];
check('in-app daily run: started by the app\'s own clock at the configured hour, found the 2 new episodes, 0 errors',
log.includes('tmdb sync: daily at ' + new Date().getUTCHours() + ':00 UTC') && log.includes('tmdb sync: start, 3 followed shows') && runDone.includes('newSeasons=0 newEpisodes=2 updatedEpisodes=0') && runDone.includes('errors=0'), log);
const during = lat.filter(l => l.running);
const runSecs = Number((runDone.match(/seconds=([0-9.]+)/) || [0, 0])[1]);
console.log(` (in-app run ${runSecs} s; ${during.length} pages asked during it, slowest ${Math.max(0, ...during.map(l => l.ms))} ms)`);
check('in-app daily run: the server kept answering DURING the run (between shows) — every page < 2.5 s though the run took ≥ 3 s',
runSecs >= 3 && during.length >= 3 && during.every(l => l.ms < 2500), 'run ' + runSecs + ' s, during: ' + JSON.stringify(during));
check('in-app daily run: the Bearer token on every call, 5 requests (2 per series, 1 for the movie; no poster again: unchanged), no TVmaze lookup, only the 2 episode lists (#15)', tmdb.requests.slice(before).filter(q => q.path.startsWith('/3/')).every(q => q.authorization === 'Bearer gate-token') && tmdb.requests.length - before === 5
&& JSON.stringify(tmdb.tvmazeRequests.slice(tvmazeBeforeRun).sort()) === JSON.stringify(['/tvmaze/shows/501/episodes', '/tvmaze/shows/502/episodes']), JSON.stringify(tmdb.requests.slice(before)) + JSON.stringify(tmdb.tvmazeRequests.slice(tvmazeBeforeRun)));
await page.goto(BASE + '/my/schedule');
await hydrated();
rows = await scheduleRows();
check('after the in-app run: /my/schedule has the episode TMDB added meanwhile (S03E03, 2096-03-03) on top', rows.length === 4 && rows[0] === 'Gate Test Show (2024) | S03E03 · Added Live | 2096-03-03', JSON.stringify(rows));
await page.goto(BASE + '/shows');
await hydrated();
tl = await titlesOf('tile-grid');
check('after the in-app run (no restart): /shows has Unwatched Gate Show on top — its new S01E02 (2022-02-02) is out; the homepage row too',
JSON.stringify(tl) === JSON.stringify(['Unwatched Gate Show', 'Gate Test Show', 'Pager Older Series']), JSON.stringify(tl));
await page.goto(BASE + '/');
await hydrated();
tl = await titlesOf('#home-shows');
check('after the in-app run: the homepage\'s Shows row has it first as well', JSON.stringify(tl) === JSON.stringify(['Unwatched Gate Show', 'Gate Test Show', 'Pager Older Series']), JSON.stringify(tl));
// ==== tracker.worldapi.org#15: THE TVMAZE MERGE — TVmaze knows more than TMDB: show 1 (TVmaze 501) gets S3E4's real
// title + air date (TMDB: "Episode 4", no date), a new S3E5 and a new season 4; TVmaze's other name for S3E1 must NOT
// replace TMDB's; its S1E1 airs on another day but has the same title (still agrees). Show 2 (502) TVmaze numbers
// differently (S1E1 another title, 7 years off — like a split pilot) → TVmaze is ignored for it. ====
await page.goto('about:blank');
await stopServer();
tmdb.delayMs = 0;
tmdb.shows[1001].seasons[3].episodes.push({ id: 5008, episode_number: 4, name: 'Episode 4' });
const tvm501 = tmdb.tvmaze.episodes[501].filter(e => !(e.season === 3 && e.number === 1));
tvm501.push({ id: 8005, season: 3, number: 1, name: 'Other Name From TVmaze', airdate: '2021-05-05' }, { id: 8007, season: 3, number: 3, name: 'Added Live', airdate: '2096-03-03' },
{ id: 8008, season: 3, number: 4, name: 'Real Fourth', airdate: '2096-04-04' }, { id: 8009, season: 3, number: 5, name: 'Only On TVmaze', airdate: '2096-05-05' },
{ id: 8010, season: 4, number: 1, name: 'New Season Premiere', airdate: '2096-06-06' });
tmdb.tvmaze.episodes[501] = tvm501;
tmdb.tvmaze.episodes[502] = [{ id: 8101, season: 1, number: 1, name: 'Brand New Pre-Pilot', airdate: '2090-01-01' }, { id: 8102, season: 1, number: 2, name: 'Should Not Appear', airdate: '2097-02-01' }];
// a date that differs (another country's premiere) but the SAME title still counts as the same numbering
tvm501.find(e => e.season === 1 && e.number === 1).airdate = '2019-12-20';
out = await runTool();
done = (out.match(/tmdb sync done: .*/) || [''])[0];
check('tvmaze merge: TMDB adds S3E4 ("Episode 4", no date); TVmaze adds 2 episodes (S3E5, S4E1) + 1 season (S4), fills 1 episode (S3E4), skips show 2 (numbered differently), 0 errors',
done.includes('newSeasons=0 newEpisodes=1 updatedEpisodes=0') && done.includes('tvmazeRequests=2 errors=0 tvmazeEpisodes=2 tvmazeSeasons=1 tvmazeFilled=1 tvmazeSkipped=1') && out.includes('SKIPPED (numbered differently)'), out);
out = await runTool();
done = (out.match(/tmdb sync done: .*/) || [''])[0];
check('tvmaze merge again: idempotent — nothing new, nothing filled, no TMDB update (TMDB\'s "Episode 4" does not replace TVmaze\'s "Real Fourth")',
done.includes('newSeasons=0 newEpisodes=0 updatedEpisodes=0 updatedSeasons=0') && done.includes('errors=0 tvmazeEpisodes=0 tvmazeSeasons=0 tvmazeFilled=0 tvmazeSkipped=1'), out);
await startServer();
await page.goto(BASE + '/my/schedule');
await hydrated();
rows = await scheduleRows();
check('tvmaze merge: /my/schedule shows what only TVmaze has (S03E04 with its TVmaze title + date, S03E05, S04E01), in date order; nothing of show 2\'s differently numbered TVmaze list', JSON.stringify(rows) === JSON.stringify([
'Gate Test Show (2024) | S03E03 · Added Live | 2096-03-03', 'Gate Test Show (2024) | S03E04 · Real Fourth | 2096-04-04', 'Gate Test Show (2024) | S03E05 · Only On TVmaze | 2096-05-05',
'Gate Test Show (2024) | S04E01 · New Season Premiere | 2096-06-06', 'Unwatched Gate Show (2025) | S01E01 · Brand New | 2097-01-01',
'Gate Test Show (2024) | S03E02 · Coming Soon | 2098-06-01', 'Gate Test Show (2024) | S02E01 · Season Two Opener | 2099-01-01']), JSON.stringify(rows));
const seasonsAndTitles = async () => {
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
const seasons = await ev(`Array.from(document.querySelectorAll('season-row')).map(e => e.querySelector('season-label').textContent + ': ' + e.querySelector('season-count').textContent)`);
await clickValue('button.season-toggle', await ev(`Array.from(document.querySelectorAll('season-row')).find(e => e.querySelector('season-label').textContent === 'Season 3').querySelector('button.season-toggle').value`));
await page.waitFor(`document.querySelectorAll('episode-row').length >= 6`, { timeout: 10000, label: 'S3 expanded' });
const titles = await ev(`Array.from(document.querySelectorAll('episode-row')).map(e => e.querySelector('episode-number').textContent + ' ' + e.querySelector('episode-title').textContent)`);
return { seasons, titles };
};
let tst = await seasonsAndTitles();
check('tvmaze merge: the show page has the new Season 4 (1 episode) and Season 3 with 5 — S3E1 keeps TMDB\'s title, S3E4 TVmaze\'s',
JSON.stringify(tst.seasons) === JSON.stringify(['Season 4: 1 episode', 'Season 3: 5 episodes', 'Season 2: 1 episode', 'Season 1: 3 episodes'])
&& JSON.stringify(tst.titles) === JSON.stringify(['1 New Season Premiere', '1 Third Season Start', '2 Coming Soon', '3 Added Live', '4 Real Fourth', '5 Only On TVmaze']), JSON.stringify(tst));
if (process.env.TRACKER_GATE_SHOTS) {
for (const [w, h, mobile] of [[390, 844, true], [1280, 900, false]]) {
await page.send('Emulation.setDeviceMetricsOverride', { width: w, height: h, deviceScaleFactor: mobile ? 2 : 1, mobile });
for (const [name, path] of [['tvmaze-schedule', '/my/schedule'], ['tvmaze-show', '/shows/gate-test-show']]) {
await page.goto(BASE + path);
await hydrated();
writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `${name}-${w}.png`), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
}
}
await page.send('Emulation.clearDeviceMetricsOverride', {});
}
// TMDB catches up: it now lists S3E5 (its own title) and season 4 — the TMDB step ADOPTS TVmaze's rows by number (no
// duplicate), TMDB's values win; its "Episode 4" still never replaces "Real Fourth"
await page.goto('about:blank');
await stopServer();
tmdb.shows[1001].seasons[3].episodes.push({ id: 5009, episode_number: 5, name: 'Official Fifth', air_date: '2096-05-05' });
tmdb.shows[1001].seasons.push({ id: 95, season_number: 4, name: 'Season 4', air_date: '2096-06-06', episodes: [{ id: 5010, episode_number: 1, name: 'New Season Premiere', air_date: '2096-06-06' }] });
out = await runTool();
done = (out.match(/tmdb sync done: .*/) || [''])[0];
check('tvmaze merge, TMDB catches up: TMDB adopts the 2 TVmaze episodes (updatedEpisodes=2: tmdbId set, S3E5 renamed), creates nothing, TVmaze adds nothing',
done.includes('newSeasons=0 newEpisodes=0 updatedEpisodes=2 updatedSeasons=0') && done.includes('errors=0 tvmazeEpisodes=0 tvmazeSeasons=0 tvmazeFilled=0'), out);
await startServer();
tst = await seasonsAndTitles();
check('tvmaze merge, TMDB caught up: still S4 1 / S3 5 episodes (no duplicates), S3E5 now TMDB\'s "Official Fifth", S3E4 still "Real Fourth"',
JSON.stringify(tst.seasons) === JSON.stringify(['Season 4: 1 episode', 'Season 3: 5 episodes', 'Season 2: 1 episode', 'Season 1: 3 episodes'])
&& JSON.stringify(tst.titles) === JSON.stringify(['1 New Season Premiere', '1 Third Season Start', '2 Coming Soon', '3 Added Live', '4 Real Fourth', '5 Official Fifth']), JSON.stringify(tst));
// ==== tracker.worldapi.org#14: THE SEARCH, signed IN — "Add" imports the title like the daily sync and opens its page ====
tmdb.delayMs = 0;
await page.goto(BASE + '/search/gate');
await hydrated();
await page.click('#fetchweb');
await page.waitFor(`document.querySelectorAll('web-row').length > 0`, { timeout: 10000, label: 'web results (signed in)' });
const dbBefore = await searchTitles();
// hybriel#121/#122: a SESSION face (searchImport) that stays on the page — tv 1006's details answer 404 — must leave every
// list as it was: each row once, the route-param text still in the field and in data-for
await page.click('web-row button.add[value="tv:1006"]');
await page.waitFor(`!!document.querySelector('#importerror')`, { timeout: 10000, label: 'import error' }).catch(() => {});
await new Promise(r => setTimeout(r, 300));
check('search import: a failed import (TMDB 404) says so and stays — the database list, the web list and the text are unchanged, no row twice (hybriel#121/#122)',
(await ev(`document.querySelector('#importerror') ? document.querySelector('#importerror').textContent : ''`)) === 'Could not add it: TMDB: HTTP 404 for /tv/1006'
&& (await searchTitles()) === dbBefore && dbBefore === JSON.stringify(GATE_TITLES) && (await webList()) === JSON.stringify(GATE_WEB)
&& (await ev(`document.querySelector('#searchinput').value`)) === 'gate' && (await searchFor()) === 'gate' && (await ev('location.pathname')) === '/search/gate',
(await ev(`document.querySelector('search-page').outerHTML.slice(0, 1500)`)));
await typeSearch('gate t');
check('search import: after that session face the page still searches (typing "gate t" → the two "Gate Test" titles)', (await searchTitles()) === JSON.stringify(GATE_TITLES.slice(0, 2)), await searchTitles());
await typeSearch('gate');
await page.click('#fetchweb');
await page.waitFor(`document.querySelectorAll('web-row').length > 0`, { timeout: 10000 });
const reqBefore = tmdb.requests.length;
await page.click('web-row button.add[value="tv:1004"]');
await page.waitFor(`location.pathname !== '/search/gate' && !!document.querySelector('show-header h1')`, { timeout: 15000, label: 'imported show page' });
await page.waitFor(`!!document.querySelector('show-poster img') && document.querySelector('show-poster img').complete`, { timeout: 5000 }).catch(() => {});
const imp = JSON.parse(await ev(`JSON.stringify({ path: location.pathname, h1: document.querySelector('show-header h1').textContent,
seasons: Array.from(document.querySelectorAll('season-row')).map(r => r.querySelector('season-label').textContent + ': ' + r.querySelector('season-count').textContent),
episodes: Array.from(document.querySelectorAll('episode-row episode-title')).map(e => e.textContent), genres: Array.from(document.querySelectorAll('.genre-pill')).map(g => g.textContent),
poster: document.querySelector('show-poster img') ? document.querySelector('show-poster img').getAttribute('src') : null,
posterW: document.querySelector('show-poster img') ? document.querySelector('show-poster img').naturalWidth : 0, summary: document.querySelector('show-summary').textContent })`));
lk = await extLinks();
check('search import: "Add" on tv 1004 adds it and opens its page /shows/Gate-Import-Show — season, episodes, poster (downloaded), genres matched by name, the summary',
imp.path === '/shows/Gate-Import-Show' && imp.h1 === 'Gate Import Show' && JSON.stringify(imp.seasons) === JSON.stringify(['Season 1: 2 episodes'])
&& JSON.stringify(imp.episodes) === JSON.stringify(['Imported One', 'Imported Two']) && JSON.stringify(imp.genres) === JSON.stringify(['Drama'])
&& imp.poster === '/posters/tmdb-tv-1004.png' && imp.posterW > 0 && imp.summary === 'an imported series' && existsSync(join(MPACKDB, 'posters', 'tmdb-tv-1004.png')), JSON.stringify(imp));
check('search import: the ids came like the daily sync\'s — TMDB, IMDb tt0000004, TVDB 4004, TVmaze 504 (looked up by thetvdb)',
linksAre(lk, [['TMDB', TMDB_TV + '1004'], ['IMDb', IMDB + 'tt0000004/'], ['TVDB', TVDB + '4004'], ['TVmaze', TVMAZE + '504']]), lk);
const impPaths = tmdb.requests.slice(reqBefore).map(q => q.path);
check('search import: TMDB asked exactly like the sync (details, seasons, poster) + one details request for the new record, all with the token',
JSON.stringify(impPaths) === JSON.stringify(['/3/tv/1004', '/3/tv/1004?append_to_response=external_ids', '/3/tv/1004?append_to_response=season/1', '/t/p/w342/gate4.png'])
&& tmdb.requests.slice(reqBefore).filter(q => q.path.startsWith('/3/')).every(q => q.authorization === 'Bearer gate-token'), JSON.stringify(impPaths));
await page.goto(BASE + '/search/gate');
await hydrated();
st14 = await searchTitles();
check('search import: our database has it at once (the index too): "gate" now also lists Gate Import Show (2023)',
st14 === JSON.stringify([GATE_TITLES[0], GATE_TITLES[1], ['Gate Import Show (2023)', '/shows/Gate-Import-Show', 'Series'], GATE_TITLES[2]]), st14);
await page.click('#fetchweb');
await page.waitFor(`document.querySelectorAll('web-row').length > 0`, { timeout: 10000 });
wl = await webList();
check('search import: the web list leaves it out now (we have it)', wl === JSON.stringify(GATE_WEB.slice(1)), wl);
await page.click('web-row button.add[value="movie:1005"]');
await page.waitFor(`location.pathname === '/shows/Gate-Import-Movie' && !!document.querySelector('show-header h1')`, { timeout: 15000, label: 'imported movie page' });
lk = await extLinks();
check('search import: a MOVIE (movie 1005) → /shows/Gate-Import-Movie, synced via /movie/ (TMDB /movie/1005 + IMDb), no seasons',
(await ev(`document.querySelector('show-header h1').textContent`)) === 'Gate Import Movie' && linksAre(lk, [['TMDB', TMDB_MOVIE + '1005'], ['IMDb', IMDB + 'tt0000005/']])
&& (await ev(`document.querySelectorAll('season-row').length`)) === 0 && !tmdb.requests.some(q => q.path.startsWith('/3/tv/1005')), lk);
await page.goto(BASE + '/search/gate%20import');
await hydrated();
st14 = await searchTitles();
check('search import: both imported titles are found, each once', st14 === JSON.stringify([['Gate Import Show (2023)', '/shows/Gate-Import-Show', 'Series'], ['Gate Import Movie (2001)', '/shows/Gate-Import-Movie', 'Movie']]), st14);
// merge of #13 + #14: an imported title is in the public lists at once (catalog.hl refreshCatalogShow), no restart
await page.goto(BASE + '/movies');
await hydrated();
titles = await titlesOf('tile-grid');
await page.goto(BASE + '/shows');
await hydrated();
tl = await titlesOf('tile-grid');
check('search import → the lists at once: /movies has Gate Import Movie (2001-05-05) right after the 2099 one, /shows has Gate Import Show',
titles[0] === 'Pager Future Movie' && titles[1] === 'Gate Import Movie' && titles.filter(t => t === 'Gate Import Movie').length === 1 && tl.filter(t => t === 'Gate Import Show').length === 1, JSON.stringify({ titles, tl }));
if (process.env.TRACKER_GATE_SHOTS) {
for (const [w, h, mobile] of [[390, 844, true], [1280, 900, false]]) {
await page.send('Emulation.setDeviceMetricsOverride', { width: w, height: h, deviceScaleFactor: mobile ? 2 : 1, mobile });
await page.goto(BASE + '/search/gate');
await hydrated();
await page.click('#fetchweb');
await page.waitFor(`document.querySelectorAll('web-row').length > 0`, { timeout: 10000 });
await page.waitFor(`Array.from(document.querySelectorAll('img')).every(i => i.complete)`, { timeout: 5000 }).catch(() => {});
writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `search-web-${w}.png`), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
}
await page.send('Emulation.clearDeviceMetricsOverride', {});
}
check('search: the server log has no error (the imports logged their sync counts)', !/error absorbed/i.test(log) && (log.match(/search import: /g) || []).length === 2, log.split('\n').filter(l => /search|error/i.test(l)).join('\n'));
// ==== mission 054: ADULT TITLES — the public lists and the search show only titles TMDB says are NOT adult (unknown =
// hidden); a followed adult title stays on /my/* and its page; the in-app BACKFILL asks TMDB title by title, resumes
// after a restart, and pages stay fast meanwhile. tests/seed-adult.hl adds the titles (app stopped) ====
await page.goto('about:blank'); // mission 056: a tab left on a page logs websocket reconnect errors while the server is down
await stopServer();
const seedAdult = execFileSync(join(APP, 'bin/hybriel'), ['tests/seed-adult.hl'], { cwd: APP, env: { ...process.env, TRACKER_STORAGE: MPACKDB, TRACKER_SEED_USER: 'gateu0000000000u1' } }).toString();
check('adult: fixture written (1 adult title alice follows, 14 with an unknown flag)', seedAdult.includes('15 titles') && seedAdult.includes('follows Adult Gate Movie'), seedAdult);
await startServer();
const ADULT_ALL = ['Adult Gate Movie', 'Flagless Gate Movie', 'Flagless Adult Movie', 'Flagless Gate Series', 'Gone Gate Movie', 'Backfill Movie'];
// the signed-OUT HTML of a page (node fetch, no cookie): which of these titles it names
const namesIn = async (path) => { const h = await (await fetch(BASE + path)).text(); return ADULT_ALL.filter(t => h.includes(t)); };
const allMoviesHtml = async () => { let h = ''; for (const p of ['/movies', '/movies/page/2']) h += await (await fetch(BASE + p)).text(); return h; };
const mh = await allMoviesHtml();
let seen = { home: await namesIn('/'), movies: ADULT_ALL.filter(t => mh.includes(t)), shows: await namesIn('/shows') };
check('adult (backfill off): signed out, the homepage, every /movies page and /shows list NONE of the adult/unknown titles; the count is unchanged (34 movies)',
seen.home.length === 0 && seen.movies.length === 0 && seen.shows.length === 0 && mh.includes('34 movies, newest first'), JSON.stringify(seen));
let sr = await (await fetch(BASE + '/search/flagless')).text();
const sr2 = await (await fetch(BASE + '/search/adult%20gate')).text();
check('adult (backfill off): the search finds none of them ("flagless", "adult gate" → "Nothing in our database yet.")',
sr.includes('Nothing in our database yet.') && !sr.includes('class="search-title"') && sr2.includes('Nothing in our database yet.'), sr.slice(sr.indexOf('<search-page'), sr.indexOf('<search-page') + 600));
await page.goto(BASE + '/my/movies');
await hydrated();
const myMv = await ev(`JSON.stringify(Array.from(document.querySelectorAll('my-show-row')).map(r => r.querySelector('a.myshow-title').textContent))`);
check('adult: alice follows the adult movie → it IS on her /my/movies (newest follow first)', JSON.parse(myMv)[0] === 'Adult Gate Movie (2001)', myMv);
await page.click('a.myshow-title[href="/shows/adult-gate-movie"]');
await page.waitFor(`location.pathname === '/shows/adult-gate-movie' && !!document.querySelector('show-page')`, { timeout: 10000, label: 'adult page (alice)' });
await page.waitFor(`!!document.querySelector('show-header h1')`, { timeout: 5000 }).catch(() => {});
check('adult: …and its page opens for her (client-side from /my/movies, and on a reload) with "Following"',
(await ev(`document.querySelector('show-header h1') ? document.querySelector('show-header h1').textContent : 'none'`)) === 'Adult Gate Movie'
&& (await (async () => { await page.goto(BASE + '/shows/adult-gate-movie'); await hydrated(); return ev(`(document.querySelector('show-header h1') || {}).textContent + '|' + (document.querySelector('#follow') || {}).textContent`); })()) === 'Adult Gate Movie|Following');
// mission 056: the adult title's PAGE is "Not found" for anyone who does not follow it — signed out (no cookie) here
const adultOut = await (await fetch(BASE + '/shows/adult-gate-movie')).text();
const pageH1 = (h) => (h.match(/<show-page[^>]*>[\s\S]*?<h1[^>]*>([^<]*)<\/h1>/) || [])[1];
check('adult (056): signed out, /shows/adult-gate-movie says "Not found" and names no title (a non-adult page still opens: Flagless Gate Movie is unknown, not hidden)',
pageH1(adultOut) === 'Not found' && !adultOut.includes('Adult Gate Movie') && pageH1(await (await fetch(BASE + '/shows/flagless-gate-movie')).text()) === 'Flagless Gate Movie', pageH1(adultOut));
await page.goto(BASE + '/');
await hydrated();
const homeIn = await ev(`document.querySelector('home').textContent`);
check('adult: signed in too, the homepage rows have none of them (only /my/* is personal)', ADULT_ALL.every(t => !homeIn.includes(t)), homeIn);
await page.goto(BASE + '/search/gate');
await hydrated();
const wsBefore = tmdb.searchRequests.length;
await page.click('#fetchweb');
await page.waitFor(`document.querySelectorAll('web-row').length > 0 || !!document.querySelector('#webnote')`, { timeout: 10000, label: 'web results (adult)' });
wl = await webList();
check('adult: "Fetch from web" asks TMDB with include_adult=false and leaves out the result TMDB marks adult (Gate Adult Web)',
!wl.includes('Gate Adult Web') && wl.includes('Gate Broken Show') && tmdb.searchRequests.length === wsBefore + 1 && tmdb.searchRequests[wsBefore].path.includes('include_adult=false'), wl);
check('adult (backfill off): the log says so, no TMDB request was made for the unknown titles', log.includes('adult backfill: off (TRACKER_BACKFILL=0)') && !tmdb.requests.some(q => /\/3\/(movie|tv)\/(1012|1013|1014|1120|11\d\d)/.test(q.path)), log);
// ---- the BACKFILL: every answer slowed down to 300 ms; stopped after 6 titles, started again → it goes on with the rest ----
await page.goto('about:blank'); // mission 056: a tab left on a page logs websocket reconnect errors while the server is down
await stopServer();
tmdb.delayMs = 300;
const bfReq = tmdb.requests.length;
await startServer({ TRACKER_BACKFILL: '1', TRACKER_BACKFILL_LOG_EVERY: '3' });
const waitLog = async (re, ms) => { const t0 = Date.now(); while (!re.test(log) && Date.now() - t0 < ms) await new Promise(r => setTimeout(r, 100)); return re.test(log); };
const got6 = await waitLog(/adult backfill: 6\/14 titles/, 30000);
const log1 = log;
await page.goto('about:blank'); // mission 056: a tab left on a page logs websocket reconnect errors while the server is down
await stopServer();
const asked1 = tmdb.requests.slice(bfReq).map(q => q.path).filter(p => /^\/3\/(movie|tv)\//.test(p));
check('backfill: started with the 14 unknown titles, logs every 3 (TRACKER_BACKFILL_LOG_EVERY), one details request per title (+ external_ids), with the token',
got6 && log1.includes('adult backfill: start, 14 titles without an adult flag') && /adult backfill: 3\/14 titles/.test(log1)
&& asked1.every(p => p.endsWith('?append_to_response=external_ids')) && tmdb.requests.slice(bfReq).filter(q => q.path.startsWith('/3/')).every(q => q.authorization === 'Bearer gate-token'), log1.split('\n').filter(l => /backfill/.test(l)).join('\n'));
const bfReq2 = tmdb.requests.length;
await startServer({ TRACKER_BACKFILL: '1', TRACKER_BACKFILL_LOG_EVERY: '3' });
// the start line comes with the clock's first tick, which can be after the first page answer (mission 056: it was)
await waitLog(/adult backfill: start, \d+ titles/, 5000);
const left = Number((log.match(/adult backfill: start, (\d+) titles/) || [])[1]);
// pages DURING the run: signed out, the homepage, /movies and a search, back to back, timed
const during54 = [];
const t054 = Date.now();
while (!/adult backfill done/.test(log) && Date.now() - t054 < 60000) {
for (const p of ['/', '/movies', '/search/backfill']) { const t = Date.now(); await (await fetch(BASE + p)).text(); during54.push({ p, ms: Date.now() - t }); }
}
const bfSecs = (Date.now() - t054) / 1000;
const asked2 = tmdb.requests.slice(bfReq2).map(q => q.path).filter(p => /^\/3\/(movie|tv)\//.test(p));
const askedIds = [...asked1, ...asked2].map(p => p.match(/\/3\/(?:movie|tv)\/(\d+)/)[1]);
const twice = askedIds.filter((x, k) => askedIds.indexOf(x) !== k);
const doneLine = (log.match(/adult backfill done: .*/) || [''])[0];
console.log(` (backfill second start: ${left} titles left, ${bfSecs} s; ${during54.length} pages asked during it, slowest ${Math.max(0, ...during54.map(l => l.ms))} ms; ${doneLine})`);
check('backfill RESUMES after a restart: the second start finds only the titles still unknown (≤ 8 of 14), every one of the 14 was asked, none twice except at most the one cut off by the stop',
left >= 1 && left <= 8 && new Set(askedIds).size === 14 && twice.length <= 1 && asked1.length + asked2.length - twice.length === 14, JSON.stringify({ left, asked1, asked2, twice }));
check('backfill: done — it stops when nothing is unknown (the done line with its counts); the 404 (1120) was logged',
/^adult backfill done: \d+\/\d+ titles, adult=\d+ notAdult=\d+ unknown=\d+ posters=\d+ ids=\d+ requests=\d+ errors=\d+ retries=0 seconds=/.test(doneLine) && (log1 + log).includes('HTTP 404 for /movie/1120'), (log1 + log).split('\n').filter(l => /backfill/.test(l)).join('\n'));
check('backfill: pages stay fast during the run (300 ms per TMDB answer) — every page < 1.2 s, and pages were asked during it',
during54.length >= 6 && during54.every(l => l.ms < 1200), JSON.stringify(during54.filter(l => l.ms >= 500)));
// the lists updated AS the flags arrived (no restart since the run)
seen = { home: await namesIn('/'), shows: await namesIn('/shows') };
const mh2 = await allMoviesHtml();
seen.movies = ADULT_ALL.filter(t => mh2.includes(t));
check('backfill → the lists at once (no restart): /movies has Flagless Gate Movie + the 10 Backfill Movies (45 movies), NOT the adult ones or the 404; /shows and the homepage have Flagless Gate Series (+ the homepage Flagless Gate Movie)',
JSON.stringify(seen.movies) === JSON.stringify(['Flagless Gate Movie', 'Backfill Movie']) && mh2.includes('Backfill Movie 10') && mh2.includes('Backfill Movie 01') && mh2.includes('45 movies, newest first')
&& JSON.stringify(seen.shows) === JSON.stringify(['Flagless Gate Series']) && JSON.stringify(seen.home) === JSON.stringify(['Flagless Gate Movie', 'Flagless Gate Series']), JSON.stringify(seen));
sr = await (await fetch(BASE + '/search/flagless')).text();
check('backfill → the search at once: "flagless" finds Flagless Gate Series + Flagless Gate Movie, not Flagless Adult Movie',
sr.includes('Flagless Gate Movie') && sr.includes('Flagless Gate Series') && !sr.includes('Flagless Adult Movie'), sr.slice(sr.indexOf('<search-page'), sr.indexOf('<search-page') + 900));
check('backfill: the ADULT title\'s poster is NOT downloaded (Flagless Adult Movie: asked, but no /t/p/w342/flag13.png request, no posters/admvfa.* file)',
!tmdb.requests.some(q => q.path.includes('flag13')) && !readdirSync(join(MPACKDB, 'posters')).some(f => f.startsWith('admvfa.')) && tmdb.requests.some(q => q.path.startsWith('/3/movie/1013?')),
(log1 + log).split('\n').filter(l => /backfill/.test(l)).join('\n'));
const pr = await fetch(BASE + '/posters/admvfl.png');
check('backfill: the poster was downloaded and is served (/posters/admvfl.png, image/png)', pr.status === 200 && pr.headers.get('content-type') === 'image/png' && existsSync(join(MPACKDB, 'posters', 'admvfl.png')));
// a third start: nothing unknown is left that TMDB can answer (the 404 is marked) → no request at all
await page.goto('about:blank'); // mission 056: a tab left on a page logs websocket reconnect errors while the server is down
await stopServer();
const bfReq3 = tmdb.requests.length;
tmdb.delayMs = 0;
await startServer({ TRACKER_BACKFILL: '1' });
await waitLog(/adult backfill: nothing to do/, 5000);
await new Promise(r => setTimeout(r, 500));
check('backfill: a restart afterwards has nothing to do (the 404 title is marked, not asked again) — no TMDB request',
log.includes('adult backfill: start, 0 titles') && log.includes('adult backfill: nothing to do') && tmdb.requests.length === bfReq3, log.split('\n').filter(l => /backfill/.test(l)).join('\n'));
check('adult: the server log has no error', !/error absorbed/i.test(log), log);
await page.goto(BASE + '/');
await hydrated();
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, 'adult-home-1280.png'), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
// mission 056: alice UNFOLLOWS the adult movie on its page (a session face → hl:web's session sync re-derives `found` with
// the page's slug, hybriel#122): she no longer follows it → "Not found" at once, on a reload, and it leaves /my/movies
await page.goto(BASE + '/shows/adult-gate-movie');
await hydrated();
const adultBefore = await ev(`(document.querySelector('show-header h1') || {}).textContent + '|' + (document.querySelector('#follow') || {}).textContent`);
await page.click('#follow');
const adultGone = await page.waitFor(`(document.querySelector('show-page h1') || {}).textContent === 'Not found'`, { timeout: 5000, label: 'adult page hidden after unfollow' }).then(() => true, () => false);
const adultAfter = await ev(`(document.querySelector('show-page h1') || {}).textContent + '|' + ((document.querySelector('#follow') || {}).textContent || '')`);
await page.goto(BASE + '/shows/adult-gate-movie');
await hydrated();
const adultReload = await ev(`(document.querySelector('show-page h1') || {}).textContent`);
await page.goto(BASE + '/my/movies');
await hydrated();
const myMv2 = await ev(`Array.from(document.querySelectorAll('a.myshow-title')).map(a => a.textContent).join(',')`);
check('adult (056): alice sees the adult page while she follows it; after Unfollow ON the page it says "Not found" (no reload), on a reload too, and it is off her /my/movies',
adultBefore === 'Adult Gate Movie|Following' && adultGone && adultAfter === 'Not found|' && adultReload === 'Not found' && !myMv2.includes('Adult Gate Movie'), JSON.stringify({ adultBefore, adultAfter, adultReload, myMv2 }));
// and a normal show page still works after a session face (mission 054's failure: the browser re-derived `found` → `rows`)
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
const ep56 = await ev(`(() => { const b = document.querySelector('episode-row button.checkicon'); return b ? b.value + '|' + b.className : null; })()`);
await page.click('episode-row button.checkicon');
const ep56ok = await page.waitFor(`document.querySelector('episode-row button.checkicon').className !== ${JSON.stringify((ep56 || '|').split('|')[1])}`, { timeout: 5000, label: 'episode toggled (056)' }).then(() => true, () => false);
await page.click('episode-row button.checkicon');
const ep56back = await page.waitFor(`document.querySelector('episode-row button.checkicon').className === ${JSON.stringify((ep56 || '|').split('|')[1])}`, { timeout: 5000, label: 'episode toggled back (056)' }).then(() => true, () => false);
check('adult (056): on a normal show page an episode check toggles and toggles back (the session face + sync with the new `found`)', ep56 !== null && ep56ok && ep56back, ep56);
// ==== tracker.worldapi.org#16: PERSON PAGES — a complete person at once; an incomplete one fetches TMDB on the first visit
// ("Loading filmography…", filled without a reload, step by step), titles added once, adult hidden, the links, client-side
// navigation show → person → show → Back ====
const filmRows = () => ev(`JSON.stringify(Array.from(document.querySelectorAll('a.film-row')).map(a => [a.querySelector('film-title').textContent, a.querySelector('film-year').textContent, a.querySelector('film-type').textContent, a.querySelector('film-role').textContent, a.getAttribute('href')]))`).then(JSON.parse);
const personFacts = () => ev(`JSON.stringify({ h1: (document.querySelector('person-meta h1') || {}).textContent || null, facts: Array.from(document.querySelectorAll('person-fact')).map(f => f.textContent),
bio: (document.querySelector('person-bio') || {}).textContent || null, photo: (document.querySelector('person-photo img') || { getAttribute: () => null }).getAttribute('src'),
photoLoaded: !!(document.querySelector('person-photo img') && document.querySelector('person-photo img').complete && document.querySelector('person-photo img').naturalWidth > 0),
loading: !!document.querySelector('#personloading'), error: (document.querySelector('#fillerror') || {}).textContent || null })`).then(JSON.parse);
await page.goto(BASE + '/person/Complete-Person');
await hydrated();
await new Promise(r => setTimeout(r, 600));
let pf = await personFacts();
let fr = await filmRows();
check('person: a COMPLETE person shows at once — name, born/died, bio, the filmography newest first with roles and years; no loading, TMDB not asked',
pf.h1 === 'Complete Person' && JSON.stringify(pf.facts) === JSON.stringify(['Born 3 February 1950 in Gate City', 'Died 1 January 2020']) && pf.bio === 'A fixture person who is complete.'
&& pf.photo === null && !pf.loading && JSON.stringify(fr) === JSON.stringify([['Gate Test Show', '2024', 'Series', 'Old Role', '/shows/gate-test-show'], ['Gate Test Movie', '1996', 'Movie', 'Movie Role', '/shows/gate-test-movie']])
&& tmdb.personRequests.length === 0, JSON.stringify({ pf, fr, req: tmdb.personRequests }));
await page.goto(BASE + '/person/Nobody-Here');
await hydrated();
check('person: an unknown slug says "Not found"', (await ev(`document.querySelector('person-page h1').textContent`)) === 'Not found');
check('person: /profiles/<bad name> answers 400', (await fetch(BASE + '/profiles/..%2Fx')).status === 400 || (await fetch(BASE + '/profiles/a%20b')).status === 400);
// client-side: the show page's cast link → the person page (a window marker proves no reload); TMDB answers slowly (900 ms)
// so the loading state is seen; then it fills in by itself
tmdb.personDelayMs = 900;
await page.goto(BASE + '/shows/gate-test-show');
await hydrated();
await ev(`window.__w055 = 'same document'`);
const fillT0 = Date.now();
await page.click('a.artist-link[href="/person/Test-Actor"]');
await page.waitFor(`location.pathname === '/person/Test-Actor' && !!document.querySelector('person-meta h1')`, { timeout: 10000, label: 'person page after the cast click' });
pf = await personFacts();
const rowsBefore = (await filmRows()).length;
// meanwhile another request: answered while the fill runs (the fetch steps yield)
check('person: first visit (client-side from the cast link) shows "Loading filmography…" and no rows yet',
pf.h1 === 'Test Actor' && pf.loading && (await ev(`document.querySelector('#personloading').textContent`)).startsWith('Loading filmography') && rowsBefore === 0, JSON.stringify({ pf, rowsBefore }));
await page.waitFor(`!document.querySelector('#personloading') && document.querySelectorAll('a.film-row').length > 0`, { timeout: 20000, label: 'filmography filled in' });
const fillMs = Date.now() - fillT0;
await page.waitFor(`document.querySelector('person-photo img') && document.querySelector('person-photo img').complete`, { timeout: 5000, label: 'photo' }).catch(() => {});
pf = await personFacts();
fr = await filmRows();
const marker16 = await ev('window.__w055 || null');
check('person: the filmography filled in WITHOUT a reload (same document) — facts and the photo from TMDB too',
marker16 === 'same document' && !pf.loading && pf.error === null && JSON.stringify(pf.facts) === JSON.stringify(['Born 6 May 1970 in Fixture Town']) && pf.bio === 'Test Actor bio from TMDB.'
&& pf.photo === '/profiles/p1.png' && pf.photoLoaded, JSON.stringify({ marker16, pf, fillMs }));
const bio0 = await ev(`document.querySelector('person-bio').className`);
await page.click('person-bio');
await page.waitFor(`document.querySelector('person-bio').className === 'full'`, { timeout: 5000, label: 'bio open' }).catch(() => {});
const bio1 = await ev(`document.querySelector('person-bio').className + '|' + getComputedStyle(document.querySelector('person-bio')).webkitLineClamp`);
check('person: the bio is SHORT (four lines) until clicked, then whole', bio0 === 'short' && bio1 === 'full|none', bio0 + ' → ' + bio1);
const titles16 = fr.map(r => r[0]);
check('person: 86 rows (87 TMDB titles − the adult one), newest first, undated last; roles of cast + crew merged; the adult title hidden',
fr.length === 86 && JSON.stringify(fr.slice(0, 4)) === JSON.stringify([['Gate Test Show', '2024', 'Series', 'Someone', '/shows/gate-test-show'], ['Directed Only', '2018', 'Movie', 'Writer', '/shows/Directed-Only'],
['Person Series', '2015', 'Series', 'Lead', '/shows/Person-Series'], ['Person Film One', '2010', 'Movie', 'Hero / Director', '/shows/Person-Film-One']])
&& titles16[4] === 'Bulk Film 01' && titles16[83] === 'Bulk Film 80' && JSON.stringify(fr[84]) === JSON.stringify(['Gate Test Movie', '1996', 'Movie', 'Cameo', '/shows/gate-test-movie'])
&& JSON.stringify(fr[85]) === JSON.stringify(['Announced Film', '', 'Movie', 'Villain', '/shows/Announced-Film']) && !titles16.includes('Hidden Adult Film'), JSON.stringify(fr.slice(0, 6)) + ' … ' + JSON.stringify(fr.slice(-3)));
const posters16 = JSON.parse(await ev(`JSON.stringify(Array.from(document.querySelectorAll('a.film-row img.film-poster')).slice(0, 4).map(i => i.getAttribute('src')))`));
check('person: posters — our file when we have one (show 1), else TMDB\'s small one (w92), else the placeholder',
posters16[0] === '/posters/sh1.png' && posters16[1] === '/posters/none' && posters16[3] === tmdb.base + '/t/p/w92/pf1.png', JSON.stringify(posters16));
const pr16 = tmdb.personRequests.map(q => q.path);
const fillLines = log.split('\n').filter(l => l.startsWith('person fill: '));
check('person: ONE TMDB request (person + combined_credits, Bearer token) + the photo (w185); the fill ran in 4 steps (TMDB, then 3 × 40 titles) and added 85 titles (2 existed)',
JSON.stringify(pr16) === JSON.stringify(['/3/person/3002?append_to_response=combined_credits', '/t/p/w185/face2.png']) && tmdb.personRequests[0].authorization === 'Bearer gate-token'
&& fillLines.length === 1 && /^person fill: Test Actor \(tmdb 3002\) credits=87 added=85 requests=2 steps=4 /.test(fillLines[0]), JSON.stringify({ pr16, fillLines }));
tmdb.personDelayMs = 0;
// the links: a row → its show page (client-side); Back → the person page, complete now (no loading)
await page.click('a.film-row[href="/shows/gate-test-show"]');
await page.waitFor(`location.pathname === '/shows/gate-test-show' && !!document.querySelector('show-header h1')`, { timeout: 10000, label: 'show page from the filmography' });
const back1 = await ev(`document.querySelector('show-header h1').textContent + '|' + (window.__w055 || '')`);
await ev('history.back()');
await page.waitFor(`location.pathname === '/person/Test-Actor' && document.querySelectorAll('a.film-row').length === 86`, { timeout: 10000, label: 'Back to the person' });
pf = await personFacts();
check('person: a filmography row → the show page (client-side), Back → the person page, filled, no loading again',
back1 === 'Gate Test Show|same document' && !pf.loading && (await ev('window.__w055 || null')) === 'same document', JSON.stringify({ back1, pf }));
await page.click('a.film-row[href="/shows/Person-Film-One"]');
await page.waitFor(`location.pathname === '/shows/Person-Film-One' && !!document.querySelector('show-header h1')`, { timeout: 10000, label: 'new title page' });
lk = await extLinks();
check('person: a title the fill added has its page (/shows/Person-Film-One: title, the overview, TMDB link, genre Drama, the person in its cast)',
(await ev(`document.querySelector('show-header h1').textContent`)) === 'Person Film One' && (await ev(`document.querySelector('show-summary').textContent`)) === 'a film of the person'
&& linksAre(lk, [['TMDB', TMDB_MOVIE + '2001']]) && (await ev(`Array.from(document.querySelectorAll('a.genre-pill')).map(a => a.textContent).join(',')`)) === 'Drama'
&& (await ev(`Array.from(document.querySelectorAll('a.artist-link')).map(a => a.textContent + ' ' + a.getAttribute('href')).join(',')`)) === 'Test Actor /person/Test-Actor', lk);
// second visit (full load): complete — TMDB not asked again, nothing added, same rows
await page.goto(BASE + '/person/Test-Actor');
await hydrated();
await new Promise(r => setTimeout(r, 700));
pf = await personFacts();
check('person: a SECOND visit is complete at once — no loading, the same 86 rows, TMDB not asked again, no second fill',
!pf.loading && (await filmRows()).length === 86 && tmdb.personRequests.length === 2 && log.split('\n').filter(l => l.startsWith('person fill: ')).length === 1, JSON.stringify({ pf, req: tmdb.personRequests.length }));
// another person whose credits we have by now: linked, nothing added (no duplicate titles)
await page.goto(BASE + '/person/Second-Actor');
await hydrated();
await page.waitFor(`!document.querySelector('#personloading')`, { timeout: 15000, label: 'second actor filled' });
fr = await filmRows();
const second = log.split('\n').filter(l => l.startsWith('person fill: Second Actor'));
check('person: a second person with titles we have — linked, added=0, no photo; the title OUR record marks adult hidden though the credit is not',
JSON.stringify(fr) === JSON.stringify([['Gate Test Show', '2024', 'Series', 'Guest', '/shows/gate-test-show'], ['Person Film One', '2010', 'Movie', 'Sidekick', '/shows/Person-Film-One']])
&& second.length === 1 && / added=0 requests=1 /.test(second[0]) && (await personFacts()).photo === null, JSON.stringify({ fr, second }));
await page.goto(BASE + '/search/person%20film');
await hydrated();
check('person: the search finds the added title once', (await ev(`Array.from(document.querySelectorAll('a.search-title')).filter(a => a.textContent === 'Person Film One (2010)').length`)) === 1);
check('person: the server log has no error', !/error absorbed|not stored/i.test(log), log.split('\n').filter(l => /person|error/i.test(l)).join('\n'));
for (const [w, h, mobile] of [[390, 844, true], [1280, 900, false]]) {
await page.send('Emulation.setDeviceMetricsOverride', { width: w, height: h, deviceScaleFactor: mobile ? 2 : 1, mobile });
for (const [name, path] of [['person', '/person/Test-Actor'], ['person-complete', '/person/Complete-Person']]) {
await page.goto(BASE + path);
await hydrated();
await page.waitFor(`Array.from(document.querySelectorAll('img')).filter(i => i.getBoundingClientRect().top < innerHeight).every(i => i.complete)`, { timeout: 5000 }).catch(() => {});
check(`person: ${path} at ${w} px — no sideways scroll, header one row`, (await ev('document.documentElement.scrollWidth')) <= w && (await ev(`document.querySelector('application-header').getBoundingClientRect().height`)) <= 64);
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, `${name}-${w}.png`), Buffer.from((await page.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
}
}
await page.send('Emulation.clearDeviceMetricsOverride', {});
// ==== tracker.worldapi.org#10: THE INSTALLABLE APP — hl:web's own manifest + service worker (project.hl appIcons /
// offline = [ Home ]). The manifest and every icon over HTTP; Chrome's own verdict (installability, manifest parse);
// the worker registered for the whole app; then OFFLINE: the tab loses the network (the note appears), the server
// is stopped too (CDP's offline emulation does not reach the service worker's own fetches — measured — so only a
// dead server proves the cache), and `/` still opens: header + the note. A data page gets hl:web's "Unavailable
// offline" page. A separate tab, so its expected socket errors stay out of the main tab's console check.
const html = await (await fetch(BASE + '/')).text();
const mhref = (html.match(/<link rel="manifest" href="([^"]+)"/) || [])[1];
check('pwa: every page head links the manifest, the apple-touch-icon, the favicon and the theme colour (the token `darker`)',
mhref === '/__hl/manifest.webmanifest' && html.includes('<link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">')
&& html.includes('<link rel="icon" href="/icons/favicon.svg">') && html.includes('<meta name="theme-color" content="rgb(15, 20, 25)">'), html.slice(0, 900));
const mres = await fetch(BASE + mhref);
const man = await mres.json();
check('pwa: the manifest is served as application/manifest+json: name "tracker", start_url /, scope /, display standalone, the token colours',
/manifest\+json/.test(mres.headers.get('content-type') || '') && man.name === 'tracker' && man.short_name === 'tracker' && man.start_url === '/' && man.scope === '/'
&& man.display === 'standalone' && man.theme_color === 'rgb(15, 20, 25)' && man.background_color === 'rgb(25, 30, 35)', JSON.stringify(man));
const iconOk = [];
for (const ic of man.icons || []) {
const ir = await fetch(BASE + ic.src);
const b = Buffer.from(await ir.arrayBuffer());
iconOk.push(ir.ok && ic.type === 'image/png' && b.readUInt32BE(16) === Number(ic.sizes.split('x')[0]) && b.readUInt32BE(20) === Number(ic.sizes.split('x')[1]));
}
check('pwa: every manifest icon loads and is a real PNG of its declared size (192 + 512, any + maskable)',
iconOk.length === 4 && iconOk.every(Boolean) && ['any', 'maskable'].every(pu => ['192x192', '512x512'].every(sz => man.icons.some(i => i.purpose === pu && i.sizes === sz))), JSON.stringify(man.icons) + ' ' + JSON.stringify(iconOk));
const touch = await fetch(BASE + '/icons/apple-touch-icon.png');
const touchBytes = Buffer.from(await touch.arrayBuffer());
const fav = await fetch(BASE + '/icons/favicon.svg');
const favText = await fav.text();
const ico = await fetch(BASE + '/favicon.ico');
const icoBytes = Buffer.from(await ico.arrayBuffer());
check('pwa: apple-touch-icon is a 180×180 PNG, the favicon an SVG in tracker green, /favicon.ico a real icon file',
touch.ok && touchBytes.readUInt32BE(16) === 180 && fav.ok && /image\/svg\+xml/.test(fav.headers.get('content-type') || '') && favText.includes('#4ec9b0')
&& ico.ok && icoBytes.readUInt32BE(0) === 0x00000100, `${touch.status} ${fav.status} ${ico.status}`);
await page.goto('about:blank'); // the server goes down below: the main tab must not sit on a page meanwhile
const app = await browser.newPage();
const aev = (e) => app.evaluate(e);
const appHydrated = () => app.waitFor('!!window.__hl && window.__hl.socket && window.__hl.socket.readyState === 1', { timeout: 15000, label: 'app tab hydrated' });
await app.send('Emulation.setDeviceMetricsOverride', { width: 390, height: 844, deviceScaleFactor: 2, mobile: true });
await app.goto(BASE + '/');
await appHydrated();
await app.waitFor(`navigator.serviceWorker.getRegistration().then(r => !!(r && r.active))`, { timeout: 15000, label: 'service worker active' });
await app.waitFor(`!!navigator.serviceWorker.controller`, { timeout: 10000, label: 'page controlled by the worker' });
const inst = await app.send('Page.getInstallabilityErrors');
check('pwa: Chrome reports no installability error', (inst.installabilityErrors || []).length === 0, JSON.stringify(inst));
const am = await app.send('Page.getAppManifest');
check('pwa: Chrome parses the manifest without errors', am.url && am.url.endsWith('/__hl/manifest.webmanifest') && (am.errors || []).length === 0, JSON.stringify(am.errors));
check('pwa: hl:web\'s service worker is registered for the whole app (scope /) and controls the page',
(await aev(`navigator.serviceWorker.getRegistration().then(r => new URL(r.scope).pathname + ' ' + new URL(r.active.scriptURL).pathname)`)) === '/ /__hl/sw.js' && (await aev('!!navigator.serviceWorker.controller')));
check('pwa: online, no offline note', !(await aev(`!!document.querySelector('#offline')`)));
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, 'pwa-phone-online.png'), Buffer.from((await app.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
await app.setOffline(true);
await app.waitFor(`!!document.querySelector('#offline')`, { timeout: 5000, label: 'offline note (live)' }).catch(() => {});
check('offline: the open page says so within seconds (the shell\'s tick)', (await aev(`document.querySelector('#offline') ? document.querySelector('#offline').textContent : ''`)) === 'You are offline. Your shows and lists need the network.');
await stopServer();
let down = false;
try { await fetch(BASE + '/'); } catch { down = true; }
await app.goto(BASE + '/');
await app.waitFor(`!!document.querySelector('#offline')`, { timeout: 8000, label: 'offline note after reload' }).catch(() => {});
// the Shows row: 3 fixture series + Gate Import Show (#14's import, in the lists at once since the #13/#14 merge)
check('offline: with the server gone too, a reload of / still opens the shell from the worker\'s cache — header, brand, the note, the home (#13: its text and both rows — 5 shows since mission 054 added Flagless Gate Series)',
down && (await aev(`document.querySelector('application-header .brand') ? document.querySelector('application-header .brand').textContent : ''`)) === 'tracker'
&& (await aev(`!!document.querySelector('#offline')`)) && (await aev(`!!document.querySelector('home-intro') && document.querySelectorAll('#home-movies a.tile').length === 10 && document.querySelectorAll('#home-shows a.tile').length === 5`))
&& (await aev(`getComputedStyle(document.querySelector('application-header')).backgroundColor`)) === 'rgb(15, 20, 25)', 'server down: ' + down);
if (process.env.TRACKER_GATE_SHOTS) writeFileSync(join(process.env.TRACKER_GATE_SHOTS, 'pwa-phone-offline.png'), Buffer.from((await app.send('Page.captureScreenshot', { format: 'png' })).data, 'base64'));
await app.goto(BASE + '/my/shows');
check('offline: a data page (/my/shows) is not kept — hl:web\'s "Unavailable offline" page', (await aev(`!!document.querySelector('main[data-hl-offline]') && document.querySelector('h1').textContent`)) === 'Unavailable offline');
await app.setOffline(false);
await startServer();
await app.goto(BASE + '/');
await appHydrated();
await app.waitFor(`!document.querySelector('#offline')`, { timeout: 5000, label: 'note gone' }).catch(() => {});
check('back online: / from the server again, no offline note', !(await aev(`!!document.querySelector('#offline')`)));
await app.close();
await page.goto(BASE + '/my/schedule');
await hydrated();
// ---- sign out: back to signed out, a reload confirms the app's own session (not just client state) ----
await page.click('#logout');
await page.waitForSelector('#loginbutton', { timeout: 15000 });
check('sign out returns to the signed-out header', (await ev(`!!document.querySelector('#loginbutton')`)) && !(await ev(`!!document.querySelector('#logout')`)));
await page.goto(BASE + '/');
await hydrated();
check('reload after sign-out stays signed out', (await ev(`!!document.querySelector('#loginbutton')`)) && !(await ev(`!!document.querySelector('#logout')`)));
const problems = page.problems();
check('no console errors/warnings', problems.length === 0, page.dumpConsole());
}
try {
await main();
} catch (e) {
check('gate ran without throwing', false, (e.stack || String(e)) + (globalThis.__gatePage ? '\nbrowser console:\n' + globalThis.__gatePage.dumpConsole() : '') + '\nserver log (tail):\n' + log.slice(-2000));
} finally {
await stop();
}
console.log(`\n${passes} passed, ${failures} failed`);
process.exit(failures === 0 ? 0 : 1);

Branches

mainmain branch

Latest commits

1704ec45tracker#17 (mission 057): season caret down/up, skeleton rows while a season loads, sessionless showSeasonEpisodes face (no page re-mount), client-only close; gate 214, tests/realdata-057.mjs, README + STATUSmre2026-10-01 12:39
f2fe3e36mission 056: README + STATUS (merge, fixes, Hybriel 8590df63, real-data check), tests/realdata-056.mjs, tools/check-public-slugs.hlmre2026-10-01 11:10
f40c250emission 056: re-vendor hybriel master 8590df63 (#121, #122); an adult title's page is Not found for non-followers; gate: leave the page before stopping the servermre2026-10-01 09:46
2b7fdd6cmission 056: signed-out header one row on phones ("Log in", nowrap), backfill skips adult titles' posters, gate checksmre2026-10-01 09:34
2c53d5efMerge branch 't16-person' (tracker#16 person pages) into main; filmography shows only public titles (054 adult flag), gate race fix (backfill start line)mre2026-10-01 09:28
c171227emission 054: hide adult/unknown titles from the public lists and the search; in-app adult-flag backfill (TMDB details + poster per title, resumes), gate + real-data proofmre2026-10-01 09:23
139fafd8tracker#16: short bio (4 lines, click = all), real-data check script, README + STATUSmre2026-10-01 07:53
93be9476tracker#16: person pages /person/<slug> with the filmography fetched from TMDB on the first visit (step by step), gatemre2026-10-01 07:49
47a3cae6STATUS: mission 053 merge commit idsmre2026-10-01 07:27
dcc5eecaMerge branch 't14-search'mre2026-10-01 07:27
03edc783Merge branch 't15-tvmaze'mre2026-10-01 07:20
71b46345tracker#15: numbering check by date or title, placeholder titles in other languages, docs + real-data proofmre2026-10-01 07:18
6bb2daf1tracker#13: homepage (tiles, intro, latest movies/shows), /shows, /movies/page/N, /my/movies; lists cached in memorymre2026-10-01 07:14
b8bd1157tracker#14: README + STATUS (search, real-data numbers, gate, merge notes)mre2026-10-01 07:13
65c694a8tracker#14: search — header magnifier, /search/<text> (in-memory word-prefix index over titles + people), Fetch from web (TMDB search/multi, ours left out), Add = import via syncShow; gate +25 checks, real-data scriptmre2026-10-01 07:12
34f2c15btracker#15: TVmaze merge in the sync (gaps only: new episodes/seasons, empty titles/air dates; numbering check), fake TVmaze episodes + gatemre2026-10-01 07:03
cbdc4ea7tracker#12: link icons TMDB/IMDb/TVDB/TVmaze; sync fills missing ids (TVmaze lookup); movies fetched via /movie/mre2026-10-01 06:39
b105bcd8tracker#11: Hybriel master ff51cf46 (checks no longer vanish), mobile-first styles, carets, follow button, sign-in modal, inverted check, orange castmre2026-10-01 06:25
31b758aatracker#10: installable app (manifest, service worker, offline shell), own icon + faviconmre2026-10-01 00:22
2fa9d997tracker#9: TMDB sync (followed shows: seasons, episodes, posters), tools/sync-tmdb.hl + daily run 04:00 UTC, fake TMDB in gatemre2026-10-01 00:10