@bongos/core 1.19.1067 → 1.19.1069

package/tests/hall_studio_home.mjs

@@ -0,0 +1,429 @@
+// tests/hall_studio_home.mjs — the studio home (task 1003971 / BV2.TW16, ADR
+// 0341 D2, D5, D8 and D11; docs/design/mocks/tweak-mode/Main.dc.html).
+//
+// Two halves. The pure rules (studio-lib.js) run over what the REAL composers
+// (modules/copy-desk/page-status.js) answer for a small ledger, so the words the
+// studio shows are tested on the routes' own shapes, never on a literal of them.
+// Then the REAL page: studio.html's own body in a mini-DOM, with the real
+// dom-utils.js, tweak-editor-lib.js, studio-lib.js and studio.js in a vm over a
+// stub client, driven the way an artist would: the tally, Resume, the three
+// panels, "take it", and the studio's own words typed over in place.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeRunner, makeEl, parseInto, walk, settle } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const lib = require('../modules/hall-ui/public/studio-lib.js');
+const pages = require('../modules/copy-desk/pages.js');
+const ps = require('../modules/copy-desk/page-status.js');
+
+const { test, summary } = makeRunner();
+
+// ── a small ledger, through the real composers ──────────────────────────────
+const ME = '7';
+const NOW = new Date('2026-09-28T12:00:00.000Z');
+const day = (n) => new Date(NOW.getTime() - n * 86400000).toISOString();
+const INV = {
+  surfaces: [{ id: 'landing' }, { id: 'builders' }, { id: 'status' }],
+  pages: [
+    { id: 'landing:index', surface: 'landing', title: '{{productName}}: {{tagline}}', path: '/', files: [] },
+    { id: 'landing:projects', surface: 'landing', title: '{{productName}} — projects', path: '/projects', files: [] },
+    { id: 'builders:studio', surface: 'builders', title: 'Studio', path: '/studio', files: [] },
+    { id: 'builders:work', surface: 'builders', title: 'Tasks', path: '/work', files: [] },
+    { id: 'status:index', surface: 'status', title: 'Status', path: '/', files: [] },
+  ],
+};
+const page = (id) => INV.pages.find((p) => p.id === id);
+const TASKS = [
+  { id: '11', source: 'page-tweak', source_ref: pages.roundSourceRef('landing:index', 1), status: 'shipped', shipped_at: day(9), artist_id: ME, description: pages.roundTaskBody(page('landing:index'), 1) },
+  { id: '12', source: 'page-tweak', source_ref: pages.roundSourceRef('status:index', 1), status: 'shipped', shipped_at: day(2), artist_id: ME, description: pages.roundTaskBody(page('status:index'), 1) },
+  { id: '13', source: 'page-tweak', source_ref: pages.roundSourceRef('landing:index', 2), status: 'active', holder_id: ME, holder_login: 'me', holder_worktree: false, description: pages.roundTaskBody(page('landing:index'), 2) },
+];
+const CREDITS = [
+  { reason: 'tweak.page_approved:11', delta: 30, recorded_at: day(9) },
+  { reason: 'tweak.page_approved:12', delta: 30, recorded_at: day(2) },
+];
+const ASKS = [{ page_id: 'landing:projects', askers: 2, oldest_ask_at: day(3) }];
+const TALLY = ps.composeTally({ builderId: ME, tasks: TASKS, creditRows: CREDITS, now: NOW });
+const PAGES = ps.composePages({ inventory: INV, readings: null, tasks: TASKS });
+const NEXT = ps.composeNext({ inventory: INV, readings: null, tasks: TASKS, asks: ASKS, builderId: ME });
+
+// The studio's own reading (the shape page-reader.js writes): the greeting, the
+// sub-line's template, and a generic holed line that must never win.
+const L = (key, section, text, placement) => ({ key, section, text, placement, file: 'modules/hall-ui/public/studio.html', line: 1, string_id: key });
+const STUDIO_READING = {
+  id: 'builders:studio',
+  reading_hash: 'rs-1',
+  lines: [
+    L('L0001', 'skip link', 'Skip to content', 'shared'),
+    L('L0002', 'Good evening.', 'Good evening.', 'placed'),
+    L('L0003', 'Good evening.', '{…}, on the {…} page, is where you left it. {…} of its {…} lines are yours so far.', 'placed'),
+    L('L0004', 'Good evening.', '{…} of {…}', 'placed'),
+    L('L0005', 'Good evening.', 'Approval queue', 'placed'),
+  ],
+};
+function studioRead({ held = false, draftLines = null } = {}) {
+  let description = pages.roundTaskBody(page('builders:studio'), 1);
+  if (draftLines) {
+    const r = pages.resolveDraft({ readingPage: STUDIO_READING, body: { reading_hash: 'rs-1', lines: draftLines }, savedAt: day(1) });
+    assert.equal(r.ok, true, JSON.stringify(r));
+    description += '\n\n' + pages.composeDraftBlock(r.draft);
+  }
+  const round = held ? { id: 70, status: 'active', holder_id: ME, holder_login: 'me', holder_worktree: false, description } : null;
+  return ps.composeEditor({ page: page('builders:studio'), readingPage: STUDIO_READING, round, builderId: ME });
+}
+const RESUME_READ = { ok: true, counter: { changed: 12, total: 38 } };
+
+// ── the mini-DOM over the page's own markup ─────────────────────────────────
+const HTML = read('studio.html');
+const BODY = /<body[^>]*>([\s\S]*)<\/body>/.exec(HTML)[1].replace(/<script[\s\S]*?<\/script>/g, '');
+const SOURCES = ['dom-utils.js', 'tweak-editor-lib.js', 'studio-lib.js', 'studio.js'].map((f) => [f, read(f)]);
+let boot = null;
+
+function augment(el) {
+  if (el._aug) return el;
+  el._aug = true;
+  const classes = () => String(el.className || '').split(/\s+/).filter(Boolean);
+  el.classList = {
+    add: (c) => { const s = new Set(classes()); s.add(c); el.className = [...s].join(' '); },
+    remove: (c) => { el.className = classes().filter((x) => x !== c).join(' '); },
+    toggle: (c, force) => { const on = force === undefined ? !classes().includes(c) : !!force; if (on) el.classList.add(c); else el.classList.remove(c); return on; },
+    contains: (c) => classes().includes(c),
+  };
+  for (const attr of ['hidden', 'disabled']) {
+    Object.defineProperty(el, attr, { get() { return attr in el.attrs; }, set(v) { if (v) el.attrs[attr] = ''; else delete el.attrs[attr]; }, configurable: true });
+  }
+  Object.defineProperty(el, 'href', { get() { return el.attrs.href || ''; }, set(v) { el.attrs.href = String(v); }, configurable: true });
+  Object.defineProperty(el, 'innerHTML', {
+    get() { return el._html === null ? '' : el._html; },
+    set(v) { el._html = String(v); parseInto(el, el._html); walk(el, (c) => { augment(c); return null; }); },
+    configurable: true,
+  });
+  el.focus = () => { boot.focused = el; };
+  el.blur = () => el.fire('blur', { target: el });
+  return el;
+}
+
+function bootStudio({ answers = {}, signedIn = true } = {}) {
+  const root = augment(makeEl('body', {}));
+  root.innerHTML = BODY;
+  const byId = (id) => walk(root, (c) => (c.id === id ? c : null));
+  const docListeners = {};
+  const requests = [];
+  const htmlEl = augment(makeEl('html', {}));
+  const documentObj = {
+    body: root,
+    documentElement: htmlEl,
+    getElementById: byId,
+    querySelector: (sel) => root.querySelector(sel),
+    querySelectorAll: (sel) => root.querySelectorAll(sel),
+    createElement: (tag) => augment(makeEl(tag, {})),
+    addEventListener: (type, fn) => { (docListeners[type] = docListeners[type] || []).push(fn); },
+    execCommand() {},
+  };
+  const client = {
+    request: async (method, url, body) => {
+      requests.push({ method, url, body });
+      const key = `${method} ${url.replace(/^\/api\/bongos/, '')}`;
+      if (key === 'GET /me') return signedIn ? ok({ builder: { id: ME, display_name: 'Artist A', rank: 'metic' } }) : { ok: false, status: 401, data: {} };
+      const a = answers[key];
+      if (typeof a === 'function') return a(body);
+      if (a) return a;
+      return { status: 404, ok: false, data: { error: { code: 'no_answer', message: key } } };
+    },
+  };
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    location: { host: 'builders.cloudbongos.com', hostname: 'builders.cloudbongos.com', protocol: 'https:', search: '', pathname: '/studio', assign: (u) => { out.navigated = u; } },
+    localStorage: { getItem: () => null, setItem() {} },
+    addEventListener() {},
+    scrollTo() {},
+  };
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, encodeURIComponent };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const [name, src] of SOURCES) vm.runInContext(src, sandbox, { filename: name });
+  const out = {
+    requests, navigated: null, focused: null, el: byId, html: htmlEl,
+    writes: () => requests.filter((r) => r.method !== 'GET'),
+    click: async (id) => { const el = byId(id); assert.ok(el, `no #${id}`); el.fire('click', { target: el }); await out.settle(); },
+    clickIn: async (overlayId, sel) => {
+      const overlay = byId(overlayId);
+      const target = overlay.querySelector(sel);
+      assert.ok(target, `no ${sel} in #${overlayId}`);
+      overlay.fire('click', { target });
+      await out.settle();
+    },
+    settle: async () => { for (let i = 0; i < 10; i++) await settle(); },
+  };
+  boot = out;
+  return out;
+}
+const ok = (data) => ({ status: 200, ok: true, data });
+const HOME = {
+  'GET /copy-desk/tally': ok(TALLY),
+  'GET /copy-desk/next': ok(NEXT),
+  'GET /copy-desk/pages': ok(PAGES),
+  'GET /copy-desk/pages/landing:index/draft': ok(RESUME_READ),
+};
+
+try {
+  // ── the pure half, over the composers' answers ────────────────────────────
+  await test('the tally reads the composer: credits, pages tweaked, and this week with its sign', () => {
+    assert.deepEqual(lib.tallyParts(TALLY), { credits: '60', pages: '2', week: '+30' });
+    assert.deepEqual(lib.tallyParts({ credits: 0, pages_tweaked: 0, this_week: 0 }), { credits: '0', pages: '0', week: '0' }, 'a quiet week is 0, not +0');
+    assert.equal(lib.tallyParts(null), null);
+  });
+
+  await test('Resume and the sub-line name the held page as the artist reads it, in the artboard\'s words', () => {
+    assert.equal(NEXT.resume.page_id, 'landing:index', 'the composer reports the held round as resume');
+    assert.equal(lib.resumeDetail(NEXT.resume, RESUME_READ.counter), 'Home · landing · 12 of 38 lines');
+    assert.equal(lib.resumeDetail(NEXT.resume, null), 'Home · landing');
+    assert.deepEqual(lib.subParts(NEXT.resume, RESUME_READ.counter),
+      { title: 'Home', surface: 'landing', counted: true, changed: 'Twelve', total: 'thirty-eight' });
+    assert.equal(lib.subParts(null, null), null, 'nothing held: the page\'s own sentence stands');
+    assert.equal(lib.numberWords(0, { capital: true }), 'None');
+    assert.equal(lib.numberWords(75), 'seventy-five');
+    assert.equal(lib.numberWords(120), 'one hundred and twenty');
+    assert.equal(lib.numberWords(1200), '1200');
+  });
+
+  await test('the three details: next up, the approvals count, and the whole count', () => {
+    assert.equal(lib.flowDetail(NEXT), 'next up: Projects — 2 people asked for it');
+    assert.equal(lib.flowDetail({ recommended: null }), 'every page is taken for now');
+    assert.equal(lib.statusDetail(PAGES), '2 of 5 pages tweaked');
+  });
+
+  await test('Artist Review Status: landing, builders hall, status, each N of M, the bar never empty', () => {
+    const rows = lib.surfaceRows(PAGES, 'cloudbongos.com');
+    assert.deepEqual(rows.map((r) => [r.name, r.where, r.count, r.pct]), [
+      ['Landing', 'cloudbongos.com', '1 of 2 tweaked', 50],
+      ['Builders hall', 'where the work happens', '0 of 2 tweaked', 3],
+      ['Status', 'the public dashboard', '1 of 1 tweaked', 100],
+    ]);
+    assert.equal(lib.landingHost('https://cloudbongos.com/', 'builders.x.test'), 'cloudbongos.com', 'the stamped origin wins');
+    assert.equal(lib.landingHost('{{publicOrigin}}', 'builders.x.test'), 'x.test', 'an unstamped token is no address');
+    assert.equal(lib.askedLine(NEXT.asked_pages), '1 page has been asked for. It comes up first in the Tweak/CopyWrite Flow.');
+    assert.equal(lib.askedLine(4), '4 pages have been asked for. They come up first in the Tweak/CopyWrite Flow.');
+    assert.equal(lib.askedLine(0), '');
+  });
+
+  await test('a word on the page finds its own line: the most specific wins, holes alone never match, shared never', () => {
+    const sentence = 'Home, on the landing page, is where you left it. Twelve of its thirty-eight lines are yours so far.';
+    assert.equal(lib.matchLine(sentence, STUDIO_READING.lines).key, 'L0003', 'not the generic "{…} of {…}"');
+    assert.equal(lib.matchLine('Good evening.', STUDIO_READING.lines).key, 'L0002');
+    assert.equal(lib.matchLine('Nine of ten', STUDIO_READING.lines), null, 'a line of holes and one word is no match for a sentence');
+    assert.equal(lib.matchLine('Skip to content', STUDIO_READING.lines), null, 'shell text is not the studio\'s own');
+    assert.equal(lib.matchLine('Something new', STUDIO_READING.lines), null);
+  });
+
+  await test('a refused claim, in words', () => {
+    assert.equal(lib.claimWords('page_held', { holder: { login: 'bob' } }), 'bob is tweaking this page right now.');
+    assert.match(lib.claimWords('not_an_artist', {}), /Only an artist can take a page/);
+    assert.equal(lib.claimWords('page_in_flight', { what_this_means: 'The server says so.' }), 'The server says so.');
+  });
+
+  // ── the real page ─────────────────────────────────────────────────────────
+  await test('the home paints from the four reads: tally, Resume into the editor, the sub-line, the details', async () => {
+    const s = bootStudio({ answers: HOME });
+    await s.settle();
+    assert.equal(s.el('st-tally').hidden, false);
+    assert.deepEqual(['st-tally-credits', 'st-tally-pages', 'st-tally-week'].map((id) => s.el(id).textContent), ['60', '2', '+30']);
+    assert.equal(s.el('st-resume').hidden, false);
+    assert.equal(s.el('st-resume').getAttribute('href'), '/builders/tweak-editor?page=landing:index');
+    assert.equal(s.el('st-resume-detail').textContent, 'Home · landing · 12 of 38 lines');
+    assert.equal(s.el('studio-sub').textContent, 'Home, on the landing page, is where you left it. Twelve of its thirty-eight lines are yours so far.');
+    assert.equal(s.el('st-flow-detail').textContent, 'next up: Projects — 2 people asked for it');
+    assert.equal(s.el('st-status-detail').textContent, '2 of 5 pages tweaked');
+    assert.deepEqual(s.writes(), [], 'opening the studio writes nothing');
+  });
+
+  await test('nothing held: no Resume, and the page\'s own sub-line stands', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'GET /copy-desk/next': ok({ ...NEXT, resume: null }) } });
+    await s.settle();
+    assert.equal(s.el('st-resume').hidden, true);
+    assert.match(s.el('studio-sub').textContent, /^Nothing is on your desk yet\./);
+  });
+
+  await test('signed out: no tally, no reads of the ledger', async () => {
+    const s = bootStudio({ answers: HOME, signedIn: false });
+    await s.settle();
+    assert.equal(s.el('st-tally').hidden, true);
+    assert.equal(s.requests.filter((r) => /copy-desk\/(tally|next|pages)/.test(r.url)).length, 0);
+  });
+
+  await test('the Tweak/CopyWrite Flow: the recommendation, pick another swaps it, take it claims THAT page and opens it', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'POST /copy-desk/pages/builders:studio/claim': ok({ ok: true, outcome: 'created' }) } });
+    await s.settle();
+    await s.click('st-flow');
+    assert.equal(s.el('st-panel').hidden, false);
+    assert.ok(s.html.classList.contains('st-open'));
+    assert.equal(s.el('st-panel-title').textContent, 'Tweak/CopyWrite Flow');
+    const body = () => s.el('st-panel-body').innerHTML;
+    assert.match(body(), /st-next__page">Projects</);
+    assert.match(body(), /landing · 2 people asked for it/);
+    await s.clickIn('st-panel', '[data-pick]');
+    assert.doesNotMatch(body(), /id="st-picks" hidden/, 'the chips open');
+    assert.match(body(), /data-pick-id="builders:studio">Studio · builders hall</);
+    await s.clickIn('st-panel', '[data-pick-id="builders:studio"]');
+    assert.match(body(), /st-next__page">Studio</, 'the picked page is now the one to take');
+    await s.clickIn('st-panel', '[data-take]');
+    assert.deepEqual(s.writes().map((w) => `${w.method} ${w.url}`), ['POST /api/bongos/copy-desk/pages/builders:studio/claim']);
+    assert.equal(s.navigated, '/builders/tweak-editor?page=builders:studio');
+  });
+
+  await test('a refused take stays in the panel and says why', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'POST /copy-desk/pages/landing:projects/claim': { ok: false, status: 409, data: { error: { code: 'page_held', message: 'held', details: { holder: { login: 'bob' } } } } } } });
+    await s.settle();
+    await s.click('st-flow');
+    await s.clickIn('st-panel', '[data-take]');
+    assert.equal(s.navigated, null);
+    const err = s.el('st-take-err');
+    assert.equal(err.hidden, false);
+    assert.match(err.textContent, /is tweaking this page right now/);
+  });
+
+  await test('Artist Review Status: three surface lines, the instance\'s address on landing, the asked line', async () => {
+    const s = bootStudio({ answers: HOME });
+    s.el('hall-main').setAttribute('data-apex', 'https://cloudbongos.com');
+    await s.settle();
+    await s.click('st-status');
+    const body = s.el('st-panel-body').innerHTML;
+    assert.equal(s.el('st-panel-title').textContent, 'Artist Review Status');
+    assert.deepEqual([...body.matchAll(/st-surface__name">([^<]*)</g)].map((m) => m[1]), ['Landing', 'Builders hall', 'Status']);
+    assert.match(body, /st-surface__where">cloudbongos\.com</);
+    assert.match(body, /1 of 2 tweaked/);
+    assert.match(body, /style="width: 50%"/);
+    assert.match(body, /1 page has been asked for/);
+    await s.clickIn('st-panel', '[data-close-panel]');
+    assert.equal(s.el('st-panel').hidden, true);
+    assert.ok(!s.html.classList.contains('st-open'));
+  });
+
+  await test('the studio\'s words: a first click offers the studio page, and nothing is taken until the artist says so', async () => {
+    const s = bootStudio({ answers: { ...HOME, 'GET /copy-desk/pages/builders:studio/draft': ok(studioRead({ held: false })) } });
+    await s.settle();
+    await s.click('studio-greet');
+    assert.equal(s.el('st-offer').hidden, false);
+    assert.equal(s.el('studio-greet').getAttribute('contenteditable'), null, 'not editable before the page is taken');
+    assert.deepEqual(s.writes(), []);
+    await s.click('st-offer-no');
+    assert.equal(s.el('st-offer').hidden, true);
+    assert.deepEqual(s.writes(), [], 'not now takes nothing');
+  });
+
+  await test('taken: the words the reading lists are typed over in place, and the WHOLE draft is saved to the studio page', async () => {
+    let held = false;
+    const saved = [];
+    const s = bootStudio({
+      answers: {
+        ...HOME,
+        'GET /copy-desk/pages/builders:studio/draft': () => ok(studioRead({ held, draftLines: held ? [{ key: 'L0005', after: 'Waiting for you' }] : null })),
+        'POST /copy-desk/pages/builders:studio/claim': () => { held = true; return ok({ ok: true, outcome: 'created' }); },
+        'PUT /copy-desk/pages/builders:studio/draft': (b) => { saved.push(b); return ok({ ok: true, outcome: 'saved' }); },
+      },
+    });
+    await s.settle();
+    await s.click('studio-greet');
+    await s.click('st-offer-take');
+    const greet = s.el('studio-greet');
+    const sub = s.el('studio-sub');
+    assert.equal(greet.getAttribute('contenteditable'), 'true');
+    assert.equal(sub.getAttribute('contenteditable'), 'true', 'the sub-line found its own line, not the generic one');
+    assert.equal(sub.textContent, STUDIO_READING.lines[2].text, 'a line with holes is typed over as the reading holds it');
+    assert.equal(s.el('st-hint').hidden, true);
+    assert.equal(s.el('st-editing').hidden, false);
+    assert.match(s.el('st-editing').innerHTML, /The studio page is yours · 1 of 5 rewritten · saved/);
+    assert.match(s.el('st-editing').innerHTML, /href="\/builders\/tweak-editor\?page=builders:studio"/, 'submit is the editor\'s');
+
+    greet.textContent = 'Good night.';
+    greet.fire('input', { target: greet });
+    greet.fire('blur', { target: greet });
+    await s.settle();
+    assert.equal(saved.length, 1, 'one save');
+    assert.deepEqual(JSON.parse(JSON.stringify(saved[0])), { reading_hash: 'rs-1', lines: [{ key: 'L0002', after: 'Good night.' }, { key: 'L0005', after: 'Waiting for you' }] },
+      'the whole draft: the word typed here AND the line the editor saved');
+    assert.match(s.el('st-editing').innerHTML, /2 of 5 rewritten · saved/);
+    greet.fire('blur', { target: greet });
+    await s.settle();
+    assert.equal(saved.length, 1, 'an unchanged draft is not saved again');
+    const writes = s.writes().map((w) => `${w.method} ${w.url}`);
+    assert.deepEqual(writes, ['POST /api/bongos/copy-desk/pages/builders:studio/claim', 'PUT /api/bongos/copy-desk/pages/builders:studio/draft'],
+      'the claim and the draft, and never a live string');
+  });
+
+  await test('already held: a click goes straight to editing; a refused save says so in the server\'s words', async () => {
+    const s = bootStudio({
+      answers: {
+        ...HOME,
+        'GET /copy-desk/pages/builders:studio/draft': ok(studioRead({ held: true })),
+        'PUT /copy-desk/pages/builders:studio/draft': { ok: false, status: 409, data: { error: { code: 'reading_moved', message: 'moved', details: { what_this_means: 'The page changed since it was read.' } } } },
+      },
+    });
+    await s.settle();
+    await s.click('studio-greet');
+    assert.equal(s.el('st-offer').hidden, true, 'no offer: the page is already yours');
+    const greet = s.el('studio-greet');
+    assert.equal(greet.getAttribute('contenteditable'), 'true');
+    greet.textContent = 'Evening.';
+    greet.fire('input', { target: greet });
+    greet.fire('blur', { target: greet });
+    await s.settle();
+    assert.match(s.el('st-editing').innerHTML, /not saved · The page changed since it was read\./);
+    assert.ok(s.el('st-editing').classList.contains('st-editing--failed'));
+  });
+
+  await test('a refused claim on the studio page keeps the words as they are and says why', async () => {
+    const s = bootStudio({
+      answers: {
+        ...HOME,
+        'GET /copy-desk/pages/builders:studio/draft': ok(studioRead({ held: false })),
+        'POST /copy-desk/pages/builders:studio/claim': { ok: false, status: 403, data: { error: { code: 'not_an_artist', message: 'no' } } },
+      },
+    });
+    await s.settle();
+    await s.click('studio-greet');
+    await s.click('st-offer-take');
+    assert.equal(s.el('studio-greet').getAttribute('contenteditable'), null);
+    assert.equal(s.el('st-offer-err').hidden, false);
+    assert.match(s.el('st-offer-err').textContent, /Only an artist can take a page/);
+  });
+
+  await test('the older reviews stay one quiet door away while any still wait', async () => {
+    const REVIEW = { id: '1900', title: 'Artist review: the copy and visuals that shipped in task 1899', status: 'backlog', source: 'cascade', source_ref: 'cascade-artist-review-on-ship-1899', created_at: day(20) };
+    const s = bootStudio({ answers: { ...HOME, 'GET /tasks?discipline=artist&status=backlog&limit=50': ok({ tasks: [REVIEW] }) } });
+    await s.settle();
+    assert.equal(s.el('st-older').hidden, false);
+    assert.equal(s.el('st-older-label').textContent, '1 review from before Tweak Mode still waits');
+    await s.click('st-older');
+    assert.equal(s.el('st-reviews').hidden, false);
+    assert.match(s.el('studio-focus').innerHTML, /to tend now · 1 of 1/);
+    const none = bootStudio({ answers: HOME });
+    await none.settle();
+    assert.equal(none.el('st-older').hidden, true, 'no review waiting: no door');
+  });
+
+  await test('the markup: one h1 (the greeting), the tally and four doors, the libs before the page, the full-screen switch', () => {
+    const nc = HTML.replace(/<!--[\s\S]*?-->/g, '');
+    assert.equal((nc.match(/<h1\b/g) || []).length, 1);
+    assert.match(nc, /<h1[^>]*id="studio-greet"[^>]*data-words/);
+    assert.match(nc, /<p[^>]*id="studio-sub"[^>]*data-words/);
+    for (const id of ['st-tally', 'st-resume', 'st-flow', 'studio-approvals', 'st-status', 'st-older']) assert.match(nc, new RegExp(`id="${id}"`));
+    assert.match(nc, /<body[^>]*data-fullscreen-switch/);
+    const at = (f) => nc.indexOf(f);
+    assert.ok(at('tweak-editor-lib.js') < at('studio-lib.js') && at('studio-lib.js') < at('/studio.js'), 'the libs, then the page');
+    assert.ok(at('approval-queue.js') < at('/studio.js'), 'the Approval queue panel before the page that mounts it');
+  });
+} finally {
+  await new Promise((r) => setTimeout(r, 100));
+  summary();
+}

package/tests/hall_studio_world.mjs

@@ -55,6 +55,12 @@ test('the Studio writes ONLY the artist\'s verdict on their own review queue', (
     /^PATCH \$\{API\}\/tasks\/\$\{reviewId\}$/,          // note it   → the words, on the review
     /^POST \$\{API\}\/tasks$/,                           // needs work→ the follow-up task
     /^POST \$\{API\}\/tasks\/\$\{reviewId\}\/merge$/,    // …and the review closed against it
+    // The home (task 1003971 / BV2.TW16, ADR 0341 D5 and D11): take a page's
+    // tweak round, and save the studio page's draft while the artist holds it.
+    // Neither writes a live string; the words reach a page only as a shipped,
+    // approved tweak.
+    /^POST \$\{API\}\/copy-desk\/pages\/\$\{pageId\}\/claim$/,
+    /^PUT \$\{API\}\/copy-desk\/pages\/\$\{pageId\}\/draft$/,
   ];
   // Every write site, as "<VERB> <route expression>" — the verb from the
   // request call, the route from the WRITE_ROUTES entry it names.
@@ -69,7 +75,7 @@ test('the Studio writes ONLY the artist\'s verdict on their own review queue', (
       const named = /^WRITE_ROUTES\.(\w+)\(/.exec(arg.trim());
       return { verb, arg: arg.trim(), route: named ? routes.get(named[1]) : null };
     });
-  assert.equal(sites.length, 4, `exactly the four verdict writes; found ${sites.length}`);
+  assert.equal(sites.length, 6, `the four verdict writes, one page claim and one draft save; found ${sites.length}`);
   for (const s of sites) {
     assert.ok(s.route, `every write names a WRITE_ROUTES entry, never an inline URL: ${s.verb} ${s.arg}`);
     const site = `${s.verb} ${s.route}`;

package/tests/hall_tweak_editor.mjs

@@ -407,7 +407,7 @@ try {
     assert.match(HTML, /<body data-page="tweak-editor"[^>]*data-fullscreen-switch/);
     assert.equal((HTML.match(/<h1\b/g) || []).length, 1);
     assert.ok(HTML.indexOf('tweak-editor-lib.js') < HTML.indexOf('tweak-editor.js?'), 'the lib loads first');
-    assert.match(HTML, /shell\.js\?v=2026-09-27-fullscreen/);
+    assert.match(HTML, /shell\.js\?v=2026-09-28-archive/);
     assert.equal(/fonts\.googleapis\.com\/css/.test(HTML), false);
     for (const id of ['tw-bar', 'tw-counter', 'tw-open', 'tw-download', 'tw-upload', 'tw-file', 'tw-submit', 'tw-paper', 'tw-doc', 'tw-notice', 'tw-done', 'tw-take', 'tw-pick', 'tw-picks']) {
       assert.ok(new RegExp(`id="${id}"`).test(HTML), `#${id} is in the markup`);

package/tests/nav_permission_atoms.mjs

@@ -87,7 +87,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the file and left the query alone, so a returning browser kept the cached copy —
 // a fix that reaches nobody looks identical to a fix that does not work.
 
-const SHELL_SHA = '7f66604d74d544e8';
+const SHELL_SHA = '0c646e5bac9336e8';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);