@bongos/core 1.21.53 → 1.21.54

package/tests/hall_street_desk.mjs

@@ -271,26 +271,33 @@ function fakeDom() {
   }
   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, over = {} } = {}) {
+// xhr: an XMLHttpRequest stand-in (the recorded sign-off's upload); answer(url,
+// body): a response of its own for a write, else the default; extra: more feeds
+async function bootPage(hash, ms, { refuse = false, over = {}, xhr = null, answer = null, extra = {} } = {}) {
   const { document, byId, focused } = fakeDom();
   const sent = [];
   const store = new Map();
   let matters = ms.slice();
-  const feeds = () => ({ '/api/bongos/government/docket': docket(matters, over), '/api/bongos/goals': { goals: [] }, '/api/bongos/goals/rollups': { rollups: [] } });
+  const feeds = () => ({ '/api/bongos/government/docket': docket(matters, over), '/api/bongos/goals': { goals: [] }, '/api/bongos/goals/rollups': { rollups: [] }, ...extra });
+  const reads = [];
   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() {} },
+    XMLHttpRequest: xhr || undefined,
   };
   const fetch = (url, init) => {
     if (init && init.method && init.method !== 'GET') {
       sent.push({ method: init.method, url, body: JSON.parse(init.body || '{}') });
+      const own = answer ? answer(url, JSON.parse(init.body || '{}')) : null;
+      if (own) return Promise.resolve({ ok: own.status < 300, status: own.status, json: async () => own.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 }) });
     }
+    reads.push(url);
     const body = feeds()[url];
     return Promise.resolve(body === undefined ? { ok: false, json: async () => ({}) } : { ok: true, json: async () => body });
   };
@@ -301,7 +308,7 @@ async function bootPage(hash, ms, { refuse = false, over = {} } = {}) {
   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 };
+  return { window, byId, focused, sent, store, deskEl, part, reads };
 }
 
 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 () => {
@@ -490,13 +497,16 @@ test('Automation: switch on and off, allow a goal from the open goals, first in
   assert.ok(!none.some((r) => r.actions.some((a) => a.key === 'allow')));
 });
 
-test('Review: a backend-only promise signs off in one tap; a recorded one goes to its page; force sign-off only with its atom', () => {
+test('Review: a backend-only promise signs off in one tap; a recorded one is recorded in place; force sign-off only with its atom', () => {
   const rows = actedRows(actedDocket(), 'review', 1);
   const backend = rows.find((r) => r.actions[0].key === 'signoff');
   assert.deepEqual(j(C.request(backend.card, 'signoff', backend.choices.signoff.options[0].input)), { method: 'POST', url: '/api/bongos/done-when/8/uat', body: { kind: 'backend_signoff', live_attested: true } });
   assert.deepEqual(j(C.request(backend.card, 'force', backend.choices.force.options[0].input)), { method: 'POST', url: '/api/bongos/done-when/8/satisfy', body: { override_reason: 'Signed off on the floor desk: tested by hand.' } });
   const ui = rows.find((r) => r.actions[0].key === 'record');
-  assert.equal(ui.actions[0].go, '/goals#/goal/4');
+  assert.equal(ui.actions[0].go, null, 'no link to the goal page (task 1004579)');
+  assert.equal(ui.actions[0].label, 'record it');
+  assert.deepEqual(j(ui.choices.record), { for: 'record', ask: 'the recording', file: true, options: [] }, 'it asks for the recording in place');
+  assert.ok(ui.actions.every((a) => !a.go), 'nothing on the row leaves the desk');
   const noForce = actedRows(actedDocket({ force: false }), 'review', 1);
   assert.ok(noForce.every((r) => !r.actions.some((a) => a.key === 'force')));
 });
@@ -935,3 +945,358 @@ test('walkthrough 1004531: a card act that records nothing takes no pip', async
   await settle();
   assert.equal(p.byId.get('streetTodayN').textContent, '0 decided', 'a refused act is not a decision');
 });
+
+// ── the recorded sign-off from the card (task 1004579) ───────────────────────
+// A promise that needs a recording is recorded in place: the file is picked or
+// dropped on its one line, sent with its progress on that line, then signed off
+// through the goal page's own two routes. The row clears, the meter takes a
+// pip, the toast speaks; a refused or failed upload says why on the line and
+// offers to try again, and counts nothing.
+const REC_NAME = 'uat-9-0123456789abcdef.mp4';
+const VIDEO = { name: 'walkthrough of the city.mp4', type: 'video/mp4', size: 12 * 1024 * 1024 };
+const uatMatters = () => [DK.normalizeMatter(lifeDocket.uatMatter({ id: 9, criterion_md: 'The city draws', goal_id: 4, shipped_total: 2, backend_only: false }, { force: false }), { source: 'criteria_uat', building: 'review' })];
+// an XMLHttpRequest stand-in: each send takes the next planned answer; `hold`
+// keeps it open until the test lets it go, so progress can be seen mid-flight
+function fakeXhr(plan = []) {
+  const calls = [];
+  const held = [];
+  class X {
+    constructor() { this.upload = {}; this.headers = {}; }
+    open(method, url) { this.method = method; this.url = url; }
+    setRequestHeader(k, v) { this.headers[k] = v; }
+    send(file) {
+      calls.push({ method: this.method, url: this.url, type: this.headers['Content-Type'], file, withCredentials: this.withCredentials, xhr: this });
+      const p = plan.shift() || { status: 201, body: { ok: true, recording: REC_NAME } };
+      const go = () => {
+        (p.progress || []).forEach((n) => this.upload.onprogress && this.upload.onprogress({ lengthComputable: true, loaded: n, total: 100 }));
+        if (p.status === 0) { this.onerror(); return; }
+        this.status = p.status;
+        this.responseText = JSON.stringify(p.body || {});
+        this.onload();
+      };
+      if (p.hold) held.push(go); else setTimeout(go, 0);
+    }
+  }
+  return { X, calls, held };
+}
+function walk(n, pred, out = []) {
+  if (!n) return out;
+  if (pred(n)) out.push(n);
+  (n.kids || []).forEach((k) => walk(k, pred, out));
+  return out;
+}
+const byAct = (root, act) => walk(root, (n) => n.attrs && n.attrs['data-act'] === act)[0];
+const recLine = (root) => walk(root, (n) => /\brec__line\b/.test(n.className))[0];
+const recBox = (root) => walk(root, (n) => /(^| )rec( |$)/.test(n.className))[0];
+const fileInput = (root) => walk(root, (n) => n.attrs && n.attrs.type === 'file')[0];
+function pickFile(root, file) {
+  const input = fileInput(root);
+  input.files = [file];
+  input.fire('change');
+}
+async function reviewDesk(opts = {}) {
+  const p = await bootPage('#building=review', uatMatters(), opts);
+  const row = () => p.part('desk-rows') && p.part('desk-rows').children[0];
+  return { ...p, row };
+}
+
+test('1004579 the line: what it says in each phase, in one line, with at most two chips', () => {
+  assert.deepEqual(j(C.recordLine({ phase: 'empty' })), { text: 'mp4 or webm, up to 100 MB', pct: null, busy: false, error: false, chips: [{ key: 'pick', label: 'pick or drop it' }] });
+  const picked = C.recordPick({}, VIDEO);
+  assert.equal(picked.phase, 'picked');
+  assert.deepEqual(j(C.recordLine(picked)).chips, [{ key: 'pick', label: 'pick another' }, { key: 'send', label: 'tested it live' }], 'the live attestation is the one-tap chip that sends it');
+  assert.equal(C.recordLine(picked).text, 'walkthrough of the city.mp4 · 12 MB');
+  assert.equal(C.recordLine({ file: VIDEO, phase: 'uploading', pct: 42 }).text, 'walkthrough of the city.mp4 · 42% sent');
+  assert.equal(C.recordLine({ file: VIDEO, phase: 'uploading', pct: 42 }).pct, 42);
+  assert.deepEqual(C.recordLine({ file: VIDEO, phase: 'uploading', pct: 42 }).chips, [], 'nothing to tap while it is sent');
+  assert.equal(C.recordLine({ file: VIDEO, phase: 'signing' }).text, 'walkthrough of the city.mp4 · sent, signing off…');
+  for (const st of [{ phase: 'empty' }, picked, { file: VIDEO, phase: 'uploading', pct: 99 }, { file: VIDEO, phase: 'failed', why: C.recordWhy(0, {}), retry: true }]) {
+    const ln = C.recordLine(st);
+    assert.ok(!/[\r\n]/.test(ln.text), 'one line');
+    assert.ok(ln.chips.length <= 2, 'at most two chips');
+    assert.ok(ln.chips.every((c) => c.label.length <= D.LIMITS.chip), 'each chip within the desk chip cap');
+  }
+  const long = C.recordPick({}, { name: 'a very long name for a screen recording of the whole walkthrough.webm', type: 'video/webm', size: 2048 });
+  assert.ok(C.recordLine(long).text.length <= 40, 'a long file name is cut, never wrapped');
+});
+
+test('1004579 a wrong file says why before anything is sent, and asks for another', () => {
+  const st = C.recordPick({}, { name: 'notes.pdf', type: 'application/pdf', size: 100 });
+  assert.equal(st.phase, 'failed');
+  assert.equal(st.why, 'Only an mp4 or webm video can go.');
+  assert.deepEqual(j(C.recordLine(st).chips), [{ key: 'pick', label: 'pick another' }], 'no "try again" for a file that cannot go');
+  assert.equal(C.recordPick({}, { name: 'big.mp4', type: 'video/mp4', size: C.RECORD_MAX + 1 }).why, 'Over the 100 MB cap. Record a shorter pass.');
+  assert.equal(C.recordPick({}, { name: 'empty.webm', type: 'video/webm', size: 0 }).why, 'That file is empty.');
+  assert.deepEqual(C.RECORD_TYPES, ['video/mp4', 'video/webm']);
+  const lifecycle = SRV('modules/lifecycle/criterion-uat.js');
+  assert.deepEqual(C.RECORD_TYPES.slice().sort(), Object.keys(lifecycle.EXT_BY_TYPE).sort(), 'the same types the server stores');
+  assert.equal(C.RECORD_MAX, lifecycle.MAX_RECORDING_BYTES, 'the same cap the server screens');
+});
+
+test('1004579 the routes are the goal page\'s own two: the raw video, then the sign-off with its stored name', () => {
+  const r = C.recordRoutes(9);
+  assert.equal(r.upload, '/api/bongos/done-when/9/uat/recording');
+  assert.deepEqual(j(r.signoff(REC_NAME)), { method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } });
+  const old = read('criterion-uat-ui.js');
+  assert.match(old, /\/done-when\/\$\{encodeURIComponent\(id\)\}\/uat\/recording/, 'the goal page uploads to the same route');
+  assert.match(old, /kind: backend \? 'backend_signoff' : 'uat'/, 'and signs off with the same kind');
+  const route = read('../../lifecycle/routes/criterion-uat.js');
+  assert.match(route, /router\.post\('\/done-when\/:criterionId\/uat\/recording'/);
+  assert.match(route, /router\.post\('\/done-when\/:criterionId\/uat',/);
+});
+
+test('1004579 a refusal is one short sentence a person can act on', () => {
+  const said = [
+    [413, {}],
+    [400, { error: { code: 'bad_type', message: 'A UAT recording must be an mp4 or webm video.' } }],
+    [403, { error: { code: 'signer_shipped_this_work', message: 'You shipped work linked to this criterion, so someone else has to sign it off. Any other reviewer, or the project owner, can.' } }],
+    [409, { error: { code: 'work_not_live', message: 'Some of this work is shipped but not running on the site yet.' } }],
+    [0, {}],
+    [500, { error: { code: 'uat_signoff_failed', message: 'uat_signoff_failed' } }],
+    [409, { error: { code: 'something_new', message: 'A brand new refusal from the server. With a second sentence that goes on and on.' } }],
+  ].map(([s, b]) => C.recordWhy(s, b));
+  assert.deepEqual(said, [
+    'Over the 100 MB cap. Record a shorter pass.',
+    'Only an mp4 or webm video can go.',
+    'You built this, so someone else signs it off.',
+    'It is not on the live site yet. Sign off once it is.',
+    'The upload broke off. Try again.',
+    'It did not go through. Try again.',
+    'A brand new refusal from the server.',
+  ]);
+  for (const w of said) { assert.ok(w.length <= 72, w); assert.ok(!/[\r\n]/.test(w)); }
+});
+
+test('1004579 recordRun: sends the video with its progress, then signs off with the stored name', async () => {
+  const st = C.recordPick({}, VIDEO);
+  const phases = [];
+  const pcts = [];
+  const sent = [];
+  const out = await C.recordRun('9', st, {
+    upload: async (url, file, onPct) => { assert.equal(url, '/api/bongos/done-when/9/uat/recording'); assert.equal(file, VIDEO); onPct(30); onPct(80); return { ok: true, status: 201, body: { recording: REC_NAME } }; },
+    send: async (req) => { sent.push(j(req)); return { ok: true, status: 201, body: { ok: true, criterion_closed: true } }; },
+    change: (s) => phases.push(s.phase),
+    progress: (s) => pcts.push(s.pct),
+  });
+  assert.equal(out.ok, true);
+  assert.deepEqual(phases, ['uploading', 'signing']);
+  assert.deepEqual(pcts, [30, 80]);
+  assert.deepEqual(sent, [{ method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } }]);
+  assert.equal(st.phase, 'done');
+});
+
+test('1004579 recordRun: a failed upload says why and offers to try again; a refused sign-off keeps the upload, so trying again does not send the video twice', async () => {
+  const st = C.recordPick({}, VIDEO);
+  let uploads = 0;
+  const broke = await C.recordRun('9', st, { upload: async () => { uploads += 1; return { ok: false, status: 0, body: {} }; }, send: async () => assert.fail('no sign-off after a failed upload') });
+  assert.equal(broke.ok, false);
+  assert.equal(st.phase, 'failed');
+  assert.equal(C.recordLine(st).text, 'The upload broke off. Try again.');
+  assert.deepEqual(C.recordLine(st).chips.map((c) => c.label), ['try again', 'pick another']);
+  let signs = 0;
+  const refused = await C.recordRun('9', st, {
+    upload: async () => { uploads += 1; return { ok: true, status: 201, body: { recording: REC_NAME } }; },
+    send: async () => { signs += 1; return signs === 1 ? { ok: false, status: 409, body: { error: { code: 'work_not_live', message: 'x' } } } : { ok: true, status: 201, body: {} }; },
+  });
+  assert.equal(refused.ok, false);
+  assert.equal(C.recordLine(st).text, 'It is not on the live site yet. Sign off once it is.');
+  assert.equal(st.recording, REC_NAME, 'the stored recording is kept');
+  const again = await C.recordRun('9', st, { upload: async () => assert.fail('the video is not sent twice'), send: async () => { signs += 1; return { ok: true, status: 201, body: {} }; } });
+  assert.equal(again.ok, true);
+  assert.equal(uploads, 2);
+  // a refusal no new try can fix offers neither a retry nor (for a sign-off that is not yours) another file
+  const mine = C.recordPick({}, VIDEO);
+  await C.recordRun('9', mine, { upload: async () => ({ ok: true, status: 201, body: { recording: REC_NAME } }), send: async () => ({ ok: false, status: 403, body: { error: { code: 'signer_shipped_this_work' } } }) });
+  assert.deepEqual(C.recordLine(mine).chips, [], 'you built it: nothing to tap but close');
+  assert.equal(C.recordLine(mine).text, 'You built this, so someone else signs it off.');
+  // a file the server refused asks for another file, not the same one again
+  const odd = C.recordPick({}, VIDEO);
+  await C.recordRun('9', odd, { upload: async () => ({ ok: false, status: 400, body: { error: { code: 'sniff_mismatch' } } }), send: async () => assert.fail() });
+  assert.deepEqual(C.recordLine(odd).chips.map((c) => c.key), ['pick']);
+});
+
+test('1004579 uploadXhr: the raw file with its type, its progress, and the answer', async () => {
+  const x = fakeXhr([{ status: 201, body: { ok: true, recording: REC_NAME }, progress: [25, 50, 100] }]);
+  const pcts = [];
+  const out = await C.uploadXhr(x.X, '/api/bongos/done-when/9/uat/recording', VIDEO, (p) => pcts.push(p));
+  assert.deepEqual(out, { ok: true, status: 201, body: { ok: true, recording: REC_NAME } });
+  assert.deepEqual(x.calls.map((c) => [c.method, c.url, c.type, c.file === VIDEO, c.withCredentials]), [['POST', '/api/bongos/done-when/9/uat/recording', 'video/mp4', true, true]]);
+  assert.deepEqual(pcts, [25, 50, 99], 'the bar stops short of full until the server has answered');
+  const broke = await C.uploadXhr(fakeXhr([{ status: 0 }]).X, '/u', VIDEO, () => {});
+  assert.deepEqual(broke, { ok: false, status: 0, body: {} });
+  const none = await C.uploadXhr(undefined, '/u', VIDEO, () => {});
+  assert.equal(none.ok, false, 'no XMLHttpRequest: a failure, never a throw');
+});
+
+test('1004579 the page: record it opens its line in place, the upload shows its progress, and the sign-off clears the row', async () => {
+  const x = fakeXhr([{ status: 201, body: { ok: true, recording: REC_NAME }, hold: true }]);
+  const p = await reviewDesk({ xhr: x.X });
+  assert.equal(p.byId.get('insideFloors').children[1].attrs['aria-pressed'], 'true', 'Review opens on the promises waiting for a tester');
+  const acts = p.row().children[0].children[2].children;
+  assert.deepEqual(acts.map((b) => b.textContent), ['record it']);
+  assert.ok(walk(p.deskEl(), (n) => n.tagName === 'a').length === 0, 'no link on the desk');
+  acts[0].fire('click');
+  const strip = p.row().children[1];
+  assert.equal(strip.className, 'desk-choices');
+  assert.equal(strip.children[0].textContent, 'the recording');
+  assert.equal(recLine(strip).textContent, 'mp4 or webm, up to 100 MB');
+  assert.equal(fileInput(strip).attrs.accept, 'video/mp4,video/webm');
+  pickFile(strip, VIDEO);
+  assert.equal(recLine(p.row()).textContent, 'walkthrough of the city.mp4 · 12 MB');
+  const go = byAct(p.row(), 'record-send');
+  assert.equal(go.textContent, 'tested it live');
+  assert.equal(p.focused.el, go, 'focus moves to the chip that sends it');
+  go.fire('click');
+  await settle();
+  assert.equal(x.calls.length, 1, 'the video went up');
+  assert.match(recLine(p.row()).textContent, /0% sent$/);
+  const line = recLine(p.row());
+  x.held.shift()();
+  await settle();
+  assert.equal(p.sent.length, 1, 'then the sign-off');
+  assert.deepEqual(p.sent[0], { method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } });
+  await new Promise((r) => setTimeout(r, 360));
+  await settle();
+  assert.equal(p.part('desk-rows'), undefined, 'the row cleared away');
+  assert.ok(p.part('desk-quiet').className.includes('desk-quiet--cleared'), 'the floor lights');
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided', 'the meter takes a pip');
+  assert.equal(p.byId.get('streetToast').textContent, 'Signed off with the recording. The promise counts as kept.');
+  assert.match(p.byId.get('streetToast').className, /street-toast--desk/);
+  assert.equal(p.part('desk-record').children[1].textContent, 'signed off The city dra… · now', 'the record gains the line (cut at the record cap)');
+  assert.ok(line, 'the line was drawn while it was sent');
+});
+
+test('1004579 the page: progress is painted on the line in place while the video is sent', async () => {
+  const x = fakeXhr([{ status: 201, body: { ok: true, recording: REC_NAME }, hold: true }]);
+  const p = await reviewDesk({ xhr: x.X });
+  p.row().children[0].children[2].children[0].fire('click');
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  const line = recLine(p.row());
+  const fill = walk(p.row(), (n) => n.className === 'rec__fill')[0];
+  assert.ok(walk(p.row(), (n) => /\brec--busy\b/.test(n.className))[0], 'the line reads as busy while it is sent');
+  assert.equal(fileInput(p.row()), undefined, 'no file chip while it is sent');
+  assert.equal(line.textContent, 'walkthrough of the city.mp4 · 0% sent');
+  assert.equal(fill.style.width, '0%');
+  // the open request reports progress through its own upload hook
+  x.calls[0].xhr.upload.onprogress({ lengthComputable: true, loaded: 42, total: 100 });
+  assert.equal(recLine(p.row()), line, 'the same line node: progress never redraws the desk');
+  assert.equal(line.textContent, 'walkthrough of the city.mp4 · 42% sent');
+  assert.equal(fill.style.width, '42%', 'the bar fills');
+  x.calls[0].xhr.upload.onprogress({ lengthComputable: true, loaded: 100, total: 100 });
+  assert.equal(line.textContent, 'walkthrough of the city.mp4 · 99% sent', 'never full before the server answers');
+  x.held.shift()();
+  await settle();
+  assert.equal(p.sent.length, 1, 'the sign-off follows the upload');
+});
+
+test('1004579 the page: a refused upload says why on the line, keeps the row, counts nothing, and lets them try again', async () => {
+  const x = fakeXhr([{ status: 413, body: {} }, { status: 0 }, { status: 201, body: { ok: true, recording: REC_NAME } }]);
+  const p = await reviewDesk({ xhr: x.X });
+  p.row().children[0].children[2].children[0].fire('click');
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(p.row()).textContent, 'Over the 100 MB cap. Record a shorter pass.');
+  assert.equal(recLine(p.row()).attrs.role, 'alert', 'the why is said, not just shown');
+  assert.equal(recBox(p.row()).attrs['data-record'], 'failed');
+  assert.equal(byAct(p.row(), 'record-send'), undefined, 'a file over the cap is not offered again');
+  assert.ok(fileInput(p.row()), 'pick another is offered');
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+  assert.equal(p.sent.length, 0, 'no sign-off after a refused upload');
+  assert.equal(p.part('desk-rows').children.length, 1, 'the row stays');
+  // another file; the connection breaks; try again goes through
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(p.row()).textContent, 'The upload broke off. Try again.');
+  const retry = byAct(p.row(), 'record-send');
+  assert.equal(retry.textContent, 'try again');
+  retry.fire('click');
+  await settle();
+  await new Promise((r) => setTimeout(r, 360));
+  await settle();
+  assert.equal(x.calls.length, 3);
+  assert.equal(p.sent.length, 1);
+  assert.equal(p.part('desk-rows'), undefined, 'signed off on the retry: the row cleared');
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+});
+
+test('1004579 the page: a refused sign-off says why on the line; nothing is counted', async () => {
+  const x = fakeXhr();
+  const p = await reviewDesk({ xhr: x.X, answer: (url) => (/\/uat$/.test(url) ? { status: 403, body: { error: { code: 'signer_shipped_this_work', message: 'You shipped work linked to this criterion.' } } } : null) });
+  p.row().children[0].children[2].children[0].fire('click');
+  pickFile(p.row(), VIDEO);
+  byAct(p.row(), 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(p.row()).textContent, 'You built this, so someone else signs it off.');
+  assert.equal(p.byId.get('streetToast').hidden, true, 'the line says it; no toast claims a decision');
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+  assert.equal(p.part('desk-rows').children.length, 1);
+});
+
+test('1004579 the page: a recording dropped on its row is taken and its line opens', async () => {
+  const p = await reviewDesk({ xhr: fakeXhr().X });
+  const row = p.row();
+  row.listeners.drop[0]({ preventDefault() {}, dataTransfer: { files: [VIDEO] } });
+  assert.equal(recLine(p.row()).textContent, 'walkthrough of the city.mp4 · 12 MB');
+  assert.equal(byAct(p.row(), 'record-send').textContent, 'tested it live');
+});
+
+test('1004579 the page: tapping its name opens the goal page\'s three checks in place', async () => {
+  const view = { uat_state: 'awaiting_uat', checks: { code: true, live: { available: true, live: true }, uat: null, stale_uat: null } };
+  const p = await reviewDesk({ xhr: fakeXhr().X, extra: { '/api/bongos/done-when/9/uat': view } });
+  p.row().children[0].children[1].fire('click');
+  await settle();
+  assert.ok(p.reads.includes('/api/bongos/done-when/9/uat'), 'the same read the goal page opens');
+  assert.deepEqual(p.row().children[1].children.map((x) => x.textContent), ['code done', 'running live', 'not signed off yet']);
+  assert.deepEqual(D.breaks({ ...D.deskModel({ key: 'review', floor: 1, docket: docket(uatMatters()), now: NOW }) }), []);
+});
+
+test('1004579 the card: record it on the street card records in place too, and the card closes on the sign-off', async () => {
+  const x = fakeXhr();
+  const view = { uat_state: 'awaiting_uat', checks: { code: true, live: { available: false }, uat: null, stale_uat: { signed_off_by_login: 'mira', created_at: '2026-09-30T10:00:00.000Z' } } };
+  const p = await bootPage('', uatMatters(), { xhr: x.X, extra: { '/api/bongos/done-when/9/uat': view } });
+  p.window.GovStreetPage.openCard('criteria_uat:9');
+  const body = p.byId.get('streetCardBody');
+  const rec = byAct(body, 'record');
+  assert.equal(rec.tagName, 'button', 'a button, not a link');
+  assert.equal(walk(body, (n) => n.tagName === 'a').length, 0, 'no link on the card');
+  // more: the checks the goal page showed
+  byAct(body, 'more').fire('click');
+  await settle();
+  const more = walk(body, (n) => n.className === 'mcard-more')[0];
+  const words = walk(more, (n) => n.className === 'mcard-more__text').map((n) => n.textContent);
+  assert.ok(words.includes('code · every linked task is done'));
+  assert.ok(words.includes('live · this site cannot tell, so the sign-off says you tried it live'));
+  assert.ok(words.some((w) => /^sign-off · an earlier one by mira on .* no longer counts/.test(w)));
+  byAct(body, 'more').fire('click');
+  byAct(body, 'record').fire('click');
+  assert.equal(walk(body, (n) => n.className === 'mcard-chips__ask')[0].textContent, 'the recording');
+  pickFile(body, VIDEO);
+  assert.equal(recLine(body).textContent, 'walkthrough of the city.mp4 · 12 MB');
+  byAct(body, 'record-send').fire('click');
+  await settle();
+  await settle();
+  assert.equal(x.calls.length, 1);
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/done-when/9/uat', body: { kind: 'uat', recording: REC_NAME, live_attested: true } }]);
+  assert.equal(p.byId.get('streetCard').hidden, true, 'the card closes: the matter is done');
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+  assert.equal(p.byId.get('streetToast').textContent, 'Signed off with the recording. The promise counts as kept.');
+});
+
+test('1004579 the card: a failed upload says why on the card\'s line and keeps the card open', async () => {
+  const x = fakeXhr([{ status: 400, body: { error: { code: 'bad_type', message: 'A UAT recording must be an mp4 or webm video.' } } }]);
+  const p = await bootPage('', uatMatters(), { xhr: x.X });
+  p.window.GovStreetPage.openCard('criteria_uat:9');
+  const body = p.byId.get('streetCardBody');
+  byAct(body, 'record').fire('click');
+  pickFile(body, VIDEO);
+  byAct(body, 'record-send').fire('click');
+  await settle();
+  assert.equal(recLine(body).textContent, 'Only an mp4 or webm video can go.');
+  assert.equal(p.byId.get('streetCard').hidden, false);
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+  assert.equal(walk(body, (n) => n.className === 'mcard-error').length, 0, 'said once, on its own line');
+});