@bongos/core 1.21.33 → 1.21.34

package/tests/hall_street_desk.mjs

@@ -0,0 +1,328 @@
+// tests/hall_street_desk.mjs — THE FLOOR DESK AND THE LINE RULE (task 1004558,
+// goal 1000125; round 2 of the Governor City).
+//
+// WHAT IT GUARDS. The chosen floor of a building is the desk from the round 2
+// board (docs/design/mocks/governor-city/Desks.dc.html), built by
+// GovDesk.deskModel() (street-desk.js) and drawn by street.js. What can go wrong:
+//   * THE LINE RULE breaking on real data: a row name over three words, a
+//     second fact, a third button, a tile that reads zero or carries a
+//     sentence, a status that is orange when nothing needs you, an empty list
+//     where a quiet floor should be one lit line. Pinned by running EVERY
+//     building and EVERY floor of a deliberately long-winded docket through
+//     GovDesk.breaks() — the test that fails when the docket produces a line
+//     the rule does not allow;
+//   * fit() drifting from the board's own fit() (run from the board's
+//     Component class) or the limits drifting from the board's numbers;
+//   * a row's button sending anything but the matter card's own request to
+//     the existing route, or a reason arriving as free text instead of a chip;
+//   * the game layer going quiet: the act that does not clear its row, count a
+//     pip on the today meter, light the cleared floor with a tick, or say a toast.
+//
+// Run:  node --test tests/hall_street_desk.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 { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const require = createRequire(import.meta.url);
+require(path.join(PUB, 'city-draw.js'));
+const S = require(path.join(PUB, 'street-draw.js'));
+const I = require(path.join(PUB, 'street-inside.js'));
+const C = require(path.join(PUB, 'street-card.js'));
+const D = require(path.join(PUB, 'street-desk.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const NOW = Date.parse('2026-10-03T12:00:00.000Z');
+const j = (v) => JSON.parse(JSON.stringify(v));
+
+// the board's own Component class, run beside the desk
+function board() {
+  const src = fs.readFileSync(path.join(ROOT, 'docs/design/mocks/governor-city/Desks.dc.html'), 'utf8');
+  const script = src.split('data-dc-script')[1].split('>').slice(1).join('>').split('</script>')[0];
+  const DCLogic = class { constructor(p) { this.props = p || {}; this.state = {}; } setState(s) { Object.assign(this.state, s); } };
+  const Comp = new Function('DCLogic', 'setTimeout', 'clearTimeout', `${script}\nreturn Component;`)(DCLogic, () => 0, () => {});
+  return new Comp({ mode: 'dark' });
+}
+
+// ── a long-winded docket: every source, long words everywhere ─────────────────
+const LONG = 'The extraordinarily long-winded proposal to reorganise every single floor of the hall before winter';
+const SOURCES = [['board', 'charter'], ['blockers', 'planning'], ['access_requests', 'people'], ['goal_join_requests', 'people'], ['override_requests', 'release'], ['removal_proposals', 'disputes'], ['redteam_reports', 'disputes'], ['criteria_uat', 'review'], ['core_update', 'release'], ['gate_approvals', 'release'], ['autobongos_fence', 'automation'], ['module_rechecks', 'release'], ['grade_appeals', 'disputes'], ['standing_rules', 'rules'], ['treasury_spending', 'treasury']];
+function matter(over = {}) {
+  return { id: 'blockers:1', source: 'blockers', building: 'planning', rule: 'majority', state: 'needs', title: 'A matter', short: 'a matter', where: 'Planning', opened_at: '2026-09-29T10:00:00.000Z', deadline: null, proposer: null, tally: null, href: null, ref: null, ...over };
+}
+function docket(matters, over = {}) {
+  const counts = { needs: 0, moving: 0, settled: 0 };
+  matters.forEach((m) => { counts[m.state] += 1; });
+  return {
+    viewer: { id: '95' }, counts, line: '', matters,
+    buildings: S.CIVIC_KEYS.map((key) => ({ key, name: key[0].toUpperCase() + key.slice(1), group: '', counts: {}, matter_ids: [] })),
+    sources: SOURCES.map(([source, building]) => ({ source, building, label: source, status: 'live', count: 0, reason: null })),
+    readings: ['flow', 'promises', 'money', 'people', 'fairness', 'rules'].map((key) => ({ key, label: key, building: 'people', status: 'live', value: 0, figure: key === 'money' ? '$1,234,567.89 left this month' : '0 people', line: LONG, hot: false, reason: null })),
+    floors: Object.values(I.PLAN).flatMap((p) => p.floors).map((f) => f[2] && f[2].floor).filter(Boolean).map((key, i) => ({ key, building: key.split('.')[0], status: 'live', count: i % 3 === 0 ? '0' : i % 3 === 1 ? '1,204,331' : '', line: i % 2 ? LONG : '12 things that the floor counts', lines: [[LONG, 'today']], hot: i % 4 === 0, reason: null })),
+    history: S.CIVIC_KEYS.flatMap((b) => [0, 1, 2, 3, 4].map((n) => ({ id: `h:${b}:${n}`, source: 'government', building: b, title: LONG, at: '2026-09-2' + n + 'T10:00:00.000Z', outcome: 'passed after a very long sitting' }))),
+    ...over,
+  };
+}
+function longMatters() {
+  const out = [];
+  let n = 0;
+  for (const [source, building] of SOURCES) {
+    for (const state of ['needs', 'moving', 'settled']) {
+      n += 1;
+      out.push(matter({ id: `${source}:${n}`, source, building, state, title: `${LONG} ${n}`, short: 'a matter with a very long short description', where: 'Somewhere far away in the hall, vouched for by everyone', proposer: { name: 'Maximiliana Theodora Alexandrovna-Wellington III', login: 'maxi' }, deadline: '2026-10-05T10:00:00.000Z', opened_at: `2026-0${(n % 9) + 1}-1${n % 9}T10:00:00.000Z`, href: source === 'goal_join_requests' ? '/builders/goal/42' : source === 'core_update' ? '/settings#software-update' : null, tally: source === 'board' ? { open: 3, needs: 'needs 4 of 5' } : null }));
+    }
+  }
+  out.push(matter({ id: 'board:900', source: 'board', building: 'planning', short: 'idea to ratify', title: LONG, state: 'needs' }));
+  return out;
+}
+const ROOM = { open: [{ id: '1', subject_type: 'constitutional_amendment', subject: { title: LONG, author_id: '7' }, votes: [] }, { id: '900', subject_type: 'full_idea', subject: { title: LONG }, votes: [] }], closed: [] };
+
+function everyDesk(dk, extra = {}) {
+  const out = [];
+  for (const key of S.CIVIC_KEYS) {
+    I.PLAN[key].floors.forEach((_f, floor) => out.push(D.deskModel({ key, floor, docket: dk, goals: [{ id: '1', title: LONG, status: 'open' }], now: NOW, room: ROOM, viewerId: '95', ...extra })));
+  }
+  return out;
+}
+
+// ── the line rule ─────────────────────────────────────────────────────────────
+
+test('fit() is the board\'s fit(), with a word cap on top', () => {
+  const b = board();
+  for (const [s, n] of [['Governor city', 20], [LONG, 20], [LONG, 44], ['Ana Ruiz', 18], ['exactly twenty chars', 20], ['  spaced   out  ', 30]]) {
+    assert.equal(D.fit(s, n), b.fit(String(s).replace(/\s+/g, ' ').trim(), n), `${s} @ ${n}`);
+  }
+  assert.equal(D.fit('Raise the hosting limit', 20, 3), 'Raise the hosting…', 'a cut by words says so');
+  assert.equal(D.fit('Ana Ruiz', 20, 3), 'Ana Ruiz', 'nothing cut, nothing marked');
+  for (const n of [5, 12, 20]) for (const w of [1, 2, 3]) assert.ok(D.fit(LONG, n, w).length <= n, 'never longer than its cap');
+});
+
+test('the limits are the board\'s numbers: name 20, fact 26, facts 24 (three), status 44, record 30 (four), three tiles, ten pips', () => {
+  const L = D.LIMITS;
+  assert.deepEqual([L.name, L.nameWords, L.fact, L.factLen, L.facts, L.actions, L.status, L.recordLen, L.record, L.tiles, L.tileWords, L.todayTarget], [20, 3, 26, 24, 3, 2, 44, 30, 4, 3, 2, 10]);
+  const src = fs.readFileSync(path.join(ROOT, 'docs/design/mocks/governor-city/Desks.dc.html'), 'utf8');
+  for (const pin of ['this.fit(r.t, 20)', 'this.fit(r.f, 26)', 'this.fit(t, 24)', '.slice(0, 3)', "this.fit('nothing needs you · ' + F.quiet, 44)", "this.fit(t + ' · now', 30)", '.slice(0, 4)', 'const target = 10']) assert.ok(src.includes(pin), `the board says ${pin}`);
+});
+
+test('THE LINE RULE: no row, tile or status any docket produces breaks it, on every floor of every building', () => {
+  const dk = docket(longMatters());
+  const desks = everyDesk(dk);
+  assert.equal(desks.length, S.CIVIC_KEYS.reduce((a, k) => a + I.PLAN[k].floors.length, 0));
+  const broken = desks.flatMap((d) => D.breaks(d));
+  assert.deepEqual(broken, []);
+  // the stress docket really reaches every part of the rule
+  const rows = desks.flatMap((d) => d.rows);
+  assert.ok(rows.length >= 30, 'rows were drawn');
+  assert.ok(rows.some((r) => r.actions.length === 2) && rows.some((r) => r.chips) && rows.some((r) => r.wait), 'two buttons, chips and a wait pill were all exercised');
+  assert.ok(desks.some((d) => d.quiet), 'a quiet floor was exercised');
+  assert.ok(desks.some((d) => d.tiles.length === 3), 'three tiles were exercised');
+  assert.ok(desks.some((d) => d.hot), 'an orange status was exercised');
+  const moving = everyDesk(docket(longMatters().filter((m) => m.state !== 'needs')));
+  assert.ok(moving.some((d) => !d.hot && d.rows.length), 'a grey status over rows was exercised');
+  assert.deepEqual(moving.flatMap((d) => D.breaks(d)), []);
+  assert.ok(rows.some((r) => r.name.endsWith('…')), 'a long title was cut, and says so');
+  // the same docket with acts done, floors cleared, and with nothing readable
+  assert.deepEqual(everyDesk(dk, { done: Object.fromEntries(dk.matters.map((m) => [m.id, true])), cleared: true, mine: [LONG, 'let in Ana'], today: 123456 }).flatMap((d) => D.breaks(d)), []);
+  assert.deepEqual(everyDesk(null).flatMap((d) => D.breaks(d)), []);
+  assert.deepEqual(everyDesk(docket([])).flatMap((d) => D.breaks(d)), []);
+});
+
+test('breaks() names every way a desk can break the rule (so the rule test can fail)', () => {
+  const dk = docket(longMatters());
+  const good = D.deskModel({ key: 'people', floor: 4, docket: dk, now: NOW });
+  assert.deepEqual(D.breaks(good), []);
+  const bad = j(good);
+  bad.rows[0].name = 'Four words in here';
+  bad.rows[0].fact = 'x'.repeat(27);
+  bad.rows[0].actions = [{ label: 'a' }, { label: 'b' }, { label: 'c' }];
+  bad.rows[0].facts = ['a', 'b', 'c', 'd'];
+  bad.tiles = [{ v: '0', l: 'need you' }, { v: '3', l: 'three whole words' }, { v: '4', l: 'ok' }, { v: '5', l: 'ok' }];
+  bad.status = 'x'.repeat(45);
+  bad.hot = false;
+  const why = D.breaks(bad).join('\n');
+  for (const w of ['row name', 'row fact', 'more than two buttons', 'row facts', 'tile value', 'tile label', 'more than three tiles', 'status too long', 'orange only when']) assert.match(why, new RegExp(w), w);
+  const empty = j(good); empty.rows = []; empty.quiet = false;
+  assert.match(D.breaks(empty).join(), /quiet and rows disagree/, 'never an empty list');
+});
+
+// ── which matters sit on which floor ──────────────────────────────────────────
+
+test('a floor holds its own source; the ideas floor holds the open ideas; the rest sit at the front desk; settled is the record', () => {
+  const ms = [
+    matter({ id: 'access_requests:1', source: 'access_requests', building: 'people', state: 'needs' }),
+    matter({ id: 'access_requests:2', source: 'access_requests', building: 'people', state: 'settled' }),
+    matter({ id: 'board:5', source: 'board', building: 'people', state: 'needs' }),
+    matter({ id: 'board:6', source: 'board', building: 'planning', short: 'idea to ratify', state: 'moving' }),
+  ];
+  const dk = docket(ms);
+  const at = (k, f) => D.floorMatters(k, f, dk).map((m) => m.id);
+  assert.deepEqual(at('people', 4), ['access_requests:1'], 'Waiting to join: the open request only');
+  assert.deepEqual(at('people', 0), ['board:5'], 'a sitting sits at the front desk');
+  assert.deepEqual(at('planning', 2), ['board:6'], 'Ideas to ratify');
+  assert.deepEqual(at('planning', 0), [], 'an idea is not also at the front desk');
+  assert.equal(D.firstNeeds('people', dk), 0);
+  assert.equal(D.firstNeeds('rules', dk), null);
+});
+
+// ── the acts are the card's own requests ──────────────────────────────────────
+
+test('a row\'s buttons are the card\'s acts under the board\'s words, and send the card\'s own request', () => {
+  const ms = [
+    matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 } }),
+    matter({ id: 'goal_join_requests:12', source: 'goal_join_requests', building: 'people', state: 'needs', proposer: { name: 'Kai Mo' }, href: '/builders/goal/42', ref: { id: 12 } }),
+    matter({ id: 'override_requests:13', source: 'override_requests', building: 'release', state: 'needs', ref: { id: 13 } }),
+    matter({ id: 'gate_approvals:14', source: 'gate_approvals', building: 'release', state: 'needs', ref: { id: 14 } }),
+    matter({ id: 'board:1', source: 'board', building: 'charter', state: 'needs', ref: { type: 'board_item', id: '1' } }),
+  ];
+  const dk = docket(ms);
+  const row = (k, f) => D.rowsFor(k, f, dk, { room: ROOM, now: NOW, viewerId: '95' })[0];
+  const ana = row('people', 4);
+  assert.equal(ana.name, 'Ana Ruiz', 'a person is named by their name');
+  assert.deepEqual(ana.actions.map((a) => [a.key, a.label, a.tone]), [['fine', 'let in', 'primary'], ['refuse', 'not now', 'quiet']]);
+  assert.deepEqual(j(C.request(ana.card, 'fine')), { method: 'PATCH', url: '/api/bongos/access-requests/11', body: { status: 'invited' } });
+  assert.deepEqual(j(C.request(row('people', 6).card, 'refuse')), { method: 'POST', url: '/api/bongos/goals/42/requests/12/respond', body: { action: 'deny' } });
+  const rel = D.rowsFor('release', 0, dk, { now: NOW });
+  assert.deepEqual(rel[0].actions.map((a) => a.label), ['release', 'hold']);
+  assert.equal(C.request(rel[0].card, 'release').url, '/api/bongos/override-requests/13/decide');
+  assert.equal(C.request(D.rowsFor('release', 5, dk, { now: NOW })[0].card, 'release').url, '/api/bongos/gate-approvals/14/approve');
+  // a vote: yes and no, and the no's reason is a chip, never free text
+  const vote = row('charter', 0);
+  assert.deepEqual(vote.actions.map((a) => [a.key, a.label]), [['for', 'yes'], ['object', 'no']]);
+  assert.equal(vote.chips.for, 'object');
+  assert.deepEqual(vote.chips.options.map((c) => c.key), C.SECTIONS.map((s) => s.key), 'every chip is a section the server accepts');
+  const chip = vote.chips.options[0];
+  assert.equal(C.check(vote.card, 'object', chip.input), null, 'one tap is a complete objection');
+  assert.deepEqual(j(C.request(vote.card, 'object', chip.input).body), { direction: 'no', reason_md: chip.input.reason, section_key: 'scope' });
+  // before the sitting is read the row waits, never guesses a ballot
+  assert.equal(D.rowsFor('charter', 0, dk, { now: NOW })[0].wait, 'reading…');
+});
+
+// ── the page: the desk acts in place, and the game layer answers ──────────────
+
+function fakeDom() {
+  const byId = new Map();
+  const focused = { el: null };
+  const mk = (tag) => ({
+    tagName: tag, attrs: {}, kids: [], className: '', listeners: {}, _text: '', hidden: false,
+    style: { setProperty(k, v) { this[k] = v; } },
+    clientWidth: 1440, clientHeight: 708, offsetLeft: 0, scrollLeft: 0, parentNode: null,
+    get children() { const a = this.kids.slice(); a[Symbol.isConcatSpreadable] = false; return a; },
+    get firstChild() { return this.kids[0] || null; },
+    setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'id') byId.set(String(v), this); },
+    getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+    appendChild(c) { this.kids.push(c); c.parentNode = this; return c; },
+    removeChild(c) { this.kids = this.kids.filter((x) => x !== c); return c; },
+    addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+    fire(t) { (this.listeners[t] || []).forEach((fn) => fn({ type: t, preventDefault() {} })); },
+    focus() { focused.el = this; },
+    set textContent(v) { this._text = String(v); this.kids = []; },
+    get textContent() { return this._text; },
+    get innerHTML() { throw new Error('no innerHTML'); },
+    set innerHTML(v) { throw new Error('no innerHTML'); },
+  });
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  for (const id of [...html.matchAll(/id="([A-Za-z]+)"/g)].map((m) => m[1])) {
+    const el = mk('x');
+    el.setAttribute('id', id);
+    const tag = new RegExp(`<[^>]*\\bid="${id}"[^>]*>`).exec(html);
+    if (tag && /\shidden(?=[\s>])/.test(tag[0])) el.hidden = true;
+  }
+  return { document: { documentElement: mk('html'), getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_n, t) => mk(t) }, byId, focused };
+}
+async function bootPage(hash, ms, { refuse = false } = {}) {
+  const { document, byId, focused } = fakeDom();
+  const sent = [];
+  const store = new Map();
+  let matters = ms.slice();
+  const feeds = () => ({ '/api/bongos/government/docket': docket(matters), '/api/bongos/goals': { goals: [] }, '/api/bongos/goals/rollups': { rollups: [] } });
+  const location = { hash, href: '' };
+  const window = {
+    innerWidth: 1440, innerHeight: 900, location,
+    localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) },
+    matchMedia: () => ({ matches: true, addEventListener() {} }),
+    addEventListener() {}, history: { pushState() {} },
+  };
+  const fetch = (url, init) => {
+    if (init && init.method && init.method !== 'GET') {
+      sent.push({ method: init.method, url, body: JSON.parse(init.body || '{}') });
+      if (refuse) return Promise.resolve({ ok: false, status: 409, json: async () => ({ error: { code: 'not_pending' } }) });
+      matters = matters.filter((m) => !url.includes('/' + String(m.id).split(':')[1]));
+      return Promise.resolve({ ok: true, status: 200, json: async () => ({ ok: true }) });
+    }
+    const body = feeds()[url];
+    return Promise.resolve(body === undefined ? { ok: false, json: async () => ({}) } : { ok: true, json: async () => body });
+  };
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map, Set });
+  ctx.globalThis = ctx;
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street.js']) vm.runInContext(read(f), ctx);
+  await window.GovStreetPage.ready;
+  await new Promise((r) => setTimeout(r, 0));
+  const deskEl = () => (byId.get('insideOpenA').hidden ? byId.get('insideOpenB') : byId.get('insideOpenA'));
+  const part = (cls) => deskEl().children.find((c) => c.className.split(' ').includes(cls));
+  return { window, byId, focused, sent, store, deskEl, part };
+}
+
+test('the page: the desk acts in place — the row clears, the floor lights with a tick, the meter takes a pip, the toast speaks', async () => {
+  const ms = [matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 }, opened_at: '2026-10-01T12:00:00.000Z' })];
+  const p = await bootPage('#building=people', ms);
+  const html = read('street.html');
+  assert.ok(html.indexOf('/builders/street-desk.js?') > html.indexOf('/builders/street-inside.js?') && html.indexOf('/builders/street-desk.js?') < html.indexOf('/builders/street.js?'), 'the desk loads after the interior and before the page');
+  assert.equal(p.byId.get('insideFloors').children[4].attrs['aria-pressed'], 'true', 'the building opens on the floor that needs you');
+  const head = p.deskEl().children[0].children[1];
+  assert.deepEqual([head.children[1].textContent, head.children[2].textContent, head.children[2].className], ['Waiting to join', '1 waiting · oldest 2 days', 'desk-status desk-status--hot']);
+  assert.deepEqual(p.part('desk-tiles').children.map((t) => [t.children[0].textContent, t.children[1].textContent]), [['1', 'waiting'], ['5', 'on record']], 'the first tile is the count in the floor noun, as on the board; a zero tile (nothing moving) is hidden');
+  const row = p.part('desk-rows').children[0];
+  const name = row.children[0].children[1];
+  assert.equal(name.children[0].textContent, 'Ana Ruiz');
+  name.fire('click');
+  const opened = p.part('desk-rows').children[0];
+  assert.equal(opened.children[0].children[1].attrs['aria-expanded'], 'true');
+  assert.ok(opened.children[1].children.length >= 1 && opened.children[1].children.length <= 3, 'at most three facts open in place');
+  const acts = opened.children[0].children[2].children;
+  assert.deepEqual(acts.map((b) => b.textContent), ['not now', 'let in'], 'the primary sits rightmost');
+  acts[1].fire('click');
+  for (let i = 0; i < 5; i++) await new Promise((r) => setTimeout(r, 0));
+  assert.deepEqual(p.sent, [{ method: 'PATCH', url: '/api/bongos/access-requests/11', body: { status: 'invited' } }], 'the card\'s own route, nothing else');
+  assert.match(p.byId.get('streetToast').textContent, /Ana Ruiz is invited in/);
+  assert.equal(p.byId.get('streetToast').hidden, false);
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+  assert.equal(p.byId.get('streetTodayPips').children.filter((x) => x.className.includes('--on')).length, 1, 'one pip per decision');
+  assert.equal(JSON.parse(p.store.get('gov-desk-today')).n, 1, 'the day keeps its count');
+  const quiet = p.part('desk-quiet');
+  assert.ok(quiet && quiet.className.includes('desk-quiet--cleared'), 'a cleared floor is one lit line, never an empty list');
+  assert.deepEqual(quiet.children.slice(1).map((x) => x.textContent), ['Everyone is in', 'lit up · 1 decided today']);
+  assert.equal(p.part('desk-rows'), undefined);
+  assert.equal(p.part('desk-record').children[1].textContent, 'let in Ana Ruiz · now', 'the record line starts with what you did');
+  assert.equal(p.byId.get('insideFloors').children[4].attrs['aria-pressed'], 'true', 'you stay on the floor you cleared');
+  // the drawing: the cleared floor's windows lit and its tick drawn
+  const bv = I.buildingModel({ key: 'people', docket: docket([]), goals: [], mode: 'dark', now: NOW, floor: 4, cleared: [4] });
+  const plain = I.buildingModel({ key: 'people', docket: docket([]), goals: [], mode: 'dark', now: NOW, floor: 0 });
+  assert.ok(bv.shapes.some((s) => /l6 6 12-13$/.test(s.d)), 'a tick on the cleared floor');
+  assert.ok(!plain.shapes.some((s) => /l6 6 12-13$/.test(s.d)), 'no tick on a floor nobody cleared');
+});
+
+test('the page: a refused act keeps the row and says why; no pip is counted', async () => {
+  const ms = [matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 } })];
+  const p = await bootPage('#building=people', ms, { refuse: true });
+  p.part('desk-rows').children[0].children[0].children[2].children[1].fire('click');
+  for (let i = 0; i < 5; i++) await new Promise((r) => setTimeout(r, 0));
+  assert.equal(p.byId.get('streetToast').textContent, 'Someone already decided this.');
+  assert.equal(p.part('desk-rows').children.length, 1);
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+});
+
+test('the stylesheet: the desk in tokens only, its motion dies under reduced motion, the chips clear 24px', () => {
+  const css = read('street.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  const desk = css.split('\n').filter((l) => /^\.(desk|street-today)/.test(l)).join('\n');
+  assert.ok(desk.length > 0);
+  assert.doesNotMatch(desk, /#[0-9a-f]{3,8}\b|rgba?\(/i, 'no literal colours on the desk');
+  assert.match(css, /\.desk-chip \{[^}]*height: 34px/);
+  assert.match(css, /\.desk-row--gone \{[^}]*animation: desk-gone/);
+  assert.match(css, /@media \(prefers-reduced-motion: reduce\) \{[^}]*animation: none !important; transition: none !important;/);
+  assert.match(read('street.html'), /id="streetTodayPips"/);
+});

package/tests/hall_street_inside.mjs

@@ -508,7 +508,7 @@ async function bootPage({ hash = '', feeds = {}, innerWidth = 1440 } = {}) {
   };
   const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map });
   ctx.globalThis = ctx;
-  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street.js']) vm.runInContext(read(f), ctx);
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street.js']) vm.runInContext(read(f), ctx);
   await window.GovStreetPage.ready;
   await new Promise((r) => setTimeout(r, 0));
   const fireWin = (t, e) => (listeners[t] || []).forEach((fn) => fn(e));