@bongos/core 1.19.538 → 1.19.539

package/tests/project_invite_ui.mjs

@@ -0,0 +1,502 @@
+// tests/project_invite_ui.mjs — inviting a builder to a project, EXECUTED
+// (BV1.R27, task 1002346, goal 1000046 criterion C6, ADR 0249).
+//
+// tests/project_invite_ownership.mjs pins the ROUTE half — who POST
+// /projects/invite admits and what it refuses. This file pins the SURFACE an
+// owner actually uses: the creation wizard's optional invite step, and the same
+// widget mounted again on the project's own page so a skipped step is a default
+// rather than a dead end.
+//
+// The idiom is tests/project_modules_ui.mjs beside it (there is no jsdom in this
+// repo): lift the region out of modules/public-landing/public/projects.html, run
+// it in a vm under a minimal DOM stub, PARSE the markup it writes, drive real
+// clicks — and assert the slice boundaries themselves, so a rename can never
+// leave this file quietly executing an empty string.
+//
+// What it proves, and why each matters:
+//   • the step is INVISIBLE until there is a real project to invite to — the
+//     catalog row a client_id resolves is projected at create (ADR 0246), so
+//     before that an invite could only ever 404
+//   • an invite sends exactly { client_id, github_login } — the slug IS the
+//     client_id — on the cookie session, and nothing else
+//   • the 201 row is what the pending line is drawn from, and the github_id it
+//     carries is never shown
+//   • every refusal the route can give is said in the route's own vocabulary,
+//     and the 403 is said CAREFULLY: it is byte-identical whether or not the
+//     project exists (ADR 0248), so the page may not read it as "it is there"
+//   • a refusal never costs the project or the step — the box stays, re-tryable
+//   • Skip advances with ZERO calls
+//   • both call sites hand over a slug only for a signed-in owner
+//
+// Run:  node --test --test-reporter=tap tests/project_invite_ui.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 COSMOS = fs.readFileSync(path.join(LANDING, 'assets', 'cosmos.css'), 'utf8').replace(/\r\n/g, '\n');
+const SCRIPT = (HUB.match(/<script>([\s\S]*?)<\/script>\s*<\/body>/) || [, ''])[1];
+
+const START = SCRIPT.indexOf('var INVITE_MOUNTS = {');
+const END = SCRIPT.indexOf('/* ── boot: who am I');
+assert.ok(START > 0, 'the invite region must start at INVITE_MOUNTS');
+assert.ok(END > START, 'the invite region must end before the boot block');
+const REGION = SCRIPT.slice(START, END);
+for (const fn of ['function setInviteSlug(', 'function doInvite(', 'function skipInvite(', 'function inviteRefusal(']) {
+  assert.ok(REGION.includes(fn), `the region must carry ${fn}`);
+}
+
+// ── the DOM stub ─────────────────────────────────────────────────────────────
+// Narrow on purpose (the project_modules_ui.mjs rule): it supports exactly what
+// the region uses, so it stays honest about what it can prove.
+
+const ROW = /<li><b>([^<]*)<\/b><small>([^<]*)<\/small><\/li>/g;
+const parseRows = (html) => [...String(html).matchAll(ROW)].map((m) => ({ login: m[1], said: m[2] }));
+
+function boot({ mount = 'wizInvite', answers = [] } = {}) {
+  const requests = [];
+  const els = new Map();
+  const listeners = new Map();          // "elId:type" → [fn]
+  const focused = [];
+
+  const makeEl = (id) => ({
+    _id: id, _html: '', textContent: '', className: '', value: '', hidden: false,
+    set innerHTML(v) { this._html = String(v); },
+    get innerHTML() { return this._html; },
+    addEventListener(type, fn) {
+      const key = id + ':' + type;
+      if (!listeners.has(key)) listeners.set(key, []);
+      listeners.get(key).push(fn);
+    },
+    setAttribute() {},
+    focus() { focused.push(id); },
+  });
+  const $ = (id) => {
+    if (id == null) return null;
+    if (!els.has(id)) els.set(id, makeEl(id));
+    return els.get(id);
+  };
+
+  // Every mount's elements exist before the region wires them, exactly as the
+  // real page has them: the script runs at the end of <body>.
+  ['wizInvite', 'wizInviteWho', 'wizInviteList', 'wizInviteMsg', 'wizInviteLater', 'doneStepsHead',
+    'mInvite', 'mInviteWho', 'mInviteList', 'mInviteMsg'].forEach($);
+
+  const queued = answers.slice();
+  const fetch = (url, init = {}) => {
+    requests.push({ url, method: init.method || 'GET', body: init.body, credentials: init.credentials, headers: init.headers });
+    const a = queued.shift() || { ok: true, status: 201, body: { invited: true, row: { id: 7, client_id: 'mercury', github_id: 4242, membership_kind: 'pending' } } };
+    if (a.reject) return Promise.reject(new Error('offline'));
+    return Promise.resolve({ ok: a.ok, status: a.status, _json: a.body, json: () => Promise.resolve(a.body) });
+  };
+
+  const sandbox = {
+    $, fetch, console, Promise, JSON, String, Object, Array, Error,
+    encodeURIComponent, setTimeout, clearTimeout,
+    API: '/api/bongos',
+    esc: (s) => String(s == null ? '' : s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;'),
+    jsonOrEmpty: (res) => Promise.resolve(res._json),
+    apiError: (data, status) => ({
+      code: (data && data.error && data.error.code) || ('http_' + status),
+      message: (data && data.error && data.error.message) || '',
+    }),
+    signInAgain: () => 'Your session expired — <a href="/in">sign in again</a>.',
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(REGION, sandbox, { filename: 'projects.html#project-invite' });
+
+  const mounts = {
+    wizInvite: { who: 'wizInviteWho', list: 'wizInviteList', msg: 'wizInviteMsg' },
+    mInvite: { who: 'mInviteWho', list: 'mInviteList', msg: 'mInviteMsg' },
+  };
+  const m = mounts[mount];
+  const settle = async () => { for (let i = 0; i < 40; i++) await Promise.resolve(); };
+
+  const press = async (marker) => {
+    const handlers = listeners.get(mount + ':click') || [];
+    assert.equal(handlers.length, 1, 'the mount wires exactly one delegated click handler');
+    handlers[0]({
+      target: {
+        closest: (sel) => (sel === '[data-invite-send],[data-invite-skip]'
+          ? { hasAttribute: (a) => a === marker }
+          : null),
+      },
+    });
+    await settle();
+  };
+
+  return {
+    requests, sandbox, settle, focused,
+    box: () => $(mount),
+    field: () => $(m.who),
+    msg: () => $(m.msg),
+    rows: () => parseRows($(m.list).innerHTML),
+    async open(slug) { sandbox.setInviteSlug(mount, slug); await settle(); },
+    async type(login) { $(m.who).value = login; },
+    async send() { await press('data-invite-send'); },
+    async skip() { await press('data-invite-skip'); },
+    async enter() {
+      const handlers = listeners.get(m.who + ':keydown') || [];
+      assert.equal(handlers.length, 1, 'the field takes Enter');
+      handlers[0]({ key: 'Enter', preventDefault() {} });
+      await settle();
+    },
+  };
+}
+
+const refused = (status, code, message) => ({ ok: false, status, body: { error: { code, message: message || '' } } });
+
+// ── the step only exists once the project does ───────────────────────────────
+
+test('the step is invisible until a real project exists — no slug, no step', async () => {
+  // Arrange — the mount is what the page ships: hidden, with nothing to invite to
+  const ui = boot();
+
+  // Act
+  await ui.open('');
+
+  // Assert
+  assert.equal(ui.box().hidden, true, 'the box stays hidden');
+  assert.equal(ui.rows().length, 0);
+});
+
+test('a real slug opens the step', async () => {
+  const ui = boot();
+
+  await ui.open('mercury');
+
+  assert.equal(ui.box().hidden, false);
+});
+
+test('a click while the step is closed sends nothing at all', async () => {
+  // This is how "signed out" and "not the owner" reach the widget: the call site
+  // hands over no slug, and there is nothing to send.
+  const ui = boot();
+  await ui.open('');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(ui.requests.length, 0, 'no project, no request');
+});
+
+// ── the invite itself ────────────────────────────────────────────────────────
+
+test('an invite carries exactly { client_id, github_login } — the slug IS the client_id', async () => {
+  // Arrange
+  const ui = boot();
+  await ui.open('mercury');
+
+  // Act
+  await ui.type('octo-builder');
+  await ui.send();
+
+  // Assert
+  assert.equal(ui.requests.length, 1);
+  const req = ui.requests[0];
+  assert.equal(req.url, '/api/bongos/projects/invite');
+  assert.equal(req.method, 'POST');
+  assert.equal(req.credentials, 'same-origin', 'the cookie session is the auth — this page carries no token');
+  assert.deepEqual(JSON.parse(req.body), { client_id: 'mercury', github_login: 'octo-builder' },
+    'exactly the two fields the route validates, and nothing else');
+});
+
+test('the pending line is drawn from the 201 ROW, and the github_id on it is never shown', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.deepEqual(ui.rows().map((r) => r.login), ['octo-builder']);
+  assert.match(ui.rows()[0].said, /waiting for them to accept/i, "the row's own 'pending' is what the line says");
+  assert.equal(ui.msg().className, 'projMsg ok');
+  assert.doesNotMatch(ui.msg().textContent + ui.rows()[0].said + ui.rows()[0].login, /4242/,
+    'the row carries a github_id; a person who has accepted nothing yet is not published by it');
+});
+
+test('a membership_kind the page does not know is shown VERBATIM, never papered over as pending', async () => {
+  // The state word is the row's, not this page's: if the route ever seeds a
+  // different kind, an owner sees that rather than a comfortable fiction.
+  const ui = boot({ answers: [{ ok: true, status: 201, body: { invited: true, row: { id: 7, client_id: 'mercury', github_id: 1, membership_kind: 'member' } } }] });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(ui.rows()[0].said, 'member');
+});
+
+test('a name is trimmed, and an empty one is a question rather than a request', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+
+  await ui.type('   ');
+  await ui.send();
+  assert.equal(ui.requests.length, 0, 'nothing is sent for a blank field');
+  assert.equal(ui.msg().className, 'projMsg err');
+
+  await ui.type('  octo-builder  ');
+  await ui.send();
+  assert.deepEqual(JSON.parse(ui.requests[0].body).github_login, 'octo-builder');
+});
+
+test('the field clears after a sent invite, so the next one starts empty', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(ui.field().value, '');
+});
+
+test('Enter in the field sends the invite too', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.enter();
+
+  assert.equal(ui.requests.length, 1);
+});
+
+test('two invites in a row both stand, newest last', async () => {
+  const ui = boot({
+    answers: [
+      { ok: true, status: 201, body: { invited: true, row: { id: 7, client_id: 'mercury', github_id: 1, membership_kind: 'pending' } } },
+      { ok: true, status: 201, body: { invited: true, row: { id: 8, client_id: 'mercury', github_id: 2, membership_kind: 'pending' } } },
+    ],
+  });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+  await ui.type('second-builder');
+  await ui.send();
+
+  assert.deepEqual(ui.rows().map((r) => r.login), ['octo-builder', 'second-builder']);
+});
+
+// ── every refusal the route can give ─────────────────────────────────────────
+
+test('an invitee with no platform account is named honestly, and the step survives it', async () => {
+  const ui = boot({ answers: [refused(404, 'account_not_found', 'That builder has no platform account yet — they must sign in somewhere once before they can be invited.')] });
+  await ui.open('mercury');
+
+  await ui.type('nobody-here');
+  await ui.send();
+
+  assert.equal(ui.msg().className, 'projMsg err');
+  assert.match(ui.msg().textContent, /hasn’t signed in here yet/i);
+  assert.equal(ui.box().hidden, false, 'the step stays — a failed invite is re-tryable');
+  assert.equal(ui.rows().length, 0, 'and nothing is drawn as pending that is not');
+});
+
+test('someone already on the project is said plainly, not as a failure', async () => {
+  const ui = boot({ answers: [{ ok: true, status: 200, body: { invited: false, alreadyMember: true } }] });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(ui.msg().className, 'projMsg ok');
+  assert.match(ui.msg().textContent, /already on this project/i);
+  assert.equal(ui.rows().length, 0, 'an existing member is not a pending invite');
+});
+
+test('a project the map has not caught up with says exactly that, and stays re-tryable', async () => {
+  // The catalog row is projected at create (ADR 0246), so this is a moment, not
+  // a dead end — the copy has to say "in a moment", never "no such project".
+  const ui = boot({ answers: [refused(404, 'unknown_project')] });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(ui.msg().className, 'projMsg err');
+  assert.match(ui.msg().textContent, /isn’t on the map yet/i);
+  assert.match(ui.msg().textContent, /try again/i);
+  assert.equal(ui.box().hidden, false);
+});
+
+test('a 403 is NEVER read as "the project is there but you may not" — it says only what it knows', async () => {
+  // ADR 0248: the refusal is identical for a real project, a stealth one, one
+  // that does not exist and a malformed body. A page that words it as "you lack
+  // permission on THIS project" turns an equalised refusal back into an oracle.
+  const ui = boot({ answers: [refused(403, 'permission_forbidden', 'requires project.curate')] });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(ui.msg().className, 'projMsg err');
+  const said = ui.msg().textContent;
+  assert.match(said, /can’t invite/i);
+  assert.doesNotMatch(said, /this project (is|exists)/i, 'it may not assert the project exists');
+  assert.doesNotMatch(said, /project\.curate/, 'and it does not recite the atom at an owner');
+});
+
+test('an expired session offers a way back in rather than a dead end', async () => {
+  const ui = boot({ answers: [refused(401, 'unauthenticated')] });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.match(ui.msg().innerHTML, /sign in again/i);
+});
+
+test('an unreachable platform is said as a network problem, not as a refusal', async () => {
+  const ui = boot({ answers: [{ reject: true }] });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(ui.msg().className, 'projMsg err');
+  assert.match(ui.msg().textContent, /reach the platform/i);
+});
+
+test('an unknown refusal falls through to the server’s own words rather than an invented reason', async () => {
+  const ui = boot({ answers: [refused(429, 'rate_limited', 'Too many invitations right now — give it a minute.')] });
+  await ui.open('mercury');
+
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.match(ui.msg().textContent, /Too many invitations right now/);
+});
+
+test('inviteRefusal is a pure function over the route’s own vocabulary', () => {
+  const f = boot().sandbox.inviteRefusal;
+  assert.match(f('account_not_found', 404, ''), /signed in here yet/i);
+  assert.match(f('unknown_project', 404, ''), /map yet/i);
+  assert.match(f('permission_forbidden', 403, ''), /can’t invite/i);
+  assert.equal(f('whatever', 500, 'the server said this'), 'the server said this');
+  assert.match(f('whatever', 500, ''), /couldn’t be sent/i);
+});
+
+// ── skip ─────────────────────────────────────────────────────────────────────
+
+test('Skip advances with ZERO calls — nothing is sent and nothing is claimed', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+  await ui.type('octo-builder');   // even a typed name is not a filed invite
+
+  await ui.skip();
+
+  assert.equal(ui.requests.length, 0, 'a skip sends nothing');
+  assert.equal(ui.box().hidden, true, 'and the step steps aside');
+  assert.equal(ui.rows().length, 0);
+});
+
+test('a skip moves focus on rather than stranding it inside the box it just hid', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+
+  await ui.skip();
+
+  assert.deepEqual(ui.focused, ['doneStepsHead']);
+});
+
+test('a NEW project starts the step clean — the last one’s pending lines do not follow it', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+  await ui.type('octo-builder');
+  await ui.send();
+  assert.equal(ui.rows().length, 1);
+
+  await ui.open('venus');
+
+  assert.equal(ui.rows().length, 0, 'the invites belonged to the project they were filed on');
+  assert.equal(ui.box().hidden, false, 'and the step reopens for the new one, skip or no skip');
+});
+
+// ── the project's own page: the same widget, mounted again ───────────────────
+
+test('the project’s own page mounts the SAME widget on the SAME route', async () => {
+  const ui = boot({ mount: 'mInvite' });
+
+  await ui.open('mercury');
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.deepEqual(JSON.parse(ui.requests[0].body), { client_id: 'mercury', github_login: 'octo-builder' });
+  assert.deepEqual(ui.rows().map((r) => r.login), ['octo-builder']);
+});
+
+test('the two mounts keep their own lines — an invite on one is not drawn on the other', async () => {
+  const ui = boot();
+  await ui.open('mercury');
+  await ui.type('octo-builder');
+  await ui.send();
+
+  assert.equal(parseRows(ui.sandbox.$('mInviteList').innerHTML).length, 0);
+});
+
+// ── the call sites (source pins) ─────────────────────────────────────────────
+// The two questions this widget deliberately does NOT answer — "is anyone signed
+// in" and "is this their project" — are answered by the caller, which hands over
+// a slug or nothing. So the pins are on the calls.
+
+test('the wizard opens the step only for a signed-in owner of a project that already exists', () => {
+  assert.match(SCRIPT, /setInviteSlug\('wizInvite', \(me && created && created\.id && created\.slug\) \? created\.slug : ''\);/,
+    'the created record IS the proof: no /me, no created id, no slug ⇒ no step');
+  assert.ok(SCRIPT.indexOf("setInviteSlug('wizInvite'") > SCRIPT.indexOf('function renderDone()'),
+    'and it is the done panel that opens it — the panel that only exists after Create');
+});
+
+test('the project page opens the step from its own manage read, which the API already own-scopes', () => {
+  assert.match(SCRIPT, /setInviteSlug\('mInvite', inst\.slug \|\| ''\);/,
+    'renderManage hands over the slug it was given');
+  assert.ok(SCRIPT.indexOf("setInviteSlug('mInvite'") > SCRIPT.indexOf('function renderManage(inst)'),
+    'inside renderManage — which the per-id read 404s for anyone who is not the owner');
+});
+
+// ── the markup + the sheet ───────────────────────────────────────────────────
+
+test('the wizard’s invite step ships as real markup on the done panel, above the human steps', () => {
+  const panel = (HUB.match(/<section class="panel" id="panel-done"[\s\S]*?<\/section>/) || [''])[0];
+  assert.ok(panel, '#panel-done ships as real markup');
+  assert.match(panel, /<div class="inviteBox" id="wizInvite" hidden>/, 'the step is a real element the script only shows');
+  assert.match(panel, /id="wizInviteWho"/, 'the one field');
+  assert.match(panel, /data-invite-send="wizInvite"/, 'the sender');
+  assert.match(panel, /data-invite-skip="wizInvite"/, 'and the skip is a CONTROL, not "leave it and move on"');
+  assert.match(panel, /Optional/, 'the panel says so before it asks');
+  assert.ok(panel.indexOf('id="wizInvite"') < panel.indexOf('id="doneStepsHead"'),
+    'it stands before the steps only the owner can play');
+  assert.match(panel, /<p class="samePath" id="wizInviteLater"><\/p>/, 'and the way back afterwards is a slot beside the modules one');
+  assert.match(SCRIPT, /\$\('wizInviteLater'\)\.innerHTML = 'You can invite builders any time from ' \+ projectPageLink\('the project’s own page'\) \+ '\.';/,
+    'filled with one sentence naming THIS project, the doneModules idiom');
+});
+
+test('the project’s own page carries the invite line beside its extras', () => {
+  assert.match(HUB, /<div class="card mSec" id="mInvite">\s*<h2>Invite a builder<\/h2>/, 'its own section, the mSec idiom');
+  assert.ok(HUB.indexOf('id="mInvite"') > HUB.indexOf('id="mModules"'), 'and it stands beside Its extras');
+  const sec = (HUB.match(/<div class="card mSec" id="mInvite">[\s\S]*?\n      <\/div>/) || [''])[0];
+  assert.match(sec, /id="mInviteWho"/, 'the same one field');
+  assert.match(sec, /data-invite-send="mInvite"/, 'the same sender');
+  assert.doesNotMatch(sec, /data-invite-skip/, 'nothing to skip here — the project already exists');
+});
+
+test('the field row reuses the page’s own input+button idiom, and the sheet owns the new class (task 1002346)', () => {
+  assert.match(HUB, /<div class="attach">\s*<label class="vh" for="wizInviteWho">/, 'the wizard row is .attach, the page\'s existing pair');
+  assert.match(HUB, /<div class="attach">\s*<label class="vh" for="mInviteWho">/, 'and so is the manage row');
+  assert.match(COSMOS, /#view-new \.attach input\[type=text\]\{/, 'the wizard\'s hairline field is corrected for the flex row in the sheet');
+  assert.match(COSMOS, /\.inviteList\{/, 'the pending list is styled in cosmos.css, not in the page');
+  assert.doesNotMatch(HUB.slice(0, HUB.indexOf('</head>') + 1), /inviteList/, 'no styles for it in the page head');
+});
+
+test('the manage view has a rendered state for the invite line', () => {
+  const states = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.states.json'), 'utf8')).states;
+  assert.ok(states['in-manage-invite'], 'the section has a kit state');
+  assert.deepEqual(states['in-manage-invite'].expect.visible, ['#mInvite', '#mInvite h2', '#mInviteWho', '#mInvite [data-invite-send]']);
+});

package/tests/projects_hub.mjs

@@ -2109,7 +2109,7 @@ test('the wizard\'s own structures wear the world: hairline fields, cells of one
   assert.doesNotMatch(block, /linear-gradient/, 'no tinted plates');
   assert.doesNotMatch(block, /box-shadow:(?!none)/, 'no box shadow in the wizard block');
   assert.match(HUB, /<div class="nav">\s*<button type="button" class="btn ghost" data-back="6">← Back<\/button>\s*<button type="button" class="btn big" id="doCreate">Create my project<\/button>/, 'the review\'s doors sit on one row, back then the primary');
-  assert.match(HUB, /<h2 class="stepsHead">Your steps — the parts only you can play<\/h2>/, 'the steps heading is the label face by class, not an inline style');
+  assert.match(HUB, /<h2 class="stepsHead" id="doneStepsHead">Your steps — the parts only you can play<\/h2>/, 'the steps heading is the label face by class, not an inline style (the id is where a skipped invite step hands focus on, task 1002346)');
   // what is enqueued is unchanged (ADR 0111): the filing body the control plane reads
   assert.match(SCRIPT, /body: JSON\.stringify\(\{\s*slug: state\.slug,/, 'the filing still carries the slug first');
   assert.match(SCRIPT, /hosting_shape: 'standalone',/, 'the shape is unchanged');

package/tests/projects_hub_pre_uat.mjs

@@ -496,8 +496,8 @@ test('a manifest error says a plain sentence, folds the route text, and sends a
     'and it is named by id whenever the flow has one');
   // every done-panel pointer that names a CONTROL goes the same way; the ones
   // that only say "watch it there" still name the list, which does show it
-  assert.equal((SCRIPT.match(/projectPageLink\(/g) || []).length, 7,
-    'the helper and its six callers: the locked step, the domain_required snag, the domainless standup, the snagged retry, the torn-down revive, and the extras pointer (task 1002342)');
+  assert.equal((SCRIPT.match(/projectPageLink\(/g) || []).length, 8,
+    'the helper and its seven callers: the locked step, the domain_required snag, the domainless standup, the snagged retry, the torn-down revive, the extras pointer (task 1002342), and the invite pointer (task 1002346)');
   for (const dead of ['Retry it \\(and see the technical details\\) from <a href="\\?view=mine">',
                       'Bring it back any time from <a href="\\?view=mine">']) {
     assert.doesNotMatch(SCRIPT, new RegExp(dead), 'a control the list no longer has must not be pointed at there');