@bongos/core 1.23.18 → 1.23.20

package/tests/hub_community_page.mjs

@@ -1,11 +1,12 @@
 // tests/hub_community_page.mjs — the hub's community pages (task 1003363; ADR 0217 D1,
 // ADR 0337 D1/D3/D4.1, docs/specs/bongos-v1-community-tab.md D1/D3/D4/D8).
 //
-// One file served as four sub-pages of the bar's Community menu (owner, 2026-10-27):
-// /community the leaderboard, /community/week the builder of the week (task 1002981),
-// /community/find the builder search, /community/recruiters the name-only list of hidden
-// builders open to recruiters. They render existing platform-identity reads and add no
-// rule of their own. What this file pins:
+// One file served as five sub-pages of the bar's Community menu (owner, 2026-10-27):
+// /community the community home (task 1004902: the builders of the week, month and year,
+// and a door to each page), /community/leaderboard the leaderboard, /community/week the
+// builder of the week (task 1002981), /community/find the builder search,
+// /community/recruiters the name-only list of hidden builders open to recruiters. They
+// render existing platform-identity reads and add no rule of their own. What this file pins:
 //   • the markup: the hub's bar with the Community menu as the current section, no top
 //     block, noindex, dark only, the routes' own windows and query limits
 //   • viewing is ungated: the leaderboard and the search read the same routes for every
@@ -15,11 +16,13 @@
 //     dropdown and the crafts, the empty, failed and rate-limited board; the search and
 //     its refusals; the recruiter list as a door signed out, a refusal on a 403, and rows
 //     only from a 200 — name, face and login, never the ranked half's numbers; the builder
-//     of the week as one line on the board and as its own page, drawn as the server sent it
+//     of the week as one line on the board and as its own page, drawn as the server sent it;
+//     the home's three crowns, its empty and failed states, and its doors; the row under
+//     them (task 1002983), the rising builder and the projects on the move, from its own read
 //   • the Community menu on every page that wears the hub's bar (apex-only where the page
 //     also serves a child), folded into the Projects band on phones
-//   • the routes: the four paths served on the hub's apex only
-//   • the kit: the states files, and the stub answering as the four reads do
+//   • the routes: the five paths served on the hub's apex only
+//   • the kit: the states files, and the stub answering as the six reads do
 //
 // DB-free. Run:  node --test tests/hub_community_page.mjs
 
@@ -46,8 +49,10 @@ const STYLE = PAGE.split('<style>')[1].split('</style>')[0].replace(/\/\*[\s\S]*
 const MAIN = PAGE.split('<main class="acct" id="comm">')[1].split('</main>')[0];
 const BOARD_JS = fs.readFileSync(path.join(PI, 'community-leaderboard.js'), 'utf8');
 const SEARCH_JS = fs.readFileSync(path.join(PI, 'builder-search.js'), 'utf8');
-const SUBPAGES = [['/community', 'Leaderboard'], ['/community/week', 'Builder of the week'], ['/community/find', 'Find a builder'], ['/community/recruiters', 'Open to recruiters']];
+const SUBPAGES = [['/community', 'Community home'], ['/community/leaderboard', 'Leaderboard'], ['/community/week', 'Builder of the week'], ['/community/find', 'Find a builder'], ['/community/recruiters', 'Open to recruiters']];
 const WEEK_JS = fs.readFileSync(path.join(PI, 'builder-of-the-week.js'), 'utf8');
+const CROWNS_JS = fs.readFileSync(path.join(PI, 'community-crowns.js'), 'utf8');
+const MOVERS_JS = fs.readFileSync(path.join(PI, 'community-movers.js'), 'utf8');
 
 // ── 1. the markup ────────────────────────────────────────────────────────────
 
@@ -73,9 +78,9 @@ test('the bar and bands are /connections’ but for the sign-in return and the c
   assert.equal(bar(PAGE), bar(read('connections.html')));
 });
 
-test('no top block: one visually hidden h1, then one section per sub-page, only the leaderboard shown in the markup', () => {
+test('no top block: one visually hidden h1, then one section per sub-page, only the home shown in the markup', () => {
   assert.match(MAIN, /^\s*<h1 class="vh">Community<\/h1>\s*(<!--[\s\S]*?-->\s*)?<div class="mineExtra">/, 'nothing is drawn above the first section (the /design floor)');
-  const order = ['<section id="board" data-view="leaderboard" aria-labelledby="boardH">', '<section id="week" data-view="week" aria-labelledby="weekH" hidden>', '<section id="find" data-view="find" aria-labelledby="findH" hidden>', '<section id="recruit" data-view="recruiters" aria-labelledby="recruitH" hidden>'].map((s) => MAIN.indexOf(s));
+  const order = ['<section id="home" data-view="home" aria-labelledby="homeH">', '<section id="board" data-view="leaderboard" aria-labelledby="boardH" hidden>', '<section id="week" data-view="week" aria-labelledby="weekH" hidden>', '<section id="find" data-view="find" aria-labelledby="findH" hidden>', '<section id="recruit" data-view="recruiters" aria-labelledby="recruitH" hidden>'].map((s) => MAIN.indexOf(s));
   assert.ok(order.every((i) => i > 0), 'every sub-page is real markup the script only shows');
   assert.deepEqual([...order].sort((a, b) => a - b), order);
   assert.match(MAIN, /<ol class="commRows" id="boardList" data-unit="\{\{currency\}\}" aria-labelledby="boardH"><\/ol>/, 'the unit is the instance’s own word, stamped by the server');
@@ -100,10 +105,44 @@ test('the builder of the week states its rule in full, and the rule is the modul
   assert.match(WEEK_JS, /ORDER BY sum\(credits\) DESC, sum\(tasks_shipped\) DESC, sum\(karma\) DESC,/, 'the tie order the page states is the query’s');
   assert.match(rule, /Builders who hide their numbers or keep their account private are not counted\./);
   assert.match(WEEK_JS, /rollupVisibleSql\('pa'\)/);
-  assert.match(rule, /Each week is decided once, the first time anyone opens this page after it ends, and it does not change after that\./);
+  assert.match(rule, /Each week is decided once, the first time a community page asks for it after it ends, and it does not change after that\./);
   assert.match(WEEK_JS, /ON CONFLICT \(week_start\) DO NOTHING/);
 });
 
+test('the home states the month’s and year’s rule, and it is the module’s; its doors are the other pages (task 1004902)', () => {
+  const home = MAIN.split('<section id="home"')[1].split('</section>')[0];
+  const rule = home.split('<p class="commNote" id="homeRule">')[1].split('</p>')[0];
+  assert.match(rule, /the most \{\{currency\}\} across every project in that time, among the builders who shipped at least one work in it\./, 'the week’s formula, which the month and the year reuse');
+  assert.match(CROWNS_JS, /require\('\.\/builder-of-the-week'\)/);
+  assert.match(CROWNS_JS, /computeWinner\(start, end, pool, opts\)/, 'the month and the crowned year are the week’s statement');
+  assert.match(rule, /A tie goes to whoever shipped more works, then to whoever earned more karma\./);
+  assert.match(rule, /Builders who hide their numbers or keep their account private are not counted\./);
+  assert.match(CROWNS_JS, /rollupVisibleSql\('pa'\)/);
+  assert.match(rule, /The week and the month are decided once, when they end; the year shows the leader so far, and is decided on 1 January\./);
+  assert.match(CROWNS_JS, /ON CONFLICT \(period, period_start\) DO NOTHING/);
+  assert.match(CROWNS_JS, /computeWinner\(start, now, pool, \{ fromFirstSnapshot: true \}\)/, 'the year so far is live');
+  for (const id of ['homeFailed', 'homeCrowns', 'crownYearLast', 'homeMovers', 'moversRule', 'moveNone']) assert.match(home, new RegExp(` id="${id}"[^>]*hidden`), `${id} waits for the route’s answer`);
+  assert.ok(home.indexOf('id="homeMovers"') > home.indexOf('id="homeRule"') && home.indexOf('id="homeMovers"') < home.indexOf('id="doorsH"'), 'the row under the crowns and their rule, above the doors (owner decision 5, task 1004902)');
+  const doors = [...home.split('<ul class="homeDoors" aria-labelledby="doorsH">')[1].split('</ul>')[0].matchAll(/<li( class="knowCell" hidden)?><a class="btn ghost" href="([^"]+)">([^<]+)<\/a><\/li>/g)];
+  assert.deepEqual(doors.map((m) => [m[2], m[3], !!m[1]]), [
+    ['/community/leaderboard', 'Leaderboard', false], ['/community/week', 'Builder of the week', false], ['/community/find', 'Find a builder', false],
+    ['/community/recruiters', 'Open to recruiters', false], ['/connections#connSuggest', 'Builders you may know', true],
+  ], 'one door per page, the menu’s order; Builders you may know signed in only, like its menu item');
+});
+
+test('the movers’ rule is the module’s: the base cap, the shipped-work floor, the projects’ order and who is counted (task 1002983)', () => {
+  const rule = MAIN.split('<p class="commNote" id="moversRule" hidden>')[1].split('</p>')[0];
+  const cap = MOVERS_JS.match(/const RISING_BASE_MAX = (\d+);/)[1];
+  assert.match(rule, new RegExp(`the most \\{\\{currency\\}\\} in the last 30 days, among the builders who had earned under ${cap} \\{\\{currency\\}\\} before them and shipped at least one work in them\\.`));
+  assert.match(MOVERS_JS, /const WINDOW = '30d';/);
+  assert.match(MOVERS_JS, /s\.base < RISING_BASE_MAX && s\.tasks_shipped >= 1/, 'the cap and the floor the page states are the ones applied');
+  assert.match(rule, /Projects on the move are the public projects that shipped the most works in the last 30 days, then earned the most \{\{currency\}\}\./);
+  assert.match(MOVERS_JS, /\(b\.tasks_shipped - a\.tasks_shipped\) \|\| \(b\.credits - a\.credits\)/);
+  assert.match(MOVERS_JS, /onMapSql\('p'\)\} AND p\.visibility = 'public'/, '“public projects”: on the map with the Public door');
+  assert.match(rule, /Builders who hide their numbers or keep their account private are not counted in either\./);
+  assert.match(MOVERS_JS, /eligibleIdentities/);
+});
+
 test('the window dropdown and the query limits are the routes’ own (boundary-forced copies)', () => {
   const days = BOARD_JS.match(/const WINDOW_DAYS = Object\.freeze\(\{([^}]*)\}\);/);
   const windows = [...days[1].matchAll(/'?(\w+)'?:/g)].map((m) => m[1]);
@@ -121,12 +160,12 @@ test('the window dropdown and the query limits are the routes’ own (boundary-f
   assert.match(MAIN, new RegExp(`<input id="findQ" type="search"[^>]* maxlength="${max}"`));
 });
 
-test('the script builds no markup from strings, reads only the five routes, and never re-ranks or reads the ranked tier', () => {
+test('the script builds no markup from strings, reads only the seven routes, and never re-ranks or reads the ranked tier', () => {
   assert.doesNotMatch(SCRIPT, /innerHTML|insertAdjacentHTML|outerHTML|document\.write/);
-  // every path literal in the code: the API base, the five reads, the four sub-pages, the
+  // every path literal in the code: the API base, the seven reads, the five sub-pages, the
   // sign-in door and the hall's invite box the Recruit door opens (task 1002292)
   const paths = [...new Set([...CODE.matchAll(/'(\/[^'?]*)/g)].map((m) => m[1]))];
-  assert.deepEqual(paths.sort(), ['/api/bongos', '/api/bongos/auth/web/start', '/builders/watch', '/community', '/community/builder-of-the-week', '/community/find', '/community/leaderboard', '/community/recruiters', '/community/search', '/community/week', '/my-projects', '/scouting']);
+  assert.deepEqual(paths.sort(), ['/api/bongos', '/api/bongos/auth/web/start', '/builders/watch', '/community', '/community/builder-of-the-week', '/community/crowns', '/community/find', '/community/leaderboard', '/community/movers', '/community/recruiters', '/community/search', '/community/week', '/my-projects', '/scouting']);
   assert.doesNotMatch(CODE, /method:/, 'it only reads');
   assert.doesNotMatch(CODE, /'\/me\b/, 'who is signed in is the bar’s question');
   assert.doesNotMatch(CODE, /\.sort\(|\.count\b|_count\b/, 'the server ranks; every count is a list’s length');
@@ -172,7 +211,20 @@ const WEEK = () => ({ week: { start: '2026-10-19', end: '2026-10-26' },
   past: [{ week_start: '2026-10-12', handle: 'bo', github_login: 'bo', display_name: null, avatar_url: 'data:x', credits: 300, tasks_shipped: 2 },
     { week_start: '2026-09-28', handle: 'cy', github_login: 'cy', display_name: 'Cy', avatar_url: null, credits: 90, tasks_shipped: 1 },
     { week_start: '2025-12-29', handle: 'di', github_login: 'di', display_name: 'Di', avatar_url: null, credits: 10, tasks_shipped: 1 }] });
+const WINNER = (handle, credits, ships, extra = {}) => ({ handle, github_login: handle, display_name: handle.toUpperCase(), avatar_url: `https://avatars.example/${handle}`, credits, tasks_shipped: ships, ...extra });
+const CROWNS = () => ({
+  week: { start: '2026-10-26', end: '2026-11-02', winner: WINNER('ana', 1240, 4, { display_name: 'Ana <i>L</i>' }) },
+  month: { start: '2026-10-01', end: '2026-11-01', first_crown: null, winner: WINNER('bo', 6120, 1, { display_name: null, avatar_url: 'javascript:alert(1)' }) },
+  year: { start: '2026-01-01', since: '2026-09-27', last: null, winner: WINNER('cy', 9870, 31) },
+});
+const MOVERS = () => ({
+  window: { start: '2026-09-28T09:30:00.000Z', end: '2026-10-28T09:30:00.000Z' },
+  rising: WINNER('kofi', 640, 5, { display_name: 'Kofi <b>M</b>' }),
+  projects: [{ name: 'Tide <i>pool</i>', origin: 'https://tidepool.example', tasks_shipped: 23, credits: 1840 }, { name: 'Quill', origin: 'javascript:alert(1)', tasks_shipped: 1, credits: 45 }],
+});
 const READS = () => ({
+  '/community/crowns': { status: 200, body: CROWNS() },
+  '/community/movers': { status: 200, body: MOVERS() },
   '/community/builder-of-the-week': { status: 200, body: WEEK() },
   '/community/leaderboard?window=all': { status: 200, body: { window: 'all', count: 99, results: [ROW(26, 'ana', 1200), ROW(27, 'bo', 1500, { tasks_shipped: 1, karma: 0, avatar_url: 'javascript:alert(1)', display_name: null })] } },
   '/community/leaderboard?window=30d': { status: 200, body: { window: '30d', results: [ROW(1, 'cy', 40)] } },
@@ -182,7 +234,7 @@ const READS = () => ({
   '/scouting': { status: 403, body: { error: { code: 'forbidden' } } },
 });
 
-async function boot({ pathname = '/community', me = null, reads = READS() } = {}) {
+async function boot({ pathname = '/community/leaderboard', me = null, reads = READS() } = {}) {
   const ids = new Map();
   for (const m of PAGE.matchAll(/<(\w+)([^>]* id="([^"]+)"[^>]*)>/g)) {
     const attrs = attrsOf(m[2]);
@@ -224,17 +276,123 @@ async function boot({ pathname = '/community', me = null, reads = READS() } = {}
   return { ids, requests, document, gets: () => requests.map((r) => r.url), tab, craft, pick, submit, current, $: (id) => ids.get(id) };
 }
 
-test('each path shows its one section, marks its menu items current and names itself; any other shape is the leaderboard', async () => {
-  for (const [pathname, title, section] of [['/community', 'Leaderboard', 'board'], ['/community/', 'Leaderboard', 'board'], ['/community/week', 'Builder of the week', 'week'], ['/community/find', 'Find a builder', 'find'], ['/community/recruiters/', 'Open to recruiters', 'recruit']]) {
+test('each path shows its one section, marks its menu items current and names itself; any other shape is the home', async () => {
+  for (const [pathname, item, section] of [['/community', 'Community home', 'home'], ['/community/', 'Community home', 'home'], ['/community/everyone', 'Community home', 'home'], ['/community/leaderboard/', 'Leaderboard', 'board'], ['/community/week', 'Builder of the week', 'week'], ['/community/find', 'Find a builder', 'find'], ['/community/recruiters/', 'Open to recruiters', 'recruit']]) {
     const ui = await boot({ pathname });
-    assert.deepEqual(['board', 'week', 'find', 'recruit'].filter((s) => !ui.$(s).hidden), [section], `${pathname}: one section`);
-    const href = SUBPAGES.find(([, t]) => t === title)[0];
+    assert.deepEqual(['home', 'board', 'week', 'find', 'recruit'].filter((s) => !ui.$(s).hidden), [section], `${pathname}: one section`);
+    const href = SUBPAGES.find(([, t]) => t === item)[0];
     assert.deepEqual(ui.current(), [href, href], `${pathname}: its Community item and its folded twin in the Projects band`);
-    assert.equal(ui.document.title, `Cloud Bongos — Community · ${title}`);
+    assert.equal(ui.document.title, section === 'home' ? 'Cloud Bongos — Community' : `Cloud Bongos — Community · ${item}`, 'the home is the Community page itself');
     assert.equal(ui.$('signinTop').attrs.href, `/api/bongos/auth/web/start?return=${href}&repos=1`, 'signing in comes back to this sub-page');
   }
 });
 
+// ── 2c. the community home (task 1004902) ───────────────────────────────────────
+// community-crowns.js decides and records each period; the home draws what it sent, the
+// same for every viewer.
+
+test('the home: one read, the three crowns with their periods, names as text, and nothing asked about projects', async () => {
+  const ui = await boot({ pathname: '/community' });
+  assert.deepEqual(ui.gets(), ['/api/bongos/community/crowns', '/api/bongos/community/movers']);
+  assert.equal(ui.$('homeLoading').hidden, true);
+  assert.equal(ui.$('homeFailed').hidden, true);
+  assert.equal(ui.$('homeCrowns').hidden, false);
+  assert.equal(ui.$('crownWeekWhen').textContent, '26 Oct – 1 Nov 2026');
+  assert.equal(find(ui.$('crownWeek'), 'crownName').textContent, 'Ana <i>L</i>', 'a name is text, never markup');
+  assert.equal(find(ui.$('crownWeek'), 'crownNums').textContent, (1240).toLocaleString() + 'credits4works shipped');
+  assert.equal(ui.$('crownMonthWhen').textContent, 'October 2026');
+  assert.equal(find(ui.$('crownMonth'), 'crownName').textContent, 'bo', 'no display name: the handle stands in');
+  assert.equal(find(ui.$('crownMonth'), 'connAv').tag, 'span', 'an avatar that is not http(s) is never loaded');
+  assert.equal(find(ui.$('crownMonth'), 'crownNums').textContent, (6120).toLocaleString() + 'credits1work shipped', 'one work, singular');
+  assert.equal(ui.$('crownYearWhen').textContent, '2026 so far, since 27 Sep 2026', 'the year says when history began while that is inside it');
+  assert.equal(find(ui.$('crownYear'), 'mineRow__host').textContent, '@cy');
+  assert.equal(ui.$('crownYearLast').hidden, true, 'no year crowned yet');
+  const signedIn = await boot({ pathname: '/community', me: { github_login: 'owner' } });
+  assert.deepEqual(signedIn.gets(), ['/api/bongos/community/crowns', '/api/bongos/community/movers'], 'signed in, the same two reads: no Recruit door here');
+  assert.equal(signedIn.$('homeCrowns').textContent, ui.$('homeCrowns').textContent, 'the same crowns for every viewer');
+});
+
+test('the home: last year under the year so far, the first month’s date, and no one to show', async () => {
+  const reads = READS();
+  reads['/community/crowns'] = { status: 200, body: { ...CROWNS(),
+    year: { start: '2027-01-01', since: '2027-01-01', winner: WINNER('di', 310, 2), last: { start: '2026-01-01', winner: WINNER('cy', 11250, 38, { display_name: 'Cy <b>!</b>' }) } } } };
+  const next = await boot({ pathname: '/community', reads });
+  assert.equal(next.$('crownYearWhen').textContent, '2027 so far', 'history began before the year: no “since”');
+  assert.equal(next.$('crownYearLast').hidden, false);
+  assert.equal(next.$('crownYearLast').textContent, '2026: Cy <b>!</b>, ' + (11250).toLocaleString() + ' credits');
+  assert.equal(kids(next.$('crownYearLast'))[1].tag, 'strong');
+  reads['/community/crowns'] = { status: 200, body: {
+    week: { start: '2026-10-19', end: '2026-10-26', winner: null },
+    month: { start: '2026-09-01', end: '2026-10-01', first_crown: '2026-11-01', winner: null },
+    year: { start: '2026-01-01', since: '2026-09-27', winner: null, last: null } } };
+  const first = await boot({ pathname: '/community', reads });
+  const line = (id) => find(first.$(id), 'commMsg').textContent;
+  assert.equal(line('crownWeek'), 'No builder of the week for 19–25 Oct 2026.');
+  assert.equal(first.$('crownMonthWhen').textContent, 'September 2026');
+  assert.equal(line('crownMonth'), 'The first builder of the month is named on 1 Nov 2026.', 'a month before history is not “nobody”');
+  assert.equal(line('crownYear'), 'No builder of 2026 yet.');
+  assert.equal(find(first.$('homeCrowns'), 'crownName'), null);
+  reads['/community/crowns'] = { status: 200, body: { ...CROWNS(), month: { start: '2026-10-01', end: '2026-11-01', first_crown: null, winner: null } } };
+  assert.equal(find((await boot({ pathname: '/community', reads })).$('crownMonth'), 'commMsg').textContent, 'No builder of the month for October 2026.', 'a hidden winner and an empty month read the same (spec D8)');
+  reads['/community/crowns'] = { status: 200, body: { week: { start: 'soon' }, month: {}, year: { last: { start: 'x', winner: WINNER('ed', 1, 1) } } } };
+  const odd = await boot({ pathname: '/community', reads });
+  assert.deepEqual(['crownWeek', 'crownMonth', 'crownYear'].map((id) => find(odd.$(id), 'commMsg').textContent), ['No builder of the week yet.', 'No builder of the month yet.', 'No builder of the year yet.'], 'a date it cannot read is never drawn');
+  assert.equal(odd.$('crownYearLast').hidden, true);
+});
+
+test('the home: a failed read is an alert, never three empty crowns; a rate limit says to wait', async () => {
+  const reads = READS();
+  for (const answer of [{ status: 500, body: {} }, { reject: true }]) {
+    reads['/community/crowns'] = answer;
+    const failed = await boot({ pathname: '/community', reads });
+    assert.equal(failed.$('homeFailed').hidden, false);
+    assert.equal(failed.$('homeFailed').textContent, 'The top builders could not be read. Reload the page to try again.');
+    assert.equal(failed.$('homeCrowns').hidden, true);
+    assert.equal(failed.$('homeLoading').hidden, true);
+  }
+  reads['/community/crowns'] = { status: 429, body: {} };
+  assert.match((await boot({ pathname: '/community', reads })).$('homeFailed').textContent, /^Too many requests/);
+});
+
+test('the row under the crowns: the rising builder as a crown, the projects in the server’s order, names as text, a link only to a web address (task 1002983)', async () => {
+  const ui = await boot({ pathname: '/community' });
+  assert.equal(ui.$('homeMovers').hidden, false);
+  assert.equal(ui.$('moversRule').hidden, false);
+  assert.equal(find(ui.$('moveRising'), 'crownName').textContent, 'Kofi <b>M</b>', 'a name is text, never markup');
+  assert.equal(find(ui.$('moveRising'), 'crownNums').textContent, '640credits5works shipped');
+  const rows = kids(ui.$('moveProjects'));
+  assert.deepEqual(rows.map((r) => find(r, 'commPlace').textContent), ['1', '2'], 'positions in the order sent');
+  const first = find(rows[0], 'mineRow__name');
+  assert.equal(first.tag, 'a');
+  assert.equal(first.attrs.href, 'https://tidepool.example/');
+  assert.equal(first.textContent, 'Tide <i>pool</i>');
+  assert.equal(find(rows[0], 'mineRow__hint').textContent, (1840).toLocaleString() + ' credits earned');
+  assert.equal(find(rows[0], 'commCredits').textContent, '23works shipped');
+  assert.equal(find(rows[1], 'mineRow__name').tag, 'div', 'an address that is not http(s) is never a link');
+  assert.equal(find(rows[1], 'commCredits').textContent, '1work shipped', 'one work, singular');
+  assert.equal(ui.$('moveNone').hidden, true);
+  const signedIn = await boot({ pathname: '/community', me: { github_login: 'owner' } });
+  assert.equal(signedIn.$('homeMovers').textContent, ui.$('homeMovers').textContent, 'the same row for every viewer');
+});
+
+test('the row under the crowns: nobody to show is one line in each card; a failed read drops only the row', async () => {
+  const reads = READS();
+  reads['/community/movers'] = { status: 200, body: { window: {}, rising: null, projects: [] } };
+  const quiet = await boot({ pathname: '/community', reads });
+  assert.equal(quiet.$('homeMovers').hidden, false);
+  assert.equal(find(quiet.$('moveRising'), 'commMsg').textContent, 'No rising builder in the last 30 days.');
+  assert.equal(kids(quiet.$('moveProjects')).length, 0);
+  assert.equal(quiet.$('moveNone').hidden, false);
+  for (const answer of [{ status: 500, body: {} }, { status: 429, body: {} }, { reject: true }]) {
+    reads['/community/movers'] = answer;
+    const failed = await boot({ pathname: '/community', reads });
+    assert.equal(failed.$('homeMovers').hidden, true);
+    assert.equal(failed.$('moversRule').hidden, true, 'no rule for cards that are not there');
+    assert.equal(failed.$('homeCrowns').hidden, false, 'the crowns stand on their own');
+    assert.equal(failed.$('homeFailed').hidden, true, 'and no alert: the row is the home’s extra');
+  }
+});
+
 test('the leaderboard, signed out: the all-time board in the server’s order with the server’s places, and nothing asked about the viewer', async () => {
   const ui = await boot();
   assert.deepEqual(ui.gets(), ['/api/bongos/community/leaderboard?window=all', '/api/bongos/community/builder-of-the-week']);
@@ -535,7 +693,8 @@ const SERVES_A_CHILD = ['privacy.html', 'terms.html', 'contact.html', 'index.htm
 const HUB_ONLY = ['account.html', 'connections.html', 'invitations.html', 'guild.html', 'community.html'];
 const wrap = (apex, s) => (apex ? `<!--apex-only:start-->${s}<!--apex-only:end-->` : s);
 const ITEMS = [
-  ['/community', 'Leaderboard', 'who earned the most, across every project'],
+  ['/community', 'Community home', 'the builders of the week, month and year'],
+  ['/community/leaderboard', 'Leaderboard', 'who earned the most, across every project'],
   ['/community/week', 'Builder of the week', 'the top earner of each week, and how it is chosen'],
   ['/community/find', 'Find a builder', 'anyone building here, by name or role'],
   ['/community/recruiters', 'Open to recruiters', 'who is open to recruiting, for project owners'],
@@ -557,9 +716,9 @@ test('every page that wears the hub’s bar carries the Community menu before Pr
     const at = html.indexOf(apex ? `<!--apex-only:start-->${trig}` : trig);
     assert.ok(at > 0, `${f}: the Community trigger`);
     assert.ok(html.indexOf('id="projTrig"') > at, `${f}: Community comes before Projects`);
-    assert.ok(html.includes(wrap(apex, band)), `${f}: the Community band, its four sub-pages`);
+    assert.ok(html.includes(wrap(apex, band)), `${f}: the Community band, its five sub-pages`);
     assert.ok(html.indexOf('id="menuCommunity"') < html.indexOf('id="menuProjects"'), `${f}: the bands in the bar’s order`);
-    assert.ok(html.includes(wrap(apex, fold)), `${f}: the four folded into the Projects band for phones`);
+    assert.ok(html.includes(wrap(apex, fold)), `${f}: the five folded into the Projects band for phones`);
     if (apex) assert.doesNotMatch(stripApexOnly(html, false).split('<body>')[1], /\/community|commTrig|menuCommunity|connSuggest/, `${f}: a child has no community pages, so no trace of the menu`);
   }
 });
@@ -617,7 +776,7 @@ function get(pathname, host) {
   });
 }
 
-test('GET /community, /community/week, /community/find and /community/recruiters: one stamped page on the hub’s apex; never on a child or another host', async () => {
+test('GET /community, /community/leaderboard, /community/week, /community/find and /community/recruiters: one stamped page on the hub’s apex; never on a child or another host', async () => {
   modules.setModuleOverrides({ 'platform-identity': false });
   for (const [p] of SUBPAGES) assert.equal((await get(p, 'game.test.local')).status, 404, `${p}: a child instance has none of the routes these pages read`);
   modules.setModuleOverrides({ 'platform-identity': true });
@@ -630,7 +789,7 @@ test('GET /community, /community/week, /community/find and /community/recruiters
     bodies.push(hub.body);
   }
   assert.ok(bodies.every((b) => b === bodies[0]), 'byte-identical for every sub-page: the script picks the view');
-  assert.doesNotMatch((await get('/community/everyone', 'game.test.local')).body, /— Community<\/title>/, 'only the four sub-pages');
+  assert.doesNotMatch((await get('/community/everyone', 'game.test.local')).body, /— Community<\/title>/, 'only the five sub-pages');
   for (const host of ['builders.test.local', 'status.test.local']) {
     assert.doesNotMatch((await get('/community', host)).body, /— Community<\/title>/, `${host} must not serve /community`);
   }
@@ -643,10 +802,19 @@ test('the kit renders each sub-page for everyone, the empty board, and a project
   const states = json('community.states.json');
   assert.equal(states.page, '/community');
   assert.deepEqual(states.modes, ['dark']);
-  for (const s of ['out', 'out-30d', 'out-artists', 'out-week', 'in-week', 'out-find', 'out-find-search', 'out-recruiters', 'in-recruiters', 'in']) assert.ok(states.states[s], `kit state ${s}`);
+  for (const s of ['out', 'in', 'out-board', 'out-30d', 'out-artists', 'out-week', 'in-week', 'out-find', 'out-find-search', 'out-recruiters', 'in-recruiters', 'in-board']) assert.ok(states.states[s], `kit state ${s}`);
+  assert.equal(states.states.out.url, undefined, 'the home is /community itself');
+  for (const s of ['out-board', 'out-30d', 'out-artists', 'in-board']) assert.equal(states.states[s].url, '/community/leaderboard', `${s}: the board’s own address`);
   assert.equal(states.states['out-find'].url, '/community/find');
   assert.equal(states.states['out-week'].url, '/community/week');
-  assert.ok(states.states.out.expect.visible.includes('#boardCrown'), 'the board carries the crown line');
+  assert.ok(states.states['out-board'].expect.visible.includes('#boardCrown'), 'the board carries the crown line');
+  assert.ok(states.states.out.expect.visible.includes('#homeMovers'), 'the home carries the row under the crowns (task 1002983)');
+  assert.equal(json('community-movers-none.states.json').stub.fixtures['community-movers'], 'community-movers-none');
+  // the home's other answers (task 1004902): before the first month, nobody, and a new year
+  for (const [file, fixture] of [['community-crowns-first.states.json', 'community-crowns-first'], ['community-crowns-none.states.json', 'community-crowns-none'], ['community-crowns-new-year.states.json', 'community-crowns-new-year']]) {
+    assert.equal(json(file).stub.fixtures['community-crowns'], fixture);
+    assert.ok(fs.existsSync(path.join(ROOT, 'modules', 'ui-design', 'kit', 'fixtures', fixture + '.json')), `fixture ${fixture}`);
+  }
   assert.equal(states.states['in-recruiters'].url, '/community/recruiters');
   assert.ok(states.states['in-recruiters'].expect.visible.includes('#recruitClosed'), 'signed in but not admitted: told, shown no one');
   for (const [file, name, fixture] of [['community-empty.states.json', 'community-leaderboard', 'community-leaderboard-empty'], ['community-recruiter.states.json', 'scouting', 'scouting-recruiter'], ['community-owner.states.json', 'my-projects', 'my-projects-owner'], ['community-owner-two.states.json', 'my-projects', 'my-projects-owner-two'], ['community-week-none.states.json', 'community-week', 'community-week-none']]) {
@@ -685,9 +853,20 @@ async function call(origin, p) {
   return { status: res.status, body: await res.json() };
 }
 
-test('the kit stub answers the board, the builder of the week, the search and the recruiting door the way the routes do', async () => {
+test('the kit stub answers the crowns, the movers, the board, the builder of the week, the search and the recruiting door the way the routes do', async () => {
   const s = await stub();
   try {
+    const crowns = await call(s.origin, '/community/crowns');
+    assert.deepEqual(Object.keys(crowns.body), ['week', 'month', 'year'], 'the route’s three periods');
+    const { week: w, month: m, year: y } = crowns.body;
+    assert.deepEqual([Object.keys(w).sort(), Object.keys(m).sort(), Object.keys(y).sort()], [['end', 'start', 'winner'], ['end', 'first_crown', 'start', 'winner'], ['last', 'since', 'start', 'winner']], 'community-crowns.js’s shape');
+    assert.ok([w.winner, m.winner, y.winner].every((r) => r && Object.keys(r).sort().join() === 'avatar_url,credits,display_name,github_login,handle,tasks_shipped'), 'the module’s projection, no github_id');
+    const movers = await call(s.origin, '/community/movers');
+    assert.deepEqual(Object.keys(movers.body), ['window', 'rising', 'projects'], 'community-movers.js’s shape');
+    assert.equal(Object.keys(movers.body.rising).sort().join(), 'avatar_url,credits,display_name,github_login,handle,tasks_shipped', 'the crown’s projection, no github_id');
+    assert.ok(movers.body.projects.length && movers.body.projects.every((p) => Object.keys(p).sort().join() === 'credits,name,origin,tasks_shipped'), 'a project’s name, address and two numbers, no client_id');
+    const ships = movers.body.projects.map((p) => p.tasks_shipped);
+    assert.deepEqual(ships, [...ships].sort((a, b) => b - a), 'most works first');
     const week = await call(s.origin, '/community/builder-of-the-week');
     assert.deepEqual(Object.keys(week.body).sort(), ['past', 'week', 'winner'], 'the route’s three keys');
     assert.ok(week.body.winner && week.body.past.length, 'a crown and the weeks before it');
@@ -717,6 +896,11 @@ test('the kit stub answers the board, the builder of the week, the search and th
     assert.equal(r.body.winner, null);
     assert.deepEqual(r.body.past, []);
   } finally { none.stop(); }
+  const nobody = await stub({ FIXTURE_ALIAS: JSON.stringify({ 'community-crowns': 'community-crowns-none' }) });
+  try {
+    const r = await call(nobody.origin, '/community/crowns');
+    assert.deepEqual([r.body.week.winner, r.body.month.winner, r.body.year.winner, r.body.year.last], [null, null, null, null]);
+  } finally { nobody.stop(); }
   const owner = await stub({ AUTH: '1', FIXTURE_ALIAS: JSON.stringify({ scouting: 'scouting-recruiter' }) });
   try {
     const r = await call(owner.origin, '/scouting');

package/tests/landing_legal_pages.mjs

@@ -193,8 +193,8 @@ for (const p of PAGES) {
     assert.deepEqual(bandLinks(bandOf(html, 'menuProjects')), [
       ['Sky', '/projects?view=map'], ['Table', '/projects?view=map&sub=table'],
       ['Your projects', '/projects?view=mine'], ['New project', '/projects?view=new'],
-      // the Community menu's four sub-pages, folded into the band under 480px (tasks 1003363, 1002981); apex-only
-      ['Leaderboard', '/community'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
+      // the Community menu's five sub-pages, folded into the band under 480px (tasks 1003363, 1002981, 1004902); apex-only
+      ['Community home', '/community'], ['Leaderboard', '/community/leaderboard'], ['Builder of the week', '/community/week'], ['Find a builder', '/community/find'], ['Open to recruiters', '/community/recruiters'],
       ['Builders you may know', '/connections#connSuggest'],
     ], 'this page has no views of its own, so every item names /projects in full');
     assert.deepEqual(bandLinks(bandOf(stripApexOnly(html, false), 'menuProjects')).map((l) => l[0]), ['Sky', 'Table', 'Your projects', 'New project'], 'a child has no /community');

package/tests/privacy_matrix.mjs

@@ -154,7 +154,15 @@ function identitySentinels(acct) {
 //                the past weeks (task 1002981, spec D5): a row IS stats, so the board's rule.
 //                Every fixture account has won a recorded week, so the read's own predicate
 //                decides: 'listed' | 'absent'
-//   directory  GET /scouting                Recruiter — 'full' | 'name-only' | 'absent'
+//   crowns     GET /community/crowns        Anon · Builder · Recruiter — the builders of the month,
+//                the year so far and last year (task 1004902): a crown IS stats, so the board's
+//                rule. Each account in turn is made the winner of all three, so the reads'
+//                own predicates decide: 'listed' | 'absent'
+//   movers     GET /community/movers        Anon · Builder · Recruiter — the rising builder and the
+//                projects on the move (task 1002983): a card IS stats, so the board's rule, and
+//                a project's totals are the sum of what may be shown. Each account in turn is
+//                the one who moved, so the reads' own predicates decide: 'listed' | 'absent'
+//   directory  GET /scouting              Recruiter — 'full' | 'name-only' | 'absent'
 //   sliver     GET /scouting/:handle        Recruiter — 'full' (D3) | 'name-only' (D3, hidden) | 404
 //   self       GET /me/cross-project        Self — 'own' (own numbers, any flags) | 'n/a' (no session exists)
 //   guild      GET /guilds/:slug            Anon · Builder · Recruiter · Self — the guild page's PUBLIC
@@ -170,13 +178,13 @@ function identitySentinels(acct) {
 //                people the guild page already shows them — shown_publicly AND existence;
 //                hide_stats never hides membership, and private or provisional is never listed
 const MATRIX = {
-  PROV: { profile: 404, search: 'absent', board: 'absent', week: 'absent', directory: 'absent', sliver: 404, self: 'n/a', guild: 'absent', members: 'absent', invite: 'absent' },
-  PUB: { profile: 'full', search: 'listed', board: 'listed', week: 'listed', directory: 'full', sliver: 'full', self: 'own', guild: 'listed', members: 'listed', invite: 'listed' },
-  SHY: { profile: 'identity', search: 'name-only', board: 'absent', week: 'absent', directory: 'name-only', sliver: 'name-only', self: 'own', guild: 'listed', members: 'listed', invite: 'listed' },
-  PRIV: { profile: 404, search: 'absent', board: 'absent', week: 'absent', directory: 'absent', sliver: 404, self: 'own', guild: 'absent', members: 'listed', invite: 'absent' },
-  PRIVD: { profile: 404, search: 'absent', board: 'absent', week: 'absent', directory: 'absent', sliver: 'full', self: 'own', guild: 'absent', members: 'listed', invite: 'absent' },
-  PRIVDH: { profile: 404, search: 'absent', board: 'absent', week: 'absent', directory: 'absent', sliver: 'name-only', self: 'own', guild: 'absent', members: 'listed', invite: 'absent' },
-  OPTOUT: { profile: 'full', search: 'listed', board: 'listed', week: 'listed', directory: 'absent', sliver: 404, self: 'own', guild: 'listed', members: 'listed', invite: 'listed' },
+  PROV: { profile: 404, search: 'absent', board: 'absent', week: 'absent', crowns: 'absent', movers: 'absent', directory: 'absent', sliver: 404, self: 'n/a', guild: 'absent', members: 'absent', invite: 'absent' },
+  PUB: { profile: 'full', search: 'listed', board: 'listed', week: 'listed', crowns: 'listed', movers: 'listed', directory: 'full', sliver: 'full', self: 'own', guild: 'listed', members: 'listed', invite: 'listed' },
+  SHY: { profile: 'identity', search: 'name-only', board: 'absent', week: 'absent', crowns: 'absent', movers: 'absent', directory: 'name-only', sliver: 'name-only', self: 'own', guild: 'listed', members: 'listed', invite: 'listed' },
+  PRIV: { profile: 404, search: 'absent', board: 'absent', week: 'absent', crowns: 'absent', movers: 'absent', directory: 'absent', sliver: 404, self: 'own', guild: 'absent', members: 'listed', invite: 'absent' },
+  PRIVD: { profile: 404, search: 'absent', board: 'absent', week: 'absent', crowns: 'absent', movers: 'absent', directory: 'absent', sliver: 'full', self: 'own', guild: 'absent', members: 'listed', invite: 'absent' },
+  PRIVDH: { profile: 404, search: 'absent', board: 'absent', week: 'absent', crowns: 'absent', movers: 'absent', directory: 'absent', sliver: 'name-only', self: 'own', guild: 'absent', members: 'listed', invite: 'absent' },
+  OPTOUT: { profile: 'full', search: 'listed', board: 'listed', week: 'listed', crowns: 'listed', movers: 'listed', directory: 'absent', sliver: 404, self: 'own', guild: 'listed', members: 'listed', invite: 'listed' },
 };
 
 // ===========================================================================
@@ -296,6 +304,12 @@ function weekOf(key) {
   }
   return weeksWon[key];
 }
+// THE ACCOUNT that won the month, the year so far and last year (task 1004902); the
+// crowns test makes each fixture account the winner in turn.
+let CROWNED = 'PUB';
+// THE ACCOUNT that moved in the 30 days, on MX_CLIENT's project (task 1002983); the movers
+// test makes each fixture account the one in turn.
+let MOVED = 'PUB';
 
 const pool = {
   query: async (text, params = []) => {
@@ -370,6 +384,53 @@ const pool = {
       return { rows, rowCount: rows.length };
     }
 
+    // THE CROWNS (task 1004902): history began long ago, every month and year is already
+    // recorded, and CROWNED names the account that won all three — so each read's own
+    // predicate decides who is shown. The projections are pinned: a new column is a new
+    // disclosure.
+    if (/^SELECT reported_at FROM platform_identity_activity_snapshots ORDER BY id ASC LIMIT 1$/.test(sql)) return { rows: [{ reported_at: '2020-01-01T00:00:00.000Z' }], rowCount: 1 };
+    if (/^SELECT 1 FROM platform_identity_period_features WHERE /.test(sql)) return { rows: [{ '?column?': 1 }], rowCount: 1 };
+    if (/FROM platform_identity_period_features f JOIN platform_identity_accounts pa/.test(sql)) {
+      const cols = (/^SELECT (.+?) FROM /.exec(sql) || [, ''])[1];
+      if (cols !== 'f.credits_delta, f.ships_delta, pa.handle, pa.github_login, pa.display_name, pa.avatar_url') throw new Error(`fake pool: the crowned-period read selects something new — ${cols}`);
+      const where = lift(sql, /AND f\.period_start = \$2::date AND (.+)$/, 'crowned period');
+      const rows = ACCOUNTS.filter((a) => a.key === CROWNED).filter(accountFilter(where, [])).map((a) => ({
+        credits_delta: String(ROLLUP[a.github_id].credits), ships_delta: String(ROLLUP[a.github_id].works_shipped),
+        handle: a.handle, github_login: a.github_login, display_name: a.display_name, avatar_url: a.avatar_url,
+      }));
+      return { rows, rowCount: rows.length };
+    }
+    // THE MOVERS (task 1002983): the 30 days' rows carry the floor on the act CTE, as the
+    // year's; MOVED had nothing before them. The project names are MX_CLIENT's.
+    if (/^WITH act AS/.test(sql) && /LEFT JOIN per_project pp/.test(sql)) {
+      const where = lift(sql, /JOIN platform_identity_accounts pa ON pa\.github_id = a\.github_id WHERE (.+?) \), per_project AS/, 'movers');
+      const rows = ACCOUNTS.filter((a) => a.key === MOVED).filter(accountFilter(where, [])).map((a) => ({
+        client_id: MX_CLIENT.client_id, github_id: a.github_id, credits: String(ROLLUP[a.github_id].credits),
+        tasks_shipped: String(ROLLUP[a.github_id].works_shipped), karma: String(ROLLUP[a.github_id].karma), base_credits: '0',
+      }));
+      return { rows, rowCount: rows.length };
+    }
+    if (/FROM platform_identity_sso_clients c JOIN platform_identity_projects p ON p\.origin = c\.origin WHERE c\.client_id = ANY\(\$1::text\[\]\)/.test(sql)) {
+      const rows = (params[0] || []).includes(MX_CLIENT.client_id) ? [{ client_id: MX_CLIENT.client_id, name: MX_CLIENT.name, origin: MX_CLIENT.origin }] : [];
+      return { rows, rowCount: rows.length };
+    }
+    // ... the year so far: computeWinner's act CTE carries the floor, then the leader's re-read
+    if (/^WITH act AS/.test(sql) && /\) f ON true/.test(sql)) {
+      const where = lift(sql, /JOIN platform_identity_accounts pa ON pa\.github_id = a\.github_id WHERE (.+?) \), per_project AS/, 'year so far');
+      const rows = ACCOUNTS.filter((a) => a.key === CROWNED).filter(accountFilter(where, [])).map((a) => ({
+        github_id: a.github_id, credits: String(ROLLUP[a.github_id].credits), tasks_shipped: String(ROLLUP[a.github_id].works_shipped),
+      }));
+      return { rows, rowCount: rows.length };
+    }
+    if (/FROM platform_identity_accounts pa WHERE pa\.github_id = \$1::bigint AND /.test(sql)) {
+      const cols = (/^SELECT (.+?) FROM /.exec(sql) || [, ''])[1];
+      if (cols !== 'pa.handle, pa.github_login, pa.display_name, pa.avatar_url') throw new Error(`fake pool: the year leader read selects something new — ${cols}`);
+      const where = lift(sql, /WHERE pa\.github_id = \$1::bigint AND (.+)$/, 'year leader');
+      const rows = ACCOUNTS.filter((a) => a.github_id === String(params[0])).filter(accountFilter(where, []))
+        .map((a) => ({ handle: a.handle, github_login: a.github_login, display_name: a.display_name, avatar_url: a.avatar_url }));
+      return { rows, rowCount: rows.length };
+    }
+
     // THE LEADERBOARD's totals: the rollup floor sits on the act CTE's join.
     if (/platform_identity_activity_snapshots/.test(sql)) {
       const where = lift(sql, /JOIN platform_identity_accounts pa ON pa\.github_id = a\.github_id WHERE (.+?) \), per_project AS/, 'leaderboard totals');
@@ -809,6 +870,43 @@ test('the builder of the week — only shown, public, active winners, on the cro
   assert.doesNotMatch(seen[0].text, /github_id/, 'github_id never crosses');
 });
 
+test('the crowns — the month, the year so far and last year only for shown, public, active winners, the same for every viewer', async () => {
+  const { clearCrownsMemo } = require('../modules/platform-identity/community-crowns.js');
+  try {
+    for (const k of KEYS) {
+      CROWNED = k;
+      clearCrownsMemo(); // the year's leader is memoised: a new winner is a new computation
+      const seen = [];
+      for (const who of [ANON, STRANGER, RECRUITER]) seen.push(await get(who, '/api/bongos/community/crowns'));
+      for (const r of seen.slice(1)) assert.equal(r.text, seen[0].text, `${r.who} got different crowns with ${k} crowned`);
+      const { month, year } = seen[0].json;
+      const shown = { month: month.winner, year: year.winner, last: year.last && year.last.winner };
+      for (const [which, w] of Object.entries(shown)) {
+        assert.equal(!!w && w.handle === ACCT[k].handle, MATRIX[k].crowns === 'listed', `${k} as ${which}: expected ${MATRIX[k].crowns}`);
+      }
+      assert.doesNotMatch(seen[0].text, /github_id/, 'github_id never crosses');
+    }
+  } finally { CROWNED = 'PUB'; }
+});
+
+test('the movers — the rising builder and a project’s totals only from shown, public, active accounts, the same for every viewer', async () => {
+  const { clearMoversMemo } = require('../modules/platform-identity/community-movers.js');
+  try {
+    for (const k of KEYS) {
+      MOVED = k;
+      clearMoversMemo(); // the 30 days are memoised: a new mover is a new computation
+      const seen = [];
+      for (const who of [ANON, STRANGER, RECRUITER]) seen.push(await get(who, '/api/bongos/community/movers'));
+      for (const r of seen.slice(1)) assert.equal(r.text, seen[0].text, `${r.who} got different movers with ${k} moving`);
+      const { rising, projects } = seen[0].json;
+      const listed = MATRIX[k].movers === 'listed';
+      assert.equal(!!rising && rising.handle === ACCT[k].handle, listed, `${k} as the rising builder: expected ${MATRIX[k].movers}`);
+      assert.deepEqual(projects.map((p) => p.tasks_shipped), listed ? [ROLLUP[ACCT[k].github_id].works_shipped] : [], `${k}'s works in a project's totals: expected ${MATRIX[k].movers}`);
+      assert.doesNotMatch(seen[0].text, /github_id|client_id/, 'github_id and client_id never cross');
+    }
+  } finally { MOVED = 'PUB'; }
+});
+
 test('the recruiting directory — the recruiter sees the full and name-only tiers; Anon and Builder are refused', async () => {
   const r = await get(RECRUITER, '/api/bongos/scouting');
   assert.equal(r.status, 200);
@@ -851,7 +949,7 @@ function disclosed(r) {
 }
 
 test('the walk covered every surface for every row (so the claims below are about something)', () => {
-  for (const p of ['/profiles/', '/me/cross-project', '/community/search', '/community/leaderboard', '/community/builder-of-the-week', '/scouting', '/guilds/mx-guild', '/guilds/mx-guild/members', '/projects/invite-guild']) {
+  for (const p of ['/profiles/', '/me/cross-project', '/community/search', '/community/leaderboard', '/community/builder-of-the-week', '/community/crowns', '/community/movers', '/scouting', '/guilds/mx-guild', '/guilds/mx-guild/members', '/projects/invite-guild']) {
     assert.ok(SEEN.some((r) => r.path.includes(p) && r.status === 200), `no 200 from ${p} — the sweep below would be vacuous for it`);
   }
   assert.ok(SEEN.length >= KEYS.length * 6, `only ${SEEN.length} responses recorded`);