@bongos/core 1.21.62 → 1.21.64

package/tests/hub_guild_cards.mjs

@@ -0,0 +1,392 @@
+// tests/hub_guild_cards.mjs — a guild's invite to you and a join request to a guild
+// you own, in /projects?view=mine's Invitations, EXECUTED (task 1004583; ADR 0336
+// D3/D4 §3, ADR 0337 D4.4).
+//
+// R24 (task 1002300) shipped the routes — GET /me/guild-requests, POST
+// /guild-requests/:id/accept|decline, GET /guilds/:slug/requests — and nothing in
+// any UI called them. These cards do. What this pins:
+//   • an invite card tells the member, BEFORE they accept, that their numbers count
+//     toward the guild's rounded totals, in guild.html's own words (the two pages
+//     are held to one sentence here), and offers the counted switch right there;
+//     picking "Leave them out" repaints the notice and sends nothing
+//   • it says what joining shows (a public guild lists you; an unlisted one has no
+//     page) and links a public guild's page only
+//   • Accept sends exactly { visibility (the card's), counted_in_totals } on the
+//     cookie session; a 409 guild_visibility_changed re-draws the card for the
+//     guild as it is now, and the next accept sends that
+//   • an ended invite or request leaves nothing pressable; an expired session and a
+//     dead network are said as such, and the card stays re-tryable
+//   • Decline is a body-less POST whose 204 drops the row (the section hides with
+//     its last row); a failure keeps the row and says so
+//   • the owner's card names who asked, with the handle once, and accepts with no
+//     body — the requester's switch rode their request
+//   • ONE read feeds both lists — GET /me/guild-requests's incoming and
+//     owner_incoming — never one request per guild you own; a failed read is silent
+//   • a row the page cannot answer is dropped, never drawn with a button that fails
+//   • textContent / createElement only
+//
+// The idiom is tests/hub_engagement_cards.mjs: lift the region out of
+// projects.html, run it in a node:vm under a DOM stub, drive real clicks, and
+// assert the slice boundaries so a rename can never leave this executing nothing.
+//
+// DB-free. Run:  node --test tests/hub_guild_cards.mjs
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const GUILD_PAGE = fs.readFileSync(path.join(LANDING, 'guild.html'), 'utf8').replace(/\r\n/g, '\n');
+const SCRIPT = (HUB.match(/<script>([\s\S]*?)<\/script>\s*<\/body>/) || [, ''])[1];
+
+// the rows region, mineEl through the guild cards' loaders
+const START = SCRIPT.indexOf('  function mineEl(tag, cls)');
+const END = SCRIPT.indexOf('\n  }\n', SCRIPT.indexOf('  function loadGuildQueue() {')) + 5;
+assert.ok(START > 0, 'the region starts at mineEl');
+assert.ok(END > START, 'and ends with loadGuildQueue');
+const REGION = SCRIPT.slice(START, END);
+for (const fn of ['function paintInvitesSection(', 'function sessionExpired(', 'function guildPost(', 'function guildDecline(',
+  'function guildInviteRow(', 'function renderGuildInvites(', 'function guildRequestRow(', 'function renderGuildRequests(',
+  'function loadGuildQueue(']) {
+  assert.ok(REGION.includes(fn), `the region must carry ${fn}`);
+}
+const CARDS = REGION.slice(REGION.indexOf('var GUILD_COUNTED_ON'));
+assert.ok(CARDS.length > 1000, 'the guild cards are findable');
+
+// ── the DOM stub ─────────────────────────────────────────────────────────────
+function el(tag) {
+  const n = { tag, children: [], _text: '', className: '', hidden: false, disabled: false, checked: false, value: '', attrs: {}, _on: {}, parent: null };
+  Object.defineProperty(n, 'textContent', {
+    get() { return n._text + n.children.map((c) => c.textContent).join(''); },
+    set(v) { n._text = String(v); n.children = []; },
+  });
+  n.appendChild = (c) => { c.parent = n; n.children.push(c); return c; };
+  n.remove = () => { if (n.parent) n.parent.children = n.parent.children.filter((c) => c !== n); };
+  n.setAttribute = (k, v) => { n.attrs[k] = String(v); };
+  n.getAttribute = (k) => (k in n.attrs ? n.attrs[k] : null);
+  n.addEventListener = (t, f) => { (n._on[t] ||= []).push(f); };
+  n.querySelector = (sel) => {
+    const cls = sel.replace(/^\./, '');
+    const walk = (x) => { for (const c of x.children) { if (String(c.className).split(' ').includes(cls)) return c; const d = walk(c); if (d) return d; } return null; };
+    return walk(n);
+  };
+  return n;
+}
+const all = (n, pred, out = []) => { for (const c of n.children || []) { if (pred(c)) out.push(c); all(c, pred, out); } return out; };
+
+const OPEN_HANDS = { id: '501', created_at: '2026-10-04T15:10:00.000Z', seen_at: null, slug: 'open-hands', name: 'Open Hands', description: 'A newer guild for first-time builders.', visibility: 'public' };
+const QUIET_ROOM = { id: '502', created_at: '2026-10-03T08:45:00.000Z', seen_at: null, slug: 'quiet-room', name: 'Quiet Room', description: '', visibility: 'unlisted' };
+const TOMAS = { id: '601', created_at: '2026-10-04T19:20:00.000Z', seen_at: null, handle: 'tomas-ek', display_name: 'Tomás Ek', avatar_url: null, guild: { slug: 'night-shift', name: 'Night Shift' } };
+const KAI = { id: '602', created_at: '2026-10-02T11:05:00.000Z', seen_at: null, handle: 'kai-lowe', display_name: null, avatar_url: null, guild: { slug: 'night-shift', name: 'Night Shift' } };
+const OK = { ok: true, status: 200, body: { status: 'accepted' } };
+const GONE = { ok: false, status: 204, body: undefined };
+
+function boot({ answers = [] } = {}) {
+  const ids = new Map();
+  for (const id of ['mineInvites', 'invitesList', 'guildInviteList', 'engageList', 'guildRequestList']) ids.set(id, el(id === 'mineInvites' ? 'section' : 'ul'));
+  ids.get('mineInvites').hidden = true;
+  const requests = [];
+  const queued = answers.slice();
+  const fetch = (url, init = {}) => {
+    requests.push({ url, method: init.method || 'GET', body: init.body, headers: init.headers, credentials: init.credentials });
+    const a = typeof queued[0] === 'function' ? queued.shift()(url) : (queued.shift() || OK);
+    if (a.reject) return Promise.reject(new Error('offline'));
+    const status = a === GONE ? 204 : a.status;
+    return Promise.resolve({ ok: status >= 200 && status < 300, status, json: () => (a.body === undefined ? Promise.reject(new SyntaxError('no body')) : Promise.resolve(a.body)) });
+  };
+  const document = { createElement: el, createTextNode: (t) => ({ tag: '#text', textContent: String(t), children: [], className: '' }) };
+  const sandbox = {
+    document, fetch, console, Promise, JSON, String, Object, Array, URL,
+    $: (id) => ids.get(id) || null,
+    API: '/api/bongos',
+    hostOf: (o) => String(o || '').replace(/^https?:\/\//, '').replace(/^www\./, '').replace(/\/.*$/, '').toLowerCase(),
+    safeHttpUrl: (raw) => { try { const u = new URL(String(raw)); return (u.protocol === 'https:' || u.protocol === 'http:') ? u.href : ''; } catch (e) { return ''; } },
+    jsonOrEmpty: (res) => res.json().catch(() => ({})),
+    apiError: (data, status) => { const e = (data && data.error) || {}; return { code: e.code || ('http_' + status), message: e.message || '', details: e.details || e || {} }; },
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(REGION, sandbox, { filename: 'projects.html#mine-rows' });
+  const settle = async () => { for (let i = 0; i < 40; i++) await Promise.resolve(); };
+  const invites = () => ids.get('guildInviteList').children;
+  const asks = () => ids.get('guildRequestList').children;
+  const part = (card, cls) => card.querySelector('.' + cls);
+  const actions = (card) => part(card, 'mineRow__actions').children;
+  const button = (card, label) => actions(card).find((b) => b.tag === 'button' && b.textContent === label);
+  const radios = (card) => all(card, (n) => n.tag === 'input' && n.type === 'radio');
+  const msg = (card) => part(card, 'projMsg');
+  const click = async (b) => { for (const f of b._on.click || []) f({}); await settle(); };
+  const pick = async (card, value) => {
+    for (const r of radios(card)) r.checked = r.value === value;
+    for (const f of radios(card).find((r) => r.value === value)._on.change || []) f({});
+    await settle();
+  };
+  return { sandbox, ids, requests, settle, invites, asks, part, actions, button, radios, msg, click, pick, section: () => ids.get('mineInvites') };
+}
+
+// ── the D4.4 notice: one sentence on two pages ───────────────────────────────
+
+test('the notice is guild.html’s own words, both ways, byte for byte', () => {
+  const said = (src, re) => { const m = src.match(re); assert.ok(m, `found ${re}`); return vm.runInNewContext(m[1]); };
+  const onGuild = said(GUILD_PAGE, /\? 'Your numbers are left out[^']*'\s*:\s*('Your numbers count[\s\S]*?share them with\.');/);
+  const offGuild = said(GUILD_PAGE, /picked\('counted'\) === 'off'\s*\?\s*('[^']*')/);
+  const onHub = said(HUB, /var GUILD_COUNTED_ON = ('[\s\S]*?share them with\.');/);
+  const offHub = said(HUB, /var GUILD_COUNTED_OFF = ('[^']*');/);
+  assert.equal(onHub, onGuild);
+  assert.equal(offHub, offGuild);
+  assert.match(onHub, /count toward this guild’s rounded totals/, 'ADR 0337 D4.4’s words');
+  // the switch's own labels are the guild page's too
+  for (const words of ['Count my numbers', 'They add to this guild’s totals.', 'Leave them out', 'The totals add up everyone else.', 'In this guild’s totals']) {
+    assert.ok(GUILD_PAGE.includes(words) && CARDS.includes(words), `"${words}" on both pages`);
+  }
+});
+
+// ── the invite card ──────────────────────────────────────────────────────────
+
+test('an invite card says what joining shows, offers the switch set to count, and the notice BEFORE any accept', () => {
+  const ui = boot();
+  ui.sandbox.renderGuildInvites([OPEN_HANDS, QUIET_ROOM]);
+  assert.equal(ui.requests.length, 0, 'drawing sends nothing');
+  assert.equal(ui.section().hidden, false);
+  const [open, quiet] = ui.invites();
+  assert.equal(ui.part(open, 'mineRow__name').textContent, 'You’re invited to join Open Hands');
+  assert.equal(ui.part(open, 'guildRow__desc').textContent, 'A newer guild for first-time builders.');
+  assert.equal(ui.part(quiet, 'guildRow__desc'), null, 'an empty description draws nothing');
+  assert.match(ui.part(open, 'mineRow__hint').textContent, /^It’s public: joining lists your name and picture on its page/);
+  assert.match(ui.part(quiet, 'mineRow__hint').textContent, /^It’s unlisted: it has no public page/);
+  const link = ui.actions(open).find((a) => a.tag === 'a');
+  assert.equal(link.href, '/g/open-hands');
+  assert.equal(link.hidden, false);
+  assert.equal(ui.actions(quiet).find((a) => a.tag === 'a').hidden, true, 'an unlisted guild has no page to show an invitee');
+  for (const card of [open, quiet]) {
+    const r = ui.radios(card);
+    assert.deepEqual(r.map((x) => [x.value, x.checked]), [['on', true], ['off', false]], 'counted by default, as the membership is');
+    assert.equal(new Set(r.map((x) => x.name)).size, 1, 'one group per card');
+    const group = ui.part(card, 'guildCount__opts');
+    assert.equal(group.getAttribute('role'), 'radiogroup');
+    assert.equal(group.getAttribute('aria-labelledby'), ui.part(card, 'guildCount__label').id);
+    assert.match(ui.part(card, 'guildCount__what').textContent, /^Your numbers count toward this guild’s rounded totals/);
+    assert.deepEqual(ui.actions(card).filter((b) => b.tag === 'button').map((b) => b.textContent), ['Accept', 'Decline']);
+  }
+  assert.notEqual(ui.radios(open)[0].name, ui.radios(quiet)[0].name, 'two cards never share a group');
+});
+
+test('picking Leave them out says what that means before anything is sent; Count brings the notice back', async () => {
+  const ui = boot();
+  ui.sandbox.renderGuildInvites([OPEN_HANDS]);
+  const card = ui.invites()[0];
+  await ui.pick(card, 'off');
+  assert.equal(ui.part(card, 'guildCount__what').textContent, 'Your numbers are left out of this guild’s totals, from its next weekly count.');
+  await ui.pick(card, 'on');
+  assert.match(ui.part(card, 'guildCount__what').textContent, /^Your numbers count toward/);
+  assert.equal(ui.requests.length, 0);
+});
+
+test('Accept sends exactly the card’s visibility and the switch, on the cookie session', async () => {
+  const ui = boot();
+  ui.sandbox.renderGuildInvites([OPEN_HANDS, QUIET_ROOM]);
+  const [open, quiet] = ui.invites();
+  await ui.click(ui.button(open, 'Accept'));
+  await ui.pick(quiet, 'off');
+  await ui.click(ui.button(quiet, 'Accept'));
+  assert.equal(ui.requests.length, 2);
+  const [a, b] = ui.requests;
+  assert.equal(a.url, '/api/bongos/guild-requests/501/accept');
+  assert.equal(a.method, 'POST');
+  assert.equal(a.credentials, 'same-origin');
+  assert.equal(a.headers['Content-Type'], 'application/json');
+  assert.deepEqual(JSON.parse(a.body), { visibility: 'public', counted_in_totals: true });
+  assert.equal(b.url, '/api/bongos/guild-requests/502/accept');
+  assert.deepEqual(JSON.parse(b.body), { visibility: 'unlisted', counted_in_totals: false });
+});
+
+test('accepted: Joined and no longer the accent, nothing left to press, and the line says where your numbers went', async () => {
+  const ui = boot();
+  ui.sandbox.renderGuildInvites([QUIET_ROOM]);
+  const card = ui.invites()[0];
+  await ui.pick(card, 'off');
+  await ui.click(ui.button(card, 'Accept'));
+  const joined = ui.button(card, 'Joined');
+  assert.ok(joined, 'the button says so');
+  assert.equal(joined.disabled, true);
+  assert.equal(joined.className, 'btn small ghost');
+  assert.equal(ui.button(card, 'Decline').hidden, true);
+  assert.ok(ui.radios(card).every((r) => r.disabled), 'the switch is set; it moves on the guild page now');
+  assert.equal(ui.actions(card).find((a) => a.tag === 'a').hidden, false, 'a member reaches even an unlisted guild’s page');
+  assert.equal(ui.msg(card).className, 'projMsg ok');
+  assert.equal(ui.msg(card).textContent, 'You’ve joined Quiet Room, and your numbers are left out of its totals.');
+});
+
+test('409 guild_visibility_changed: the card re-draws for the guild as it is now, and the next accept sends that', async () => {
+  const ui = boot({ answers: [
+    { ok: false, status: 409, body: { error: { code: 'guild_visibility_changed', message: 'guild_visibility_changed', details: { visibility: 'public' } } } },
+    OK,
+  ] });
+  ui.sandbox.renderGuildInvites([QUIET_ROOM]);
+  const card = ui.invites()[0];
+  await ui.click(ui.button(card, 'Accept'));
+  assert.match(ui.part(card, 'mineRow__hint').textContent, /^It’s public:/, 'the card now says what joining shows');
+  assert.equal(ui.actions(card).find((a) => a.tag === 'a').hidden, false);
+  assert.equal(ui.msg(card).textContent, 'This guild changed since the card was drawn: it’s public now. Read it again, then accept.');
+  assert.equal(ui.button(card, 'Accept').disabled, false, 'a fresh decision, not a dead end');
+  await ui.click(ui.button(card, 'Accept'));
+  assert.deepEqual(JSON.parse(ui.requests[1].body), { visibility: 'public', counted_in_totals: true });
+  assert.ok(ui.button(card, 'Joined'));
+});
+
+test('an ended invite leaves nothing pressable; an expired session offers a way back; a dead network is said, and both stay re-tryable', async () => {
+  const gone = boot({ answers: [{ ok: false, status: 404, body: { error: { code: 'guild_request_not_found' } } }] });
+  gone.sandbox.renderGuildInvites([OPEN_HANDS]);
+  let card = gone.invites()[0];
+  await gone.click(gone.button(card, 'Accept'));
+  assert.ok(gone.actions(card).filter((b) => b.tag === 'button').every((b) => b.hidden));
+  assert.ok(gone.radios(card).every((r) => r.disabled));
+  assert.equal(gone.msg(card).textContent, 'That invite has ended — it was withdrawn, or it ran out.');
+
+  const out = boot({ answers: [{ ok: false, status: 401, body: { error: { code: 'unauthenticated' } } }, { reject: true }] });
+  out.sandbox.renderGuildInvites([OPEN_HANDS]);
+  card = out.invites()[0];
+  await out.click(out.button(card, 'Accept'));
+  const a = out.msg(card).children.find((c) => c.tag === 'a');
+  assert.ok(a, 'a sign-in link, built as an element');
+  assert.equal(a.href, '/api/bongos/auth/web/start?return=/projects%3Fview%3Dmine&repos=1');
+  assert.equal(out.button(card, 'Accept').disabled, false);
+  await out.click(out.button(card, 'Accept'));
+  assert.equal(out.msg(card).textContent, 'Couldn’t reach the platform — check your connection and try again.');
+  assert.equal(out.button(card, 'Accept').disabled, false);
+  assert.equal(out.button(card, 'Decline').disabled, false);
+});
+
+test('Decline is a body-less POST whose 204 drops the row, and the last one hides the section; a failure keeps it', async () => {
+  const ui = boot({ answers: [GONE, { ok: false, status: 500, body: {} }] });
+  ui.sandbox.renderGuildInvites([OPEN_HANDS]);
+  ui.sandbox.renderGuildRequests([TOMAS]);
+  await ui.click(ui.button(ui.invites()[0], 'Decline'));
+  assert.equal(ui.requests[0].url, '/api/bongos/guild-requests/501/decline');
+  assert.equal(ui.requests[0].method, 'POST');
+  assert.equal(ui.requests[0].body, undefined, 'nothing to send');
+  assert.equal(ui.invites().length, 0);
+  assert.equal(ui.section().hidden, false, 'the owner’s card still stands');
+  const ask = ui.asks()[0];
+  await ui.click(ui.button(ask, 'Decline'));
+  assert.equal(ui.asks().length, 1, 'kept on a failure');
+  assert.equal(ui.msg(ask).textContent, 'Couldn’t decline just now — try again in a moment.');
+  assert.equal(ui.button(ask, 'Decline').disabled, false);
+  ui.sandbox.renderGuildRequests([]);
+  assert.equal(ui.section().hidden, true, 'no row in any list hides the section');
+});
+
+// ── the owner's card ─────────────────────────────────────────────────────────
+
+test('a join request names who asked, with the handle once, and accepts with no body', async () => {
+  const ui = boot();
+  ui.sandbox.renderGuildRequests([TOMAS, KAI]);
+  const [tomas, kai] = ui.asks();
+  assert.equal(ui.part(tomas, 'mineRow__name').textContent, 'Tomás Ek asked to join Night Shift');
+  assert.equal(ui.part(tomas, 'mineRow__host').textContent, '@tomas-ek');
+  assert.equal(ui.part(kai, 'mineRow__name').textContent, '@kai-lowe asked to join Night Shift');
+  assert.equal(ui.part(kai, 'mineRow__host'), null, 'never the handle twice');
+  assert.equal(ui.part(tomas, 'guildCount'), null, 'the requester’s switch rode their request: none here');
+  assert.equal(ui.part(tomas, 'mineRow__hint').textContent, 'Accepting makes them a member. A decline is never told to them.');
+  await ui.click(ui.button(tomas, 'Accept'));
+  assert.equal(ui.requests[0].url, '/api/bongos/guild-requests/601/accept');
+  assert.equal(ui.requests[0].body, undefined, 'an owner cannot set the requester’s switch');
+  assert.equal(ui.requests[0].credentials, 'same-origin');
+  assert.equal(ui.button(tomas, 'Accepted').className, 'btn small ghost');
+  assert.equal(ui.button(tomas, 'Decline').hidden, true);
+  assert.equal(ui.msg(tomas).textContent, 'Tomás Ek is in Night Shift now.');
+});
+
+test('an ended request leaves nothing pressable; an expired session and a dead network keep the card re-tryable', async () => {
+  const ui = boot({ answers: [{ ok: false, status: 404, body: {} }, { ok: false, status: 401, body: {} }, { reject: true }] });
+  ui.sandbox.renderGuildRequests([TOMAS, KAI]);
+  const [tomas, kai] = ui.asks();
+  await ui.click(ui.button(tomas, 'Accept'));
+  assert.ok(ui.actions(tomas).every((b) => b.hidden));
+  assert.equal(ui.msg(tomas).textContent, 'That request has ended — it was withdrawn, it ran out, or their account is closed.');
+  await ui.click(ui.button(kai, 'Accept'));
+  assert.ok(ui.msg(kai).children.find((c) => c.tag === 'a'), 'sign in again');
+  assert.equal(ui.button(kai, 'Accept').disabled, false);
+  await ui.click(ui.button(kai, 'Accept'));
+  assert.equal(ui.msg(kai).textContent, 'Couldn’t reach the platform — check your connection and try again.');
+  assert.equal(ui.button(kai, 'Accept').disabled, false);
+});
+
+// ── the reads ────────────────────────────────────────────────────────────────
+
+test('ONE read feeds both lists — the invites to you and the requests to every guild you own — never one per guild', async () => {
+  const ui = boot({ answers: [{ ok: true, status: 200, body: {
+    incoming: [OPEN_HANDS], outgoing: [{ id: '9', slug: 'x' }], owner_incoming: [TOMAS, KAI],
+    incoming_count: 1, outgoing_count: 1, owner_incoming_count: 2,
+  } }] });
+  await ui.sandbox.loadGuildQueue();
+  await ui.settle();
+  assert.deepEqual(ui.requests.map((r) => `${r.method} ${r.url}`), ['GET /api/bongos/me/guild-requests']);
+  assert.equal(ui.requests[0].credentials, 'same-origin');
+  assert.equal(ui.invites().length, 1, 'incoming only: the requests YOU sent are not cards here');
+  assert.equal(ui.asks().length, 2);
+  assert.equal(ui.part(ui.asks()[0], 'mineRow__name').textContent, 'Tomás Ek asked to join Night Shift', 'each row names its own guild');
+  assert.doesNotMatch(CARDS, /\/me\/guilds'|\/requests'/, 'no per-guild queue read anywhere in the cards');
+});
+
+test('a failed or empty read is silent: no cards, and the section stays hidden', async () => {
+  for (const answer of [{ ok: false, status: 500, body: {} }, { reject: true }, { ok: true, status: 200, body: {} }]) {
+    const ui = boot({ answers: [answer] });
+    await ui.sandbox.loadGuildQueue();
+    await ui.settle();
+    assert.equal(ui.invites().length + ui.asks().length, 0);
+    assert.equal(ui.section().hidden, true);
+  }
+});
+
+test('a row the page cannot answer is dropped, never drawn with a button that fails', () => {
+  const ui = boot();
+  ui.sandbox.renderGuildInvites([
+    { ...OPEN_HANDS, id: 'abc' }, { ...OPEN_HANDS, id: undefined }, { ...OPEN_HANDS, slug: '' },
+    { ...OPEN_HANDS, visibility: 'secret' }, null, QUIET_ROOM,
+  ]);
+  assert.deepEqual(ui.invites().map((c) => ui.part(c, 'mineRow__name').textContent), ['You’re invited to join Quiet Room']);
+  ui.sandbox.renderGuildRequests([{ ...TOMAS, id: '1x' }, { ...TOMAS, handle: '' }, { ...TOMAS, guild: null }, KAI]);
+  assert.equal(ui.asks().length, 1);
+  // within the bigint range the route checks (routes/guilds.js requestId), and no further
+  ui.sandbox.renderGuildRequests([{ ...TOMAS, id: '9223372036854775808' }, { ...KAI, id: '9223372036854775807' }]);
+  assert.deepEqual(ui.asks().map((c) => ui.part(c, 'mineRow__name').textContent), ['@kai-lowe asked to join Night Shift']);
+});
+
+// ── the markup, the region's rules, the kit ──────────────────────────────────
+
+test('the cards are real lists in the Invitations section, built with createElement / textContent only', () => {
+  const section = (HUB.match(/<section id="mineInvites" hidden aria-labelledby="mineInvitesH">[\s\S]*?<\/section>/) || [''])[0];
+  const order = ['invitesList', 'guildInviteList', 'engageList', 'guildRequestList'].map((id) => section.indexOf(`<ul class="mineRows" id="${id}"></ul>`));
+  assert.ok(order.every((i) => i > 0), 'each list ships as real markup the script only fills');
+  assert.deepEqual([...order].sort((a, b) => a - b), order, 'invites to you first, the requests to your guilds last');
+  assert.doesNotMatch(CARDS, /innerHTML|insertAdjacentHTML|outerHTML/);
+  assert.match(REGION, /function loadInvites\(\) \{[\s\S]*?loadEngagements\(\),\s*loadGuildQueue\(\)\s*\]\);/, 'the mine view reads them with the other invitations');
+  const COSMOS = fs.readFileSync(path.join(LANDING, 'assets', 'cosmos.css'), 'utf8');
+  for (const rule of ['.guildCount__opts{', '.guildCount__opt:has(input:checked) b::before{', '.guildCount__opt:focus-within{', '.guildRow--invite .mineRow__actions{align-self:flex-end;}']) {
+    assert.ok(COSMOS.includes(rule), `cosmos.css carries ${rule}`);
+  }
+  assert.doesNotMatch(HUB.slice(0, HUB.indexOf('</head>')), /guildCount|guildRow/, 'styled in cosmos.css, not in the page head');
+});
+
+test('the kit pictures the cards, and the stub answers the four calls as the routes do', () => {
+  const states = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.states.json'), 'utf8')).states;
+  for (const s of ['in-mine-guild-cards', 'in-mine-guild-count-off', 'in-mine-guild-joined']) assert.ok(states[s], `kit state ${s}`);
+  const probes = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.probes.json'), 'utf8')).probes.map((p) => p.name);
+  assert.ok(probes.some((n) => /guild invite/.test(n)) && probes.some((n) => /join request/.test(n)), 'probes drive both cards');
+  const serve = fs.readFileSync(path.join(ROOT, 'modules', 'ui-design', 'kit', 'serve.js'), 'utf8');
+  assert.match(serve, /rest === '\/me\/guild-requests' && req\.method === 'GET'\) return AUTH \? myGuildRequests\(res\)/);
+  assert.match(serve, /owner_incoming: owner, owner_incoming_count: owner\.length/, 'the route’s one-read shape, owner rows included');
+  assert.match(serve, /'guild_card_visibility_required'/, 'an invitee accept with no visibility is refused, as the route does');
+  assert.match(serve, /code: 'guild_visibility_changed'[^\n]*details: \{ visibility: now \}/, 'and one that differs is the 409 with the guild as it is now');
+  assert.match(serve, /res\.writeHead\(204/, 'a decline is a silent 204');
+  const fixture = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules', 'ui-design', 'kit', 'fixtures', 'me__guild-requests.json'), 'utf8'));
+  for (const r of fixture.incoming) {
+    assert.deepEqual(Object.keys(r).sort(), ['created_at', 'description', 'id', 'name', 'seen_at', 'slug', 'visibility'], 'listMyRequests’s row shape');
+  }
+  assert.deepEqual(fixture.incoming.map((r) => r.visibility).sort(), ['public', 'unlisted']);
+});

package/tests/module_api.mjs

@@ -48,6 +48,7 @@ const PUBLISHED_SURFACE = [
   'projectJoinDoor', // added by task 1002331 (ADR 0182 D6 / ADR 0247): the COMPOSED join/apply door — visibility × join grant × joinability, one answer, so a module reading a single knob cannot re-open a door the other two closed
   'artistGate', // added by task 1003575 (ADR 0241): the artist gate — off | advisory | strict, plus the pure verdict helpers over it. Two modules ask it two different questions ("file this review?" and "does an open one hold the deploy?") and both must resolve the knob through this one reader, never branding().project
   'readApplicantProfileFromHub', // added by task 1002972 (privacy spec D7): the reviewer queue's LIVE per-render read of one applicant's hub profile view. NARROW by design — the underlying call is authenticated with this instance's hub client secret, and loadIdpConfig stays OFF the doorway so no module ever holds the credential that speaks for the whole project
+  'readApplicantViewFromHub', // added by task 1002304 (ADR 0365 D5): the same NARROW hub read as readApplicantProfileFromHub, answering { profile, guild } so the reviewer queue can group a guild's applicants. The guild rides only beside a profile, and the older port is kept so a module on it reads exactly what it did
   'notifyHubOfInvite', // added by task 1002818 (ADR 0353): tell the hub about one of THIS project's invites (or its rescind) so the invitee sees it in My Projects. The same NARROW-port reason as readApplicantProfileFromHub: the call carries this instance's hub client secret, so a module passes one login and one direction and can neither widen nor re-address it
   'inviteExpiry', // added by task 1002969 (ADR 0356): the ONE read-time definition of when a recruit invite's door closes. The sign-in gate reads it in core; the onboarding queues and the hub's notice list are modules, so without the doorway each would restate the 30 days and the predicate, and two copies can close a door on different days
   'readApplicationVouch', // added by task 1002285 (ADR 0201 D2): the public access-request write's check of the hub's application vouch. NARROW for the same reason — core supplies the hub key and this instance's client_id, so a module passes a token and a login and can neither swap the key nor re-address the audience

package/tests/watch_applications_queue.mjs

@@ -93,7 +93,8 @@ async function boot(opts = {}) {
     rows = { pending: WAITING, invited: ADMITTED, dismissed: DECLINED },
     rank = 'archon',
     queueStatus = null,          // non-200 for the queue read (403 seals it)
-    patchResult = null,          // a scripted answer for PATCH /access-requests/:id
+    patchResult = null,          // a scripted answer for PATCH /access-requests/:id (or a function of the id)
+    hub = null,                  // the hub origin OTB.hubOrigin() answers (task 1002304); null = no hub
     search = '',                 // the page's query string (?invite=<login>, task 1002818)
   } = opts;
 
@@ -114,7 +115,9 @@ async function boot(opts = {}) {
         return ok({ requests: rows[status] || [] });
       }
       if (method === 'PATCH' && route.startsWith('/access-requests/')) {
-        return patchResult || ok({ ok: true, request: { id: route.split('/').pop() } });
+        const id = route.split('/').pop();
+        const scripted = typeof patchResult === 'function' ? patchResult(id) : patchResult;
+        return scripted || ok({ ok: true, request: { id } });
       }
       if (method === 'POST' && route === '/access-requests/invite') return ok({ ok: true });
       // Every other panel on this page loads independently and degrades on its
@@ -175,6 +178,7 @@ async function boot(opts = {}) {
       fmtDate: (iso) => String(iso).slice(0, 10),
       rankLabel: (r) => String(r),
       toast: (m) => toasts.push(m),
+      hubOrigin: () => hub,
     },
     OTBKit: kit,
     OTBBranding: { currencyLabel: () => 'Credits' },
@@ -522,4 +526,110 @@ await test('?invite= that is not a GitHub username fills nothing', async () => {
   assert.equal(at.documentObj.getElementById('gate-invite-login').value, 'octo', 'a pasted @ is dropped, as the form itself does');
 });
 
+// ===========================================================================
+// A guild's applicants, together (task 1002304, R28; ADR 0365 D5)
+// ===========================================================================
+//
+// The hub labels an applicant who applied WITH their guild, and core passes the
+// label through as `guild` beside `profile` (tests/application_lifecycle.mjs
+// proves that half). What a reviewer sees is asserted here: the rows gathered
+// under the guild's name, "Invite all" as N ordinary invites, and the queue
+// exactly as it was when no row carries a guild.
+
+const LANTERN = { slug: 'lantern-works', name: 'Lantern Works' };
+const guildRow = (id, login, guild, over = {}) => ({
+  id, github_login: login, display_name: null, note: null, status: 'pending',
+  created_at: '2026-09-03T10:00:00Z', resolved_at: null, vouched: true, resolved_by_login: null,
+  profile: null, guild, ...over,
+});
+const GUILD_QUEUE = [
+  guildRow('21', 'ada', LANTERN),
+  guildRow('22', 'kel', LANTERN),
+  guildRow('23', 'fox', { slug: null, name: 'Night Shift' }),
+  WAITING[1],
+];
+const groupsOf = (h) => h.gate().querySelectorAll('section').filter((s) => String(s.className).split(/\s+/).includes('ov-group'));
+const groupNamed = (h, name) => groupsOf(h).find((g) => g.querySelector('.ov-group__name').textContent === name);
+const rowIdsIn = (el) => el.querySelectorAll('li').map((r) => r.getAttribute('data-req-id'));
+
+await test('applicants who applied with a guild are gathered under its name, the rest on their own', async () => {
+  const h = await boot({ rows: { pending: GUILD_QUEUE, invited: [], dismissed: [] } });
+  const lantern = groupNamed(h, 'Lantern Works');
+  assert.ok(lantern, 'the guild has a head of its own');
+  assert.deepEqual(rowIdsIn(lantern), ['21', '22'], 'both members, in the server order');
+  assert.equal(lantern.querySelector('.ov-group__n').textContent, '2');
+  assert.deepEqual(rowIdsIn(groupNamed(h, 'Night Shift')), ['23'], 'an unlisted guild is named too');
+  assert.deepEqual(rowIdsIn(groupNamed(h, 'On their own')), ['8'], 'a row with no guild stays out of every guild');
+  assert.equal(h.rows().length, 4, 'grouping moves rows, it never drops one');
+});
+
+await test('no row carries a guild (an older hub, no hub): the queue is exactly the list it was', async () => {
+  const h = await boot();
+  assert.equal(groupsOf(h).length, 0, 'no group heads at all when there is nothing to group');
+  assert.equal(h.gate().querySelectorAll('ul').filter((u) => u.className === 'ov-rows').length, 1);
+});
+
+await test('an UNVOUCHED row naming a guild is not filed under it — the label is the vouch’s to give', async () => {
+  const impostor = guildRow('31', 'mallory', LANTERN, { vouched: false });
+  const h = await boot({ rows: { pending: [guildRow('21', 'ada', LANTERN), impostor], invited: [], dismissed: [] } });
+  assert.deepEqual(rowIdsIn(groupNamed(h, 'Lantern Works')), ['21']);
+  assert.deepEqual(rowIdsIn(groupNamed(h, 'On their own')), ['31']);
+});
+
+await test('a grouped row keeps its own pill and its own two decisions (ADR 0016)', async () => {
+  const h = await boot({ rows: { pending: GUILD_QUEUE, invited: [], dismissed: [] } });
+  const verbs = h.rowFor('21').querySelectorAll('[data-gate-action]').map((b) => b.getAttribute('data-gate-action'));
+  assert.deepEqual(verbs, ['invited', 'dismissed']);
+  assert.match(h.rowFor('21').querySelector('.fact-pill').textContent, /vouched/i);
+});
+
+await test('"Invite all" is N ordinary invites — one PATCH per waiting member, then one re-read', async () => {
+  const h = await boot({ rows: { pending: GUILD_QUEUE, invited: [], dismissed: [] } });
+  const btn = groupNamed(h, 'Lantern Works').querySelector('[data-gate-bulk]');
+  assert.ok(btn, 'a guild of two offers Invite all');
+  assert.match(btn.textContent, /Invite all 2/);
+  const reads = h.queueReads().length;
+  btn.fire('click', {});
+  await h.settle();
+  assert.deepEqual(h.patches().map((p) => p.path).sort(),
+    ['/api/bongos/access-requests/21', '/api/bongos/access-requests/22'], 'each member, and nobody else');
+  for (const p of h.patches()) assert.deepEqual(plain(p.body), { status: 'invited' }, 'the very write the row button sends');
+  assert.equal(h.queueReads().length, reads + 1, 'the queue is re-read once, after every invite settled');
+  assert.match(h.toasts.at(-1), /Invited all 2/);
+});
+
+await test('one refused invite does not strand the rest, and the toast says how many landed', async () => {
+  const h = await boot({
+    rows: { pending: GUILD_QUEUE, invited: [], dismissed: [] },
+    patchResult: (id) => (id === '22' ? fail(409, 'already_member', 'They have already signed in.') : null),
+  });
+  groupNamed(h, 'Lantern Works').querySelector('[data-gate-bulk]').fire('click', {});
+  await h.settle();
+  assert.equal(h.patches().length, 2, 'both invites were sent');
+  assert.match(h.toasts.at(-1), /Invited 1 of 2/);
+  assert.match(h.toasts.at(-1), /already signed in/, 'the server sentence, not [object Object]');
+});
+
+await test('a lone member has no "Invite all", and the decided views offer no bulk move', async () => {
+  const h = await boot({ rows: { pending: GUILD_QUEUE, invited: GUILD_QUEUE.map((r) => ({ ...r, status: 'invited' })), dismissed: [] } });
+  assert.equal(groupNamed(h, 'Night Shift').querySelector('[data-gate-bulk]'), null, 'one applicant already has their own Invite');
+  await h.switchView('invited');
+  assert.ok(groupNamed(h, 'Lantern Works'), 'the history is still grouped by guild');
+  assert.equal(h.gate().querySelector('[data-gate-bulk]'), null, 'a mass rescind is not a gesture this queue makes');
+});
+
+await test('the guild name links to its hub page only when it has one, and is always escaped', async () => {
+  const hostile = { slug: 'lantern-works', name: '<img src=x onerror=alert(1)>Lantern' };
+  const rows = [guildRow('21', 'ada', hostile), guildRow('23', 'fox', { slug: null, name: 'Night Shift' })];
+  const linked = await boot({ hub: 'https://hub.example', rows: { pending: rows, invited: [], dismissed: [] } });
+  const a = linked.gate().querySelectorAll('a').find((x) => String(x.className).includes('gate-guild__link'));
+  assert.ok(a, 'a public guild links to its page on the hub');
+  assert.equal(a.getAttribute('href'), 'https://hub.example/g/lantern-works');
+  assert.equal(linked.gate().querySelectorAll('img').length, 0, 'a guild name is user text on a page an Archon reads');
+  assert.equal(groupNamed(linked, 'Night Shift').querySelectorAll('a').length, 0, 'an unlisted guild has no page to open');
+  const noHub = await boot({ rows: { pending: rows, invited: [], dismissed: [] } });
+  assert.equal(noHub.gate().querySelectorAll('a').filter((x) => String(x.className).includes('gate-guild__link')).length, 0,
+    'no hub, no link — never a same-host URL claiming to be the hub');
+});
+
 summary();