@bongos/core 1.19.1061 → 1.19.1063

package/tests/hall_tweak_editor.mjs

@@ -0,0 +1,432 @@
+// tests/hall_tweak_editor.mjs — the tweak editor page (task 1004321 / BV2.TW10,
+// ADR 0341 D4; docs/design/mocks/tweak-mode/Editor.dc.html).
+//
+// Boots the REAL page: tweak-editor.html's own body parsed into a mini-DOM, the
+// real dom-utils.js, tweak-editor-lib.js and tweak-editor.js in a vm, against a
+// stub client. What the client answers for the editor read is built by the REAL
+// composer (page-status.js composeEditor) over a reading and a draft block the
+// REAL pages.js wrote, so the page is tested on the route's own shape, never a
+// hand-written literal of it.
+//
+// The done-when, as far as a page can prove it: rewrite a page (the whole draft
+// is PUT, debounced), come back to it (the saved draft is what the boxes hold),
+// the Word round trip (upload lands its lines in the boxes), submit, and take
+// the next page (POST on the recommendation's own take path, then open it).
+
+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/tweak-editor-lib.js');
+const pages = require('../modules/copy-desk/pages.js');
+const pageStatus = require('../modules/copy-desk/page-status.js');
+
+const { test, summary } = makeRunner();
+
+// ── the page's own data, through the real composer ─────────────────────────
+const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
+const READING = {
+  id: 'landing:index',
+  reading_hash: 'rh-1',
+  lines: [
+    L('L0001', 'top bar', 'Skip to content', 'shared', { file: 'modules/public-landing/public/index.html', line: 3, string_id: 's1' }),
+    L('L0002', 'top bar', 'Projects', 'shared'),
+    L('L0003', 'hero', 'Building Digitally,', 'placed', { file: 'modules/public-landing/public/index.html', line: 9, string_id: 'h1' }),
+    L('L0004', 'hero', 'AI agents claim tasks and ship the code.', 'placed', { file: 'modules/public-landing/public/index.html', line: 10, string_id: 'h2' }),
+    L('L0005', 'hero', '<img src=x onerror="window.pwned=1">', 'unplaced'),
+    L('L0006', 'footer', 'Built by agents.', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'f1' }),
+    L('L0007', 'top bar', 'Sign in', 'shared', { file: 'modules/public-landing/public/index.html', line: 5, string_id: 's2' }),
+  ],
+};
+const PAGE = { id: 'landing:index', surface: 'landing', title: '{{productName}}: {{tagline}}', path: '/', url: 'https://{apex}/' };
+const ME = '7';
+function editorRead({ held = true, draftLines = [{ key: 'L0004', after: 'Agents write the code.' }], state = 'active', holder = ME } = {}) {
+  let description = pages.roundTaskBody(PAGE, 1);
+  if (draftLines) {
+    const r = pages.resolveDraft({ readingPage: READING, body: { reading_hash: 'rh-1', lines: draftLines }, savedAt: '2026-09-28T09:00:00.000Z' });
+    assert.equal(r.ok, true, JSON.stringify(r));
+    description += '\n\n' + pages.composeDraftBlock(r.draft);
+  }
+  const round = { id: 55, status: state, holder_id: held ? holder : null, holder_login: held ? (holder === ME ? 'me' : 'bob') : null, holder_worktree: false, description };
+  return pageStatus.composeEditor({ page: PAGE, readingPage: READING, round, builderId: ME });
+}
+const NEXT = {
+  resume: null,
+  recommended: { page_id: 'landing:projects', surface: 'landing', title: '{{productName}} — projects', path: '/projects', why_line: 'landing · 2 people asked for it', take: { method: 'POST', path: '/copy-desk/pages/landing:projects/claim' } },
+  alternatives: [
+    { page_id: 'builders:home', surface: 'builders', title: 'Home', path: '/', why_line: 'builders hall · untweaked', take: { method: 'POST', path: '/copy-desk/pages/builders:home/claim' } },
+  ],
+};
+
+// ── the mini-DOM over the page's own markup ────────────────────────────────
+const HTML = read('tweak-editor.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', 'tweak-editor.js'].map((f) => [f, read(f)]);
+
+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),
+  };
+  Object.defineProperty(el, 'hidden', { get() { return 'hidden' in el.attrs; }, set(v) { if (v) el.attrs.hidden = ''; else delete el.attrs.hidden; }, configurable: true });
+  Object.defineProperty(el, 'readOnly', { get() { return 'readonly' in el.attrs; }, set(v) { if (v) el.attrs.readonly = ''; else delete el.attrs.readonly; }, configurable: true });
+  Object.defineProperty(el, 'disabled', { get() { return 'disabled' in el.attrs; }, set(v) { if (v) el.attrs.disabled = ''; else delete el.attrs.disabled; }, configurable: true });
+  if (el.tagName === 'textarea') {
+    Object.defineProperty(el, 'value', { get() { return el._value !== null ? el._value : el._text; }, set(v) { el._value = String(v); }, configurable: true });
+  }
+  Object.defineProperty(el, 'innerHTML', {
+    get() { return el._html === null ? '' : el._html; },
+    set(v) { el._html = String(v); el._value = null; parseInto(el, el._html); walk(el, (c) => { augment(c); return null; }); },
+    configurable: true,
+  });
+  el.scrollHeight = 40;
+  el.inert = false;
+  el.focus = () => { boot.focused = el; };
+  el.click = () => { el.clicked = (el.clicked || 0) + 1; };
+  return el;
+}
+let boot = null;
+
+function bootEditor({ search = '?page=landing:index', answers = {} } = {}) {
+  const root = augment(makeEl('body', {}));
+  root.innerHTML = BODY;
+  const byId = (id) => walk(root, (c) => (c.id === id ? c : null));
+  const docListeners = {};
+  const timers = [];
+  let timerId = 0;
+  const requests = [];
+  const fetches = [];
+  const documentObj = {
+    title: 'Tweak a page — Cloud Bongos',
+    body: root,
+    documentElement: { dataset: {} },
+    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); },
+  };
+  const client = {
+    request: async (method, url, opts = {}) => {
+      requests.push({ method, url, body: opts.body });
+      const key = `${method} ${url.replace(/^\/api\/bongos/, '')}`;
+      const a = answers[key];
+      if (typeof a === 'function') return a(opts.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: '/builders/tweak-editor', assign: (u) => { out.navigated = u; } },
+    history: { replaceState: (_, __, u) => { out.replaced = u; } },
+    localStorage: { getItem: () => 'off', setItem() {} },
+    addEventListener() {},
+    setTimeout: (fn, ms) => { const id = ++timerId; timers.push({ id, fn, ms }); return id; },
+    clearTimeout: (id) => { const i = timers.findIndex((t) => t.id === id); if (i >= 0) timers.splice(i, 1); },
+  };
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    fetch: async (url, init) => { fetches.push({ url, init }); const a = answers[`FETCH ${init.method} ${url.replace(/^\/api\/bongos/, '')}`]; return { ok: !!(a && a.ok), json: async () => (a ? a.data : null) }; },
+    console, URLSearchParams, setTimeout, clearTimeout,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  for (const [name, src] of SOURCES) vm.runInContext(src, sandbox, { filename: name });
+
+  const fire = (type, target) => (docListeners[type] || []).forEach((fn) => fn({ type, target }));
+  const out = {
+    requests, fetches, navigated: null, replaced: null, focused: null,
+    el: byId,
+    window: windowObj,
+    lines: () => root.querySelectorAll('textarea'),
+    type: (key, value) => { const ta = byId(`tw-${key}`); ta.value = value; fire('input', ta); },
+    click: async (id) => { const el = byId(id); assert.ok(el, `no #${id}`); fire('click', el); await settle(); await settle(); },
+    clickEl: async (el) => { fire('click', el); await settle(); await settle(); },
+    flushTimers: async () => { while (timers.length) { const [t] = timers.splice(0, 1); t.fn(); await settle(); await settle(); } },
+    pending: () => timers.length,
+    settle: async () => { for (let i = 0; i < 6; i++) await settle(); },
+  };
+  boot = out;
+  return out;
+}
+const ok = (data) => ({ status: 200, ok: true, data });
+
+try {
+  // ── the pure half ─────────────────────────────────────────────────────────
+  await test('sections are consecutive runs, so a section that recurs gets its heading again', () => {
+    assert.deepEqual(lib.sectionsOf(READING.lines).map((s) => [s.name, s.lines.length]),
+      [['top bar', 2], ['hero', 3], ['footer', 1], ['top bar', 1]]);
+  });
+
+  await test('the margin note: shared and engineer lines keep theirs, a changed line says what it was', () => {
+    const ed = editorRead();
+    const byKey = Object.fromEntries(ed.reading.lines.map((l) => [l.key, l]));
+    assert.deepEqual(lib.noteFor(byKey.L0001, 'Skip', ed.notes), { kind: 'shared', text: 'changes this on every page' });
+    assert.deepEqual(lib.noteFor(byKey.L0002, 'Projects', ed.notes), { kind: 'engineer', text: 'goes to an engineer' }, 'shared with no registry row goes to an engineer, the submit\'s rule');
+    assert.deepEqual(lib.noteFor(byKey.L0004, 'Agents write the code.', ed.notes), { kind: 'was', text: 'was: AI agents claim tasks and ship the code.' });
+    assert.equal(lib.noteFor(byKey.L0003, 'Building Digitally,', ed.notes), null);
+  });
+
+  await test('the autosave body is the WHOLE draft: every changed, non-empty line, and nothing else', () => {
+    const values = lib.initialValues(READING.lines, { lines: [{ key: 'L0004', after: 'Agents write the code.' }] });
+    values.L0003 = '';           // emptied: removing words is a code change, never saved
+    values.L0006 = 'Built by agents.'; // back to the page's words: not a rewrite
+    values.L0007 = 'Log in';
+    assert.deepEqual(lib.draftBody('rh-1', READING.lines, values), {
+      reading_hash: 'rh-1',
+      lines: [{ key: 'L0004', after: 'Agents write the code.' }, { key: 'L0007', after: 'Log in' }],
+    });
+    assert.equal(lib.counterText(2, 7, 'saving'), '2 of 7 rewritten · saving…');
+    assert.equal(lib.counterText(2, 7, 'saved'), '2 of 7 rewritten · saved');
+  });
+
+  await test('names, addresses and the page id', () => {
+    assert.equal(lib.displayTitle(PAGE), 'Home', 'a templated title on "/" is the page called Home');
+    assert.equal(lib.displayTitle(NEXT.recommended), 'Projects');
+    assert.equal(lib.displayTitle({ title: 'Studio' }), 'Studio');
+    assert.equal(lib.liveUrl('https://{apex}/projects', { host: 'builders.cloudbongos.com', protocol: 'https:' }), 'https://cloudbongos.com/projects');
+    assert.equal(lib.liveUrl('https://builders.{apex}/studio', { host: 'builders.localhost:4631', protocol: 'http:' }), 'http://builders.localhost:4631/studio');
+    assert.equal(lib.pageIdFrom('?page=landing%3Aindex'), 'landing:index');
+    assert.equal(lib.pageIdFrom('?page=landing:index'), 'landing:index');
+    assert.equal(lib.pageIdFrom('?page=../../etc'), null);
+    assert.equal(lib.uploadedLabel({ from_file: ['L1', 'L2', 'L3'] }), 'uploaded · 3 lines from your doc');
+  });
+
+  // ── the page, booted ─────────────────────────────────────────────────────
+  await test('the page opens on the read: every line in page order, the saved draft in its box, notes and the accent mark', async () => {
+    const b = bootEditor({ answers: { 'GET /copy-desk/pages/landing:index/draft': ok(editorRead()) } });
+    await b.settle();
+    assert.equal(b.requests[0].url, '/api/bongos/copy-desk/pages/landing:index/draft');
+    const boxes = b.lines();
+    assert.deepEqual(boxes.map((t) => t.dataset.key), READING.lines.map((l) => l.key));
+    assert.equal(b.el('tw-L0004').value, 'Agents write the code.', 'the saved draft, not the page text');
+    assert.ok(b.el('tw-L0004').classList.contains('tw-line--changed'), 'a changed line carries the accent mark');
+    assert.equal(b.el('tw-L0004-note').textContent, 'was: AI agents claim tasks and ship the code.');
+    assert.equal(b.el('tw-L0001-note').textContent, 'changes this on every page');
+    assert.equal(b.el('tw-L0005-note').textContent, 'goes to an engineer');
+    assert.equal(b.el('tw-counter').textContent, '1 of 7 rewritten · saved');
+    assert.equal(b.el('tw-name').textContent, 'Home');
+    assert.equal(b.el('tw-surface').textContent, '· landing');
+    assert.equal(b.el('tw-title').textContent, 'Home');
+    assert.equal(b.el('tw-open').href, 'https://cloudbongos.com/');
+    assert.equal(b.el('tw-submit').disabled, false);
+    assert.equal(b.lines().some((t) => t.readOnly), false);
+    // Section headings, one per consecutive run.
+    assert.deepEqual(b.el('tw-doc').querySelectorAll('h2').map((h) => h.textContent), ['top bar', 'hero', 'footer', 'top bar']);
+  });
+
+  await test('a hostile line is text, never markup', async () => {
+    const b = bootEditor({ answers: { 'GET /copy-desk/pages/landing:index/draft': ok(editorRead()) } });
+    await b.settle();
+    assert.equal(b.el('tw-doc').querySelectorAll('img').length, 0);
+    assert.equal(b.el('tw-L0005').value, '<img src=x onerror="window.pwned=1">');
+    assert.equal(b.window.pwned, undefined);
+  });
+
+  await test('typing autosaves the whole draft once, debounced, and the counter follows', async () => {
+    const puts = [];
+    const b = bootEditor({ answers: {
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+      'PUT /copy-desk/pages/landing:index/draft': (body) => { puts.push(body); return ok({ ok: true, outcome: 'saved' }); },
+    } });
+    await b.settle();
+    b.type('L0007', 'Log');
+    b.type('L0007', 'Log in');
+    assert.equal(b.el('tw-counter').textContent, '2 of 7 rewritten · saved', 'the count moves as you type');
+    assert.ok(b.el('tw-L0007-note').textContent === 'changes this on every page', 'a shared line keeps its note when changed');
+    assert.equal(puts.length, 0, 'debounced: nothing sent mid-word');
+    await b.flushTimers();
+    // vm-born objects: compared through JSON, never by prototype.
+    assert.equal(JSON.stringify(puts), JSON.stringify([{ reading_hash: 'rh-1', lines: [{ key: 'L0004', after: 'Agents write the code.' }, { key: 'L0007', after: 'Log in' }] }]));
+    assert.equal(b.el('tw-counter').textContent, '2 of 7 rewritten · saved');
+    // Nothing changed since: a second flush sends nothing.
+    b.el('tw-L0007').value = 'Log in';
+    await b.flushTimers();
+    assert.equal(puts.length, 1);
+  });
+
+  await test('a refused save says so in the counter and in the server\'s words', async () => {
+    const b = bootEditor({ answers: {
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+      'PUT /copy-desk/pages/landing:index/draft': { status: 409, ok: false, data: { error: { code: 'page_not_held', details: { what_this_means: 'Bob holds this page now, so only they can change its draft.' } } } },
+    } });
+    await b.settle();
+    b.type('L0003', 'Build here,');
+    await b.flushTimers();
+    assert.equal(b.el('tw-counter').textContent, '2 of 7 rewritten · not saved');
+    assert.equal(b.el('tw-notice').hidden, false);
+    assert.match(b.el('tw-notice').innerHTML, /Bob holds this page now/);
+  });
+
+  await test('a page you do not hold is read-only, with the one thing to do: take it', async () => {
+    let claimed = 0;
+    const answers = {
+      'GET /copy-desk/pages/landing:index/draft': () => ok(claimed ? editorRead() : editorRead({ held: false, state: 'ready' })),
+      'POST /copy-desk/pages/landing:index/claim': () => { claimed++; return ok({ ok: true, outcome: 'claimed' }); },
+    };
+    const b = bootEditor({ answers });
+    await b.settle();
+    assert.ok(b.lines().every((t) => t.readOnly));
+    assert.equal(b.el('tw-submit').disabled, true);
+    assert.ok(b.el('tw-claim'), 'the notice carries the take button');
+    await b.click('tw-claim');
+    await b.settle();
+    assert.equal(claimed, 1);
+    assert.equal(b.lines().some((t) => t.readOnly), false, 'taken: the words are yours to type over');
+    assert.equal(b.el('tw-notice').hidden, true);
+  });
+
+  await test('someone else writing it: read-only, and named', async () => {
+    const b = bootEditor({ answers: { 'GET /copy-desk/pages/landing:index/draft': ok(editorRead({ holder: '8' })) } });
+    await b.settle();
+    assert.ok(b.lines().every((t) => t.readOnly));
+    assert.match(b.el('tw-notice').innerHTML, /bob is writing this page now/);
+    assert.equal(b.el('tw-claim'), null);
+  });
+
+  await test('the Word upload lands its lines in the boxes and says how many', async () => {
+    const b = bootEditor({ answers: {
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+      'FETCH POST /copy-desk/pages/landing:index/draft.docx': ok({ ok: true, draft: { lines: [{ key: 'L0003', after: 'Build here,' }, { key: 'L0004', after: 'Agents write the code.' }] }, merge: { from_file: ['L0003'], kept_from_draft: ['L0004'] } }),
+    } });
+    await b.settle();
+    b.el('tw-file').fire('change', { target: { files: [{ type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' }], value: 'x' } });
+    await b.settle();
+    assert.equal(b.fetches[0].url, '/api/bongos/copy-desk/pages/landing:index/draft.docx');
+    assert.equal(b.fetches[0].init.method, 'POST');
+    assert.equal(b.el('tw-L0003').value, 'Build here,');
+    assert.equal(b.el('tw-upload').textContent, 'uploaded · 1 line from your doc');
+    assert.equal(b.el('tw-counter').textContent, '2 of 7 rewritten · saved');
+  });
+
+  await test('a refused upload names each moved line, escaped', async () => {
+    const b = bootEditor({ answers: {
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+      'FETCH POST /copy-desk/pages/landing:index/draft.docx': { ok: false, data: { error: { code: 'structure_changed', details: { what_this_means: 'The file\'s lines no longer match the page.', moved: [{ change: 'added', key: null, section: 'hero', first_words: '<b>new</b> line' }] } } } },
+    } });
+    await b.settle();
+    b.el('tw-file').fire('change', { target: { files: [{ type: '' }], value: 'x' } });
+    await b.settle();
+    const html = b.el('tw-notice').innerHTML;
+    assert.match(html, /no longer match the page/);
+    assert.match(html, /hero: “&lt;b&gt;new&lt;\/b&gt; line” \(added\)/);
+    assert.equal(b.el('tw-notice').querySelectorAll('b').length, 0);
+  });
+
+  await test('submit: saves first, then "Home is in.", next up, and take next opens the next page', async () => {
+    const order = [];
+    const b = bootEditor({ answers: {
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+      'PUT /copy-desk/pages/landing:index/draft': () => { order.push('save'); return ok({ ok: true }); },
+      'POST /copy-desk/pages/landing:index/submit': () => { order.push('submit'); return ok({ ok: true, outcome: 'submitted', next: { path: '/copy-desk/next' } }); },
+      'GET /copy-desk/next': ok(NEXT),
+      'POST /copy-desk/pages/landing:projects/claim': () => { order.push('take'); return ok({ ok: true, outcome: 'created' }); },
+    } });
+    await b.settle();
+    b.type('L0003', 'Build here,');
+    await b.click('tw-submit');
+    await b.settle();
+    assert.deepEqual(order, ['save', 'submit'], 'the pending words are saved before the page is frozen');
+    assert.equal(b.el('tw-done').hidden, false);
+    assert.equal(b.el('tw-done-title').textContent, 'Home is in.');
+    assert.equal(b.el('tw-next-title').textContent, 'Projects');
+    assert.equal(b.el('tw-next-why').textContent, 'landing · 2 people asked for it');
+    assert.ok(b.lines().every((t) => t.readOnly), 'a submitted page is frozen');
+    assert.equal(b.el('tw-paper').inert, true);
+    assert.equal(b.el('tw-pick').hidden, false);
+    await b.click('tw-take');
+    assert.deepEqual(order, ['save', 'submit', 'take']);
+    assert.equal(b.navigated, '/builders/tweak-editor?page=landing:projects');
+  });
+
+  await test('pick another swaps next up in place, and take next takes that one', async () => {
+    let taken = null;
+    const b = bootEditor({ answers: {
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+      'POST /copy-desk/pages/landing:index/submit': ok({ ok: true, outcome: 'submitted' }),
+      'GET /copy-desk/next': ok(NEXT),
+      'POST /copy-desk/pages/builders:home/claim': () => { taken = 'builders:home'; return ok({ ok: true }); },
+    } });
+    await b.settle();
+    await b.click('tw-submit');
+    await b.settle();
+    await b.click('tw-pick');
+    assert.equal(b.el('tw-picks').hidden, false);
+    assert.deepEqual(b.el('tw-picks').querySelectorAll('button').map((x) => x.textContent), ['Home']);
+    const chip = b.el('tw-picks').querySelectorAll('button')[0];
+    await b.clickEl(chip);
+    assert.equal(b.el('tw-next-title').textContent, 'Home');
+    assert.equal(b.el('tw-next-why').textContent, 'builders hall · untweaked');
+    assert.equal(b.el('tw-picks').hidden, true);
+    await b.click('tw-take');
+    assert.equal(taken, 'builders:home');
+    assert.equal(b.navigated, '/builders/tweak-editor?page=builders:home');
+  });
+
+  await test('a refused submit names each line and freezes nothing', async () => {
+    const b = bootEditor({ answers: {
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+      'POST /copy-desk/pages/landing:index/submit': { status: 409, ok: false, data: { error: { code: 'lines_refused', details: { what_this_means: 'Some lines cannot be frozen as written.', refused: [{ key: 'L0004', section: 'hero', before: 'AI agents claim tasks and ship the code.', code: 'target_gone' }] } } } },
+    } });
+    await b.settle();
+    await b.click('tw-submit');
+    await b.settle();
+    assert.equal(b.el('tw-done').hidden, true);
+    assert.match(b.el('tw-notice').innerHTML, /hero: “AI agents claim tasks and ship the code.” \(target gone\)/);
+    assert.equal(b.el('tw-submit').disabled, false);
+    assert.equal(b.lines().some((t) => t.readOnly), false);
+  });
+
+  await test('no page named: the page you hold opens (resume)', async () => {
+    const b = bootEditor({ search: '', answers: {
+      'GET /copy-desk/next': ok({ ...NEXT, resume: { page_id: 'landing:index', take: { path: '/copy-desk/pages/landing:index/claim' } } }),
+      'GET /copy-desk/pages/landing:index/draft': ok(editorRead()),
+    } });
+    await b.settle();
+    assert.equal(b.replaced, '?page=landing:index');
+    assert.equal(b.lines().length, 7);
+  });
+
+  // ── the page's contract with the hall ────────────────────────────────────
+  await test('the markup: one h1, the shell\'s full-screen switch, the lib before the page, no web font', () => {
+    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.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`);
+    }
+    assert.match(HTML, />← studio</);
+    assert.match(HTML, />submit page</);
+    assert.match(HTML, />back to the studio</);
+  });
+
+  await test('the page writes only the copy-desk routes it names', () => {
+    const js = read('tweak-editor.js');
+    const writes = [...js.matchAll(/api\.request\('(POST|PUT|PATCH|DELETE)', ([^,]+),/g)].map((m) => `${m[1]} ${m[2]}`);
+    assert.deepEqual(writes.sort(), [
+      'POST WRITES.claim(p.take.path)', 'POST WRITES.claim(path)', 'POST WRITES.submit(st.pageId)', 'PUT WRITES.draft(st.pageId)',
+    ].sort());
+    const fetchCalls = [...js.matchAll(/fetch\(([^,]+),/g)].map((m) => m[1]);
+    assert.deepEqual(fetchCalls.sort(), ['WRITES.draft(st.pageId)', 'WRITES.upload(st.pageId)']);
+    assert.match(js, /const WRITES = Object\.freeze\(\{\n    draft: \(id\) => `\$\{API\}\/copy-desk\/pages\/\$\{id\}\/draft`,\n    upload: \(id\) => `\$\{API\}\/copy-desk\/pages\/\$\{id\}\/draft\.docx`,\n    submit: \(id\) => `\$\{API\}\/copy-desk\/pages\/\$\{id\}\/submit`,/);
+  });
+} finally {
+  summary();
+}