@bongos/core 1.24.51 → 1.24.53

package/tests/brand_surfaces.mjs

@@ -0,0 +1,213 @@
+// tests/brand_surfaces.mjs — the brand outside the hall (task 1005091, goal 1000138):
+// the link-preview card every public page carries, the branded 404 and 500 pages,
+// the themed API docs, the brand colour on Discord posts, and no maker's name written
+// into the portable landing.
+//
+// Behaviour, not spelling: the server is built and asked for pages over HTTP, the
+// error handlers and the link-preview template are called, and the Discord posters
+// send to a stubbed fetch whose bodies are read back.
+//
+// Run:  node --test tests/brand_surfaces.mjs
+
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { buildPlatformApp } = require('../src/platform-server.js');
+const { linkPreviewTags, applyLinkPreview, CARD_PATH } = require('../src/link-preview.js');
+const { errorPageTemplate, errorHandlers } = require('../src/error-page.js');
+const { applyBrandTokens, injectBrandingGlobal } = require('../src/bongos/serve-internal.js');
+const { clientBranding } = require('../src/branding.js');
+const webhook = require('../modules/discord/webhook.js');
+const discordLib = require('../scripts/discord/lib.js');
+const { ogCardHtml } = require('../scripts/bongos/gen-brand.js');
+
+const BRAND = clientBranding();
+const PRODUCT = BRAND.identity.productName;
+
+let server;
+let port;
+before(async () => {
+  server = http.createServer(buildPlatformApp());
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  port = server.address().port;
+});
+after(async () => { await new Promise((resolve) => server.close(resolve)); });
+
+// node:http, not fetch: fetch drops a Host override.
+function get(p, { host = '127.0.0.1', accept = 'text/html,application/xhtml+xml,*/*;q=0.8' } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({ host: '127.0.0.1', port, path: p, headers: { Host: host, Accept: accept } }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (c) => { body += c; });
+      res.on('end', () => resolve({ status: res.statusCode, type: res.headers['content-type'] || '', body }));
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+// ── the link-preview card ───────────────────────────────────────────────────────
+test('the card is built from the page\'s own title and description, with the shared image', () => {
+  const html = '<html><head><title>Status &amp; more — Acme</title><meta name="description" content="What &quot;shipped&quot;."></head><body></body></html>';
+  const brand = { identity: { productName: 'Acme' }, copy: { tagline: 'unused' } };
+  const tags = linkPreviewTags(html, brand, 'https://acme.example/');
+  assert.ok(tags.includes('<meta property="og:title" content="Status &amp; more — Acme">'), 'escaped once, not twice');
+  assert.ok(tags.includes('<meta property="og:description" content="What &quot;shipped&quot;.">'));
+  assert.ok(tags.includes(`<meta property="og:image" content="https://acme.example${CARD_PATH}">`), 'absolute when the instance has an origin');
+  assert.ok(tags.includes('<meta name="twitter:card" content="summary_large_image">'));
+  assert.ok(tags.includes('<meta property="og:site_name" content="Acme">'));
+  assert.ok(linkPreviewTags('<title>x</title>', {}, '').includes(`content="${CARD_PATH}"`), 'root-relative with no origin');
+  // a page that writes its own card keeps it
+  assert.equal(linkPreviewTags('<head><meta property="og:title" content="own"></head>', brand, ''), '');
+  const applied = applyLinkPreview(html, brand, '');
+  assert.ok(applied.indexOf('og:image') < applied.indexOf('</head>'));
+});
+
+test('every served public page carries the card: status, docs, and anything branded', async () => {
+  const status = await get('/', { host: 'status.example.com' });
+  assert.equal(status.status, 200);
+  assert.match(status.body, new RegExp(`<meta property="og:image" content="[^"]*${CARD_PATH.replace(/[.]/g, '\\.')}">`));
+  assert.match(status.body, /<meta property="og:title" content="[^"]*build status">/);
+  const docs = await get('/docs');
+  assert.equal(docs.status, 200);
+  assert.match(docs.body, /<meta name="twitter:card" content="summary_large_image">/);
+  // the landing and hub pages go through the same injection
+  const landingLike = injectBrandingGlobal('<html><head><title>{{productName}} — community</title></head><body></body></html>', BRAND, {});
+  assert.ok(landingLike.includes(`<meta property="og:title" content="${PRODUCT} — community">`));
+});
+
+test('the card image is a 1200x630 PNG drawn from the shared mark', () => {
+  const png = fs.readFileSync(path.join(ROOT, 'modules', 'ui-design', 'public', 'brand', 'og-card.png'));
+  assert.equal(png.toString('ascii', 1, 4), 'PNG');
+  assert.deepEqual([png.readUInt32BE(16), png.readUInt32BE(20)], [1200, 630]);
+  const page = ogCardHtml({ markSvg: '<svg/>', name: 'Acme <Co>', fontLinks: ['https://f.example/x'], fontFamily: '"Manrope", sans-serif' });
+  assert.ok(page.includes('text-transform:lowercase'), 'the wordmark is lowercase (DESIGN.md "Naming")');
+  assert.ok(page.includes('Acme &lt;Co&gt;'), 'the name is escaped');
+  assert.ok(page.includes('data:image/svg+xml;base64,'), 'the mark is the shared file, embedded');
+});
+
+// ── the branded 404 and 500 ────────────────────────────────────────────────────
+test('a browser gets the branded 404; an API path keeps JSON; a non-HTML client keeps text', async () => {
+  const page = await get('/no-such-page');
+  assert.equal(page.status, 404);
+  assert.match(page.type, /text\/html/);
+  assert.ok(page.body.includes('<use href="/modules/ui-design/public/brand/mark.svg#mark"/>'), 'the shared mark');
+  assert.ok(page.body.includes(`<title>${BRAND.copy.notFound} · ${PRODUCT}</title>`), 'the pack\'s words and the product name');
+  assert.ok(page.body.includes(BRAND.theme.fonts.links[0].replace(/&/g, '&amp;')), 'the pack\'s faces');
+  assert.doesNotMatch(page.body, /\{\{/);
+
+  const api = await get('/api/bongos/no-such-thing', { accept: 'text/html' });
+  assert.equal(api.status, 404);
+  assert.match(api.type, /application\/json/);
+
+  const curl = await get('/no-such-page', { accept: 'text/plain' });
+  assert.equal(curl.status, 404);
+  assert.match(curl.type, /text\/plain/);
+});
+
+test('a page route that throws answers the branded 500 to a browser and JSON to the API', () => {
+  const logged = [];
+  const { onError } = errorHandlers({
+    brandHtml: (h) => applyBrandTokens(h, { identity: { productName: 'Acme' } }, '', '', '', '', ''),
+    notFoundCopy: () => 'Gone.', isApiShapedPath: (p) => p.startsWith('/api/'), apiNotFoundBody: () => ({}),
+    log: (err) => logged.push(err.message),
+  });
+  const res = () => {
+    const r = { headersSent: false, code: 0, ctype: '', body: null };
+    r.status = (c) => { r.code = c; return r; };
+    r.type = (t) => { r.ctype = t; return r; };
+    r.send = (b) => { r.body = b; return r; };
+    r.json = (b) => { r.ctype = 'json'; r.body = b; return r; };
+    return r;
+  };
+  const req = (p, accept) => ({ path: p, method: 'GET', accepts: (t) => (Array.isArray(t) ? (accept === 'html' ? 'html' : 'json') : accept === 'html') });
+  const page = res();
+  onError(new Error('boom'), req('/projects', 'html'), page, () => {});
+  assert.equal(page.code, 500);
+  assert.equal(page.ctype, 'html');
+  assert.ok(page.body.includes('Something went wrong on our side.') && page.body.includes('· Acme</title>'));
+  assert.doesNotMatch(page.body, /boom/, 'the error text never reaches the page');
+  const api = res();
+  onError(new Error('boom'), req('/api/bongos/x', 'html'), api, () => {});
+  assert.equal(api.ctype, 'json');
+  assert.equal(api.body.error.code, 'internal_error');
+  assert.deepEqual(logged, ['boom', 'boom']);
+  // the 404 template carries the pack's words for "not found"
+  assert.ok(errorPageTemplate(404, { notFound: 'Gone.' }).includes('<h1>Gone.</h1>'));
+});
+
+test('the error page and the docs write their dark tier twice, byte-identical', () => {
+  const twins = (src) => {
+    const a = src.match(/html\[data-theme="dark"\]\s*\{([^}]*)\}/);
+    const b = src.match(/@media \(prefers-color-scheme:\s*dark\)\s*\{\s*html:not\(\[data-theme\]\)\s*\{([^}]*)\}/);
+    assert.ok(a && b, 'both twins exist');
+    const norm = (s) => s.replace(/\s+/g, ' ').trim();
+    assert.equal(norm(b[1]), norm(a[1]));
+  };
+  twins(errorPageTemplate(404));
+  twins(fs.readFileSync(path.join(ROOT, 'public-docs', 'index.html'), 'utf8'));
+});
+
+// ── the API docs ───────────────────────────────────────────────────────────────
+test('the API docs load the brand: the scales, the mark, the pack\'s faces and a token theme for Redoc', async () => {
+  const r = await get('/docs');
+  assert.equal(r.status, 200);
+  assert.ok(r.body.includes('<link rel="stylesheet" href="/modules/ui-design/public/tokens.css">'));
+  assert.ok(r.body.includes('<use href="/modules/ui-design/public/brand/mark.svg#mark"/>'));
+  assert.ok(r.body.includes(BRAND.theme.fonts.links[0].replace(/&/g, '&amp;')), 'the pack\'s font link is spliced');
+  assert.match(r.body, /Redoc\.init\('\/docs\/openapi\.json', \{[^}]*theme: theme \}/);
+  assert.doesNotMatch(r.body, /system-ui, -apple-system, Segoe UI, Roboto/, 'the old system-font bar is gone');
+  assert.doesNotMatch(r.body, /#2b6cb0|#1a1a1a/, 'no off-pack colour');
+});
+
+// ── Discord ────────────────────────────────────────────────────────────────────
+async function capture(fn, envKey) {
+  const sent = [];
+  const realFetch = globalThis.fetch;
+  const prev = process.env[envKey];
+  process.env[envKey] = 'https://discord.example/api/webhooks/1/x';
+  globalThis.fetch = async (url, init) => { sent.push(JSON.parse(init.body)); return { ok: true, status: 200, json: async () => ({ id: '1' }), text: async () => '' }; };
+  try { await fn(); } finally {
+    globalThis.fetch = realFetch;
+    if (prev === undefined) delete process.env[envKey]; else process.env[envKey] = prev;
+  }
+  return sent;
+}
+
+test('a Discord broadcast is an embed in the pack\'s accent (a sample post)', async () => {
+  const accent = parseInt(BRAND.theme.colors.accent.slice(1), 16);
+  const sample = webhook.embedBody('**Shipped:** the status page now matches the hall.');
+  assert.deepEqual(sample, {
+    embeds: [{ description: '**Shipped:** the status page now matches the hall.', color: accent }],
+    allowed_mentions: { parse: [] },
+  });
+  assert.equal(webhook.embedBody('x', { theme: { colors: { accent: 'not-a-colour' } } }).embeds[0].color, undefined, 'no bar rather than a wrong one');
+  assert.equal(webhook.embedBody('y'.repeat(5000)).embeds[0].description.length, 4096);
+
+  const [moduleBody] = await capture(() => webhook.postWebhook('ship_news', 'shipped'), 'DISCORD_SHIP_NEWS_WEBHOOK');
+  assert.deepEqual(moduleBody, { embeds: [{ description: 'shipped', color: accent }], allowed_mentions: { parse: [] } });
+  const [coreBody] = await capture(() => discordLib.postWebhook('ship_news', 'shipped'), 'DISCORD_SHIP_NEWS_WEBHOOK');
+  assert.deepEqual(coreBody, moduleBody, 'the core twin posts the same embed');
+});
+
+// ── the portable landing names no maker ─────────────────────────────────────────
+test('the landing names its maker only from the pack, and drops the band when there is none', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'public-landing', 'public', 'index.html'), 'utf8');
+  const code = src.replace(/<!--(?!\/?brand-if)[\s\S]*?-->/g, '').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(code, /Verro|VERRO/, 'no maker\'s name written into the portable page');
+  const stamp = (name) => applyBrandTokens(src, { identity: { productName: 'Acme', worldName: 'Acme', company: { name, site: '', tagline: '' } } }, '', '', '', '', '');
+  const named = stamp('Rocket Labs');
+  assert.ok(named.includes('<p class="wordmark">Rocket Labs</p>'));
+  assert.ok(named.includes('Built by Rocket Labs, Acme is our way'));
+  assert.ok(named.includes('held by Rocket Labs or its pilot clients'));
+  const none = stamp('');
+  assert.doesNotMatch(none, /class="wrap verro"|held by|Built by ,/, 'the band and the line drop whole');
+});

package/tests/bulk_toolbar.mjs

@@ -46,7 +46,7 @@ function stubPage(present) {
   const els = {};
   for (const id of present) els[id] = { hidden: true, disabled: false, textContent: '', title: '', listeners: {}, addEventListener(t, fn) { this.listeners[t] = fn; } };
   globalThis.document = { getElementById: (id) => els[id] || null };
-  globalThis.window = { confirm: () => true };
+  globalThis.window = { OTBDialog: { confirm: async () => true } }; // the branded confirm (task 1005085)
   globalThis.location = loc;
   return els;
 }

package/tests/discord_board_broadcast.mjs

@@ -132,16 +132,29 @@ test('the emitter fires on FRESH opens only, and the listener is registered (sou
   assert.ok(manifest.consumes.includes('government'), 'the port consumption is declared');
 });
 
-test('#871 survives: the mention poster keeps parse:[] and rings only the explicit allowlist', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'modules', 'discord', 'webhook.js'), 'utf8');
-  const block = src.slice(src.indexOf('async function postWebhookMentions'));
-  assert.match(block, /postCore\(channel, text, \{ parse: \[\], users \}\)/,
-    'content can never ping on its own — only the server-resolved ids ring');
-  const plain = src.slice(src.indexOf('async function postWebhook('), src.indexOf('async function postWebhookMentions'));
-  assert.match(plain, /postCore\(channel, text, \{ parse: \[\] \}\)/,
-    'the default poster stays fully suppressed — #871 verbatim');
-  assert.match(block, /slice\(0, 20\)/, 'the allowlist is sanity-bounded');
-  assert.match(block, /\^\\d\+\$/, 'only numeric snowflake ids survive the filter');
+test('#871 survives: the mention poster keeps parse:[] and rings only the explicit allowlist', async () => {
+  // Drive the two posters against a stubbed fetch and read the bodies they send
+  // (task 1005091 moved the plain poster onto an embed; the rule did not move).
+  const sent = [];
+  const realFetch = globalThis.fetch;
+  const prev = process.env.DISCORD_BOARD_ROOM_WEBHOOK;
+  process.env.DISCORD_BOARD_ROOM_WEBHOOK = 'https://discord.example/api/webhooks/1/x';
+  globalThis.fetch = async (url, init) => { sent.push(JSON.parse(init.body)); return { ok: true, status: 200, json: async () => ({ id: '9' }) }; };
+  try {
+    await webhook.postWebhookMentions('board_room', 'vote <@1> @everyone', ['111', '222', 'not-an-id', ...Array.from({ length: 30 }, (_, i) => String(1000 + i))]);
+    await webhook.postWebhook('board_room', 'plain @everyone');
+  } finally {
+    globalThis.fetch = realFetch;
+    if (prev === undefined) delete process.env.DISCORD_BOARD_ROOM_WEBHOOK; else process.env.DISCORD_BOARD_ROOM_WEBHOOK = prev;
+  }
+  const [ring, plain] = sent;
+  assert.deepEqual(ring.allowed_mentions.parse, [], 'content can never ping on its own — only the server-resolved ids ring');
+  assert.equal(ring.content, 'vote <@1> @everyone', 'the mention post stays message text, so its ids can ring');
+  assert.equal(ring.allowed_mentions.users.length, 20, 'the allowlist is sanity-bounded');
+  assert.ok(ring.allowed_mentions.users.every((u) => /^\d+$/.test(u)), 'only numeric snowflake ids survive the filter');
+  assert.deepEqual(plain.allowed_mentions, { parse: [] }, 'the default poster stays fully suppressed — #871 verbatim');
+  assert.equal(plain.content, undefined, 'the default poster sends an embed, not message text');
+  assert.equal(plain.embeds[0].description, 'plain @everyone');
   assert.ok(webhook.CHANNELS.has('board_room'), 'the channel key exists');
 });
 

package/tests/docs_openapi_route.mjs

@@ -67,7 +67,8 @@ test('/docs Redoc page points at the same-origin spec URL it now always serves',
     const res = await fetch(base + '/docs');
     assert.equal(res.status, 200);
     const html = await res.text();
-    assert.match(html, /spec-url="\/docs\/openapi\.json"/, 'Redoc host page fetches /docs/openapi.json');
+    // task 1005091: Redoc is started by Redoc.init with the page's theme, so the URL is its first argument
+    assert.match(html, /Redoc\.init\('\/docs\/openapi\.json'/, 'Redoc host page fetches /docs/openapi.json');
   });
 });
 

package/tests/hall_approval_queue.mjs

@@ -90,6 +90,9 @@ function bootPanel({ answers = {}, writes = null, mode = 'light' } = {}) {
     getElementById: byId,
     createElement: (tag) => augment(makeEl(tag, {})),
     get activeElement() { return boot.focused || null; },
+    // the shared dialog (hall-dialog.js, task 1005085) hears its keys on the document
+    listeners: {},
+    addEventListener(type, fn) { (this.listeners[type] = this.listeners[type] || []).push(fn); },
   };
   const api = {
     // The REAL client's shape: request(method, path, { body }). This fake once
@@ -110,6 +113,7 @@ function bootPanel({ answers = {}, writes = null, mode = 'light' } = {}) {
   win.window = win;
   vm.runInContext(read('brand-holes.js'), ctx, { filename: 'brand-holes.js' });
   vm.runInContext(read('approval-queue-lib.js'), ctx, { filename: 'approval-queue-lib.js' });
+  vm.runInContext(read('hall-dialog.js'), ctx, { filename: 'hall-dialog.js' }); // the shared dialog behaviour (task 1005085)
   vm.runInContext(read('approval-queue.js'), ctx, { filename: 'approval-queue.js' });
   const panel = win.OTBApprovalQueue.mount({
     api,
@@ -124,7 +128,9 @@ function bootPanel({ answers = {}, writes = null, mode = 'light' } = {}) {
   const q = (sel) => scrim.querySelector(sel);
   const qa = (sel) => scrim.querySelectorAll(sel);
   const click = async (el) => { assert.ok(el, 'the control exists'); scrim.fire('click', { target: el }); await settle(); await settle(); };
-  boot = { body, scrim, q, qa, click, requests, counts, panel, classes, win, focused: null };
+  boot = { body, scrim, q, qa, click, requests, counts, panel, classes, win, focused: null,
+    // a key pressed anywhere in the page reaches the document, where the shared dialog listens
+    key: (ev) => (documentObj.listeners.keydown || []).forEach((fn) => fn({ preventDefault() {}, stopPropagation() {}, ...ev })) };
   return boot;
 }
 
@@ -330,7 +336,7 @@ await test('empty, closed with Escape, and focus goes back where it was', async
   await b.panel.open(); await settle();
   assert.equal(text(b.q('.aq-title')), 'Nothing waiting');
   assert.match(text(b.q('.aq-frame__note')), /Nothing is waiting for you/);
-  b.scrim.fire('keydown', { key: 'Escape', preventDefault() {}, target: b.scrim });
+  b.key({ key: 'Escape', target: b.scrim });
   assert.equal(b.scrim.hidden, true);
   assert.equal(b.focused, opener);
   assert.ok(!b.classes.has('aq-open'));

package/tests/hall_audit.mjs

@@ -510,7 +510,7 @@ test('the verdict classes and the scrim exist in the token tier, in both modes',
   assert.match(css, /\.ledger__verdict--danger\s*\{[^}]*var\(--danger\)/, 'fell short → --danger');
   assert.match(css, /\.ledger__verdict--none\s*\{[^}]*var\(--ink-soft\)/, 'not graded → --ink-soft');
   assert.match(css, /--scrim:/, 'the modal scrim is a token, not a sheet-local literal');
-  assert.match(read('copy-desk.css'), /::backdrop\s*\{[^}]*var\(--scrim\)/, 'the copy-desk backdrop takes it');
+  assert.match(read('controls.css'), /\.hall-dialog::backdrop \{ background: var\(--scrim\); \}/, 'the one dialog backdrop takes it (task 1005085)');
 });
 
 // ---- 10. an outline: none always names its replacement (task 1003496) -----

package/tests/hall_city.mjs

@@ -288,7 +288,7 @@ test('the city sits in the hall chrome, behind the shell\'s full-screen switch',
   // task 1004685 (the living city): gov-living.js, the model under the drawing, and
   // gov-feeds.js, its one reader per page (shared with the shell's tally), load before it
   // task 1004702: the card answers its first ask in place, so the deck's card and sender (and the desk rows under them) load before the page
-  assert.deepEqual(scripts, ['dom-utils', 'shell-trail', 'craft-mode', 'shell', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, as on every hall page');
+  assert.deepEqual(scripts, ['dom-utils', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, then the shared dialog (task 1005085), as on every hall page');
   // task 1004925: every script but dom-utils.js is deferred, so none holds up the
   // parser; defer runs them in document order, which is why the order above still
   // holds. dom-utils.js stays synchronous: the one-escaper guard

package/tests/hall_collab_world.mjs

@@ -53,7 +53,9 @@ test('the page sheets spend only the fifteen, in px, and never opacity', () => {
   const cd = read('copy-desk.css');
   const literals = cd.match(/rgba?\([^)]*\)/g) || [];
   assert.deepEqual(literals, [], 'not even the scrim is a literal here any more');
-  assert.match(cd, /\.cd-dialog::backdrop \{ background: var\(--scrim\); \}/, 'the backdrop spends the token');
+  // task 1005085: the dialogs are the hall's one dialog, whose backdrop lives in controls.css
+  assert.doesNotMatch(cd, /::backdrop/, 'no backdrop of its own');
+  assert.match(read('controls.css'), /\.hall-dialog::backdrop \{ background: var\(--scrim\); \}/, 'the shared backdrop spends the token');
 });
 
 test('every list is the family\'s row, and the card-in-a-card is gone', () => {
@@ -335,15 +337,16 @@ test('the filters and the search are the kit\'s bar; the duplicates are paged th
   assert.match(read('copy-desk.html'), /src="\/builders\/hall-kit\.js/, 'the page loads the kit');
 });
 
-test('the three dialogs are the family modal on a native <dialog>, with the number input in a field', () => {
+test('the three dialogs are the hall\'s one dialog on a native <dialog>, with the number input in a field', () => {
   const html = read('copy-desk.html');
-  // Three since task 1003114 (R03): flag, close, and the proposal composer.
-  assert.equal((html.match(/<dialog id="cd-(close-dialog|dialog|propose-dialog)" class="ov-modal cd-dialog">/g) || []).length, 3);
+  // Three since task 1003114 (R03): flag, close, and the proposal composer; the
+  // shared .hall-dialog since task 1005085, each named by its own title.
+  assert.equal((html.match(/<dialog id="cd-(close-dialog|dialog|propose-dialog)" class="hall-dialog cd-dialog" aria-labelledby="cd-(close|dialog|propose)-h">/g) || []).length, 3);
   assert.match(html, /<div class="ov-field ov-field--wide">\s*<label class="ov-field__l" for="cd-close-task">[^<]*<\/label>\s*<input type="number" id="cd-close-task"/, 'the number input sits in the family field, which restates the 30px pill');
   assert.ok(!/<label[^>]*>[^<]*<span class="cd-dialog__hint"/.test(html), 'no hint lives inside a label (the label voice would uppercase it)');
   assert.equal((html.match(/class="ov-form__why"/g) || []).length, 4, 'the four hints are the form\'s own explainer line');
-  assert.match(html, /class="btn-accent" id="cd-submit"/, 'the accent door files the flag');
-  assert.match(html, /class="btn-accent" id="cd-propose-submit"/, 'and the proposal composer has its own');
+  assert.match(html, /class="btn" id="cd-submit"/, 'the accent door files the flag');
+  assert.match(html, /class="btn" id="cd-propose-submit"/, 'and the proposal composer has its own');
 });
 
 test('the proposal composer is prefilled, and says what filing it does and does not do', () => {