@bongos/core 1.19.1060 → 1.19.1062

package/tests/copy_desk_page_docx.mjs

@@ -0,0 +1,279 @@
+// tests/copy_desk_page_docx.mjs — download a page as .docx, edit it the way
+// Word stores an edit, and upload it back into the draft, the WHOLE path (task
+// 1004320 / BV2.TW09, ADR 0341 D12).
+//
+// The done-when: a round trip with edits lands those edits in the draft, and a
+// structure-changing upload is refused by name.
+//
+// Driven through the real copy-desk routes (with the real raw-body parser and
+// its cap), the real lifecycle port (the page claim, updateHeldTaskDescription,
+// submitPageTweak, createTask) and the real page reads, against the shared
+// stateful fake ledger (tests/fixtures/page-ledger.mjs). The reading is a file
+// on disk, read through the real page-data.js. The file is edited by the
+// Word-shaped fixture, which re-packs it with its own zip writer.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { makeRunner } from './helpers.mjs';
+import { installPageLedger } from './fixtures/page-ledger.mjs';
+import { resave, typeInto, wordRuns, lineParagraph } from '../modules/copy-desk/tests/fixtures/word-docx.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const F = require('../modules/copy-desk/tests/fixtures/page-tweak.cjs');
+const pages = require('../modules/copy-desk/pages.js');
+const docx = require('../modules/copy-desk/docx.js');
+const api = require('../src/module-api.js');
+
+const { db } = installPageLedger(api, {
+  builders: [
+    { id: '7', github_login: 'alice', display_name: 'Alice', preferred_disciplines: ['artist'] },
+    { id: '8', github_login: 'bob', display_name: 'Bob', preferred_disciplines: ['artist'] },
+  ],
+});
+const ALICE = '7';
+const BOB = '8';
+
+api.requireBuilder = (req, res, next) => {
+  req.builder = { id: String(req.headers['x-builder'] || ALICE), rank: 'metic' };
+  next();
+};
+
+const seams = require('../src/module-seams.js');
+const lifecyclePort = require('../modules/lifecycle/lifecycle.js');
+if (!seams.hasProvider('lifecycle')) seams.registerProvider('lifecycle', lifecyclePort);
+
+const pageData = require('../modules/copy-desk/page-data.js');
+const express = require('express');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildRouter = require('../modules/copy-desk/routes/copy-desk.js');
+
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const base = `http://127.0.0.1:${server.address().port}`;
+
+async function call(method, p, builder, body = {}) {
+  const r = await fetch(base + p, { method, headers: { 'content-type': 'application/json', 'x-builder': builder }, body: method === 'GET' ? undefined : JSON.stringify(body) });
+  return { status: r.status, body: await r.json() };
+}
+async function getDocx(p, builder) {
+  const r = await fetch(base + p, { headers: { 'x-builder': builder } });
+  return { status: r.status, headers: r.headers, buf: Buffer.from(await r.arrayBuffer()) };
+}
+async function putDocx(p, builder, buf, type = docx.DOCX_MIME) {
+  const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': type, 'x-builder': builder }, body: buf });
+  return { status: r.status, body: await r.json() };
+}
+const errCode = (b) => (b && b.error && b.error.code) || null;
+const errDetail = (b) => (b && b.error && b.error.details) || {};
+
+const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
+const STUDIO_LINES = [
+  L('L0001', 'top bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
+  L('L0002', 'top bar', 'Ctrl K', 'shared'),
+  L('L0003', 'greeting', 'Welcome back', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 12, string_id: 'st0003' }),
+  L('L0004', 'greeting', '{…} pages tweaked', 'placed', { file: 'modules/hall-ui/public/studio.js', line: 88, string_id: 'st0004' }),
+  L('L0005', 'greeting', 'Your desk is quiet today', 'unplaced'),
+  L('L0006', 'footer', 'Resume where you left off', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 90, string_id: 'st0006' }),
+];
+const INDEX_LINES = [
+  L('L0001', 'hero', 'Build here', 'placed', { file: 'modules/public-landing/public/index.html', line: 3, string_id: 'ix0001' }),
+];
+const readingsWith = (studioHash) => ({
+  schema: 1,
+  pages: [
+    { id: 'builders:studio', reading_hash: studioHash, lines: STUDIO_LINES },
+    { id: 'landing:index', reading_hash: 'index-h1', lines: INDEX_LINES },
+  ],
+});
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'page-docx-'));
+fs.mkdirSync(path.join(tmp, 'docs'), { recursive: true });
+fs.writeFileSync(path.join(tmp, 'docs/page-inventory.json'), JSON.stringify(F.INVENTORY));
+function writeReadings(r) {
+  fs.writeFileSync(path.join(tmp, 'docs/page-readings.json'), JSON.stringify(r));
+  pageData._setRoot(tmp); // drop the (mtime, size) cache
+}
+
+const { test, summary } = makeRunner();
+const STUDIO = '/copy-desk/pages/builders:studio';
+const INDEX = '/copy-desk/pages/landing:index';
+const studioTask = () => db.tasks.find((t) => t.source_ref === 'page-tweak/builders:studio/r1');
+const draftLines = () => pages.parseDraftBlock(studioTask().description).draft.lines.map((l) => [l.key, l.before, l.after]);
+let downloaded = null;
+
+try {
+  writeReadings(readingsWith('studio-h1'));
+
+  await test('the download works before anyone claims the page: the reading, as a Word file', async () => {
+    const r = await getDocx(`${INDEX}/draft.docx`, BOB);
+    assert.equal(r.status, 200);
+    assert.equal(r.headers.get('content-type'), docx.DOCX_MIME);
+    assert.equal(r.headers.get('content-disposition'), 'attachment; filename="tweak-landing-index.docx"');
+    const u = docx.readUpload(r.buf);
+    assert.equal(u.ok, true);
+    assert.equal(u.page_id, 'landing:index');
+    assert.deepEqual([...u.baseline], [['L0001', 'Build here']]);
+  });
+
+  await test('the download is built from the reading plus the artist\'s current draft', async () => {
+    assert.equal((await call('POST', `${STUDIO}/claim`, ALICE)).status, 201);
+    const saved = await call('PUT', `${STUDIO}/draft`, ALICE, { reading_hash: 'studio-h1', lines: [{ key: 'L0003', after: 'Welcome home' }] });
+    assert.equal(saved.body.outcome, 'saved');
+    const r = await getDocx(`${STUDIO}/draft.docx`, ALICE);
+    assert.equal(r.status, 200);
+    downloaded = r.buf;
+    const u = docx.readUpload(r.buf);
+    assert.deepEqual([u.page_id, u.reading_hash], ['builders:studio', 'studio-h1']);
+    assert.equal(u.baseline.get('L0003'), 'Welcome home', 'the draft rewrite, not the page text');
+    assert.equal(u.baseline.get('L0006'), 'Resume where you left off');
+    assert.deepEqual(u.paragraphs.filter((p) => p.tags.length).map((p) => p.tags[0]), STUDIO_LINES.map((l) => l.key));
+  });
+
+  await test('a round trip with edits (Word\'s split runs and smart quotes) lands those edits in the draft', async () => {
+    const writes = db.writes;
+    const edited = resave(downloaded, {
+      document: (xml) => typeInto(typeInto(xml, 'L0006', wordRuns(['Pick ', 'up where ', 'you’re ', 'at'])),
+        'L0004', wordRuns(['{…} ', 'pages rewritten'])),
+    });
+    const r = await putDocx(`${STUDIO}/draft.docx`, ALICE, edited);
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.equal(r.body.outcome, 'saved');
+    assert.deepEqual(r.body.merge, { mode: 'tag', baseline: true, from_file: ['L0004', 'L0006'], kept_from_draft: ['L0003'] });
+    assert.deepEqual(r.body.counter, { changed: 3, total: 6 });
+    assert.deepEqual(draftLines(), [
+      ['L0003', 'Welcome back', 'Welcome home'],
+      ['L0004', '{…} pages tweaked', '{…} pages rewritten'],
+      ['L0006', 'Resume where you left off', 'Pick up where you\'re at'],
+    ]);
+    // Into the DRAFT and nowhere else: one write, the round still writing,
+    // no frozen batch, one draft block, and the reading on disk untouched.
+    assert.equal(db.writes, writes + 1);
+    assert.equal(studioTask().status, 'active');
+    assert.equal(pages.blockPresence(studioTask().description).batch, false);
+    assert.equal((studioTask().description.match(/```page-tweak-draft/g) || []).length, 1);
+    assert.deepEqual(JSON.parse(fs.readFileSync(path.join(tmp, 'docs/page-readings.json'), 'utf8')), readingsWith('studio-h1'));
+  });
+
+  await test('the same upload again writes nothing', async () => {
+    const writes = db.writes;
+    const stamp = studioTask().updated_at;
+    const edited = resave(downloaded, {
+      document: (xml) => typeInto(typeInto(xml, 'L0006', wordRuns(['Pick ', 'up where ', 'you’re ', 'at'])),
+        'L0004', wordRuns(['{…} ', 'pages rewritten'])),
+    });
+    const r = await putDocx(`${STUDIO}/draft.docx`, ALICE, edited);
+    assert.equal(r.body.outcome, 'unchanged');
+    assert.equal(db.writes, writes);
+    assert.equal(studioTask().updated_at, stamp);
+  });
+
+  await test('a rewrite made in the studio after the download survives an upload of the older file', async () => {
+    // The artist keeps working in the studio (a whole-draft save), then
+    // uploads the file they downloaded earlier with one more Word edit.
+    const saved = await call('PUT', `${STUDIO}/draft`, ALICE, { reading_hash: 'studio-h1', lines: [{ key: 'L0003', after: 'Hello again' }, { key: 'L0005', after: 'Nothing is waiting' }] });
+    assert.equal(saved.body.outcome, 'saved');
+    const edited = resave(downloaded, { document: (xml) => typeInto(xml, 'L0001', wordRuns(['Your ', 'studio'])) });
+    const r = await putDocx(`${STUDIO}/draft.docx`, ALICE, edited);
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.deepEqual(r.body.merge.from_file, ['L0001']);
+    assert.deepEqual(draftLines().map(([k, , a]) => [k, a]), [
+      ['L0001', 'Your studio'],
+      ['L0003', 'Hello again'],
+      ['L0005', 'Nothing is waiting'],
+    ]);
+  });
+
+  await test('a structure-changing upload is refused by name, and nothing is saved', async () => {
+    const writes = db.writes;
+    const buf = resave(downloaded, {
+      document: (xml) => {
+        const p = lineParagraph(xml, 'L0003');
+        return xml.replace(lineParagraph(xml, 'L0005'), '').replace(p, () => `${p}<w:p><w:r><w:t>An extra thought</w:t></w:r></w:p>`);
+      },
+    });
+    const r = await putDocx(`${STUDIO}/draft.docx`, ALICE, buf);
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'structure_changed');
+    assert.deepEqual(errDetail(r.body).moved, [
+      { change: 'added', key: null, section: 'greeting', first_words: 'An extra thought' },
+      { change: 'dropped', key: 'L0005', section: 'greeting', first_words: 'Your desk is quiet today' },
+    ]);
+    assert.match(errDetail(r.body).what_this_means, /added, removed or moved/);
+    assert.equal(db.writes, writes);
+  });
+
+  await test('another page\'s file is wrong_page; a file from an older reading is reading_moved', async () => {
+    assert.equal((await call('POST', `${INDEX}/claim`, BOB)).status, 201);
+    const wrong = await putDocx(`${INDEX}/draft.docx`, BOB, downloaded);
+    assert.equal(wrong.status, 409);
+    assert.equal(errCode(wrong.body), 'wrong_page');
+    assert.equal(errDetail(wrong.body).file_page_id, 'builders:studio');
+
+    writeReadings(readingsWith('studio-h2'));
+    const moved = await putDocx(`${STUDIO}/draft.docx`, ALICE, downloaded);
+    assert.equal(moved.status, 409);
+    assert.equal(errCode(moved.body), 'reading_moved');
+    assert.deepEqual([errDetail(moved.body).reading_hash, errDetail(moved.body).file_reading_hash], ['studio-h2', 'studio-h1']);
+    writeReadings(readingsWith('studio-h1'));
+  });
+
+  await test('only the holder may upload: page_not_held names the holder', async () => {
+    const r = await putDocx(`${STUDIO}/draft.docx`, BOB, downloaded);
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'page_not_held');
+    assert.deepEqual(errDetail(r.body).holder, { id: ALICE, login: 'alice', name: 'Alice' });
+  });
+
+  await test('the upload is user input: anything not a .docx is refused, and the size is capped', async () => {
+    const writes = db.writes;
+    const json = await call('POST', `${STUDIO}/draft.docx`, ALICE, { lines: [] });
+    assert.equal(json.status, 415);
+    assert.equal(errCode(json.body), 'not_a_docx');
+    const text = await putDocx(`${STUDIO}/draft.docx`, ALICE, Buffer.from('hello'), 'text/plain');
+    assert.equal(errCode(text.body), 'not_a_docx');
+    const junk = await putDocx(`${STUDIO}/draft.docx`, ALICE, Buffer.from('not a zip at all'));
+    assert.equal(junk.status, 415);
+    assert.equal(errCode(junk.body), 'not_a_docx');
+    const zip = await putDocx(`${STUDIO}/draft.docx`, ALICE, docx.writeZip([{ name: 'notes.txt', data: 'hi' }]), 'application/zip');
+    assert.equal(errCode(zip.body), 'not_a_docx');
+    const big = await putDocx(`${STUDIO}/draft.docx`, ALICE, Buffer.alloc(docx.MAX_UPLOAD_BYTES + 1024, 7));
+    assert.equal(big.status, 413);
+    assert.equal(errCode(big.body), 'upload_too_large');
+    assert.equal(db.writes, writes);
+  });
+
+  await test('no round is no_open_round; after submit the draft is frozen, so an upload is page_in_flight', async () => {
+    const indexFile = (await getDocx(`${INDEX}/draft.docx`, BOB)).buf;
+    // Bob holds index; a page nobody opened a round on has nowhere to land.
+    const inv = F.INVENTORY.pages.find((p) => p.id !== 'builders:studio' && p.id !== 'landing:index');
+    assert.ok(inv, 'the fixture inventory has a page with no round');
+    const readings = readingsWith('studio-h1');
+    readings.pages.push({ id: inv.id, reading_hash: 'x-h1', lines: [L('L0001', 'hero', 'Hi', 'placed', { file: 'f', line: 1, string_id: 's' })] });
+    writeReadings(readings);
+    const other = (await getDocx(`/copy-desk/pages/${inv.id}/draft.docx`, BOB)).buf;
+    const none = await putDocx(`/copy-desk/pages/${inv.id}/draft.docx`, BOB, other);
+    assert.equal(errCode(none.body), 'no_open_round');
+    writeReadings(readingsWith('studio-h1'));
+    const edited = resave(indexFile, { document: (xml) => typeInto(xml, 'L0001', wordRuns(['Build ', 'it here'])) });
+    assert.equal((await putDocx(`${INDEX}/draft.docx`, BOB, edited)).body.outcome, 'saved');
+    assert.equal((await call('POST', `${INDEX}/submit`, BOB)).body.outcome, 'submitted');
+    const after = await putDocx(`${INDEX}/draft.docx`, BOB, edited);
+    assert.equal(after.status, 409);
+    assert.equal(errCode(after.body), 'page_in_flight');
+    // The submitted batch carries the Word edit, with its target from the reading.
+    const t = db.tasks.find((x) => x.source_ref === 'page-tweak/landing:index/r1');
+    assert.deepEqual(pages.parseBatchBlock(t.description).batch.lines.map((l) => [l.key, l.file, l.before, l.after]),
+      [['L0001', 'modules/public-landing/public/index.html', 'Build here', 'Build it here']]);
+  });
+} finally {
+  server.close();
+  pageData._setRoot(null);
+}
+summary();

package/tests/copy_desk_page_submit.mjs

@@ -0,0 +1,289 @@
+// tests/copy_desk_page_submit.mjs — save a page draft, submit it, and split the
+// unplaced lines out, the WHOLE path (task 1004319 / BV2.TW08, ADR 0341 D4, D7).
+//
+// The done-when: draft save, submit and the unplaced split work end to end.
+//
+// Driven through the real copy-desk routes, the real lifecycle port (the page
+// claim, updateHeldTaskDescription, submitPageTweak, and the real createTask
+// under it) and the real page reads, against the shared stateful fake ledger
+// (tests/fixtures/page-ledger.mjs), whose page lock and task row lock are real
+// mutexes. The reading is a file on disk, read through the real page-data.js.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { makeRunner } from './helpers.mjs';
+import { installPageLedger } from './fixtures/page-ledger.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const F = require('../modules/copy-desk/tests/fixtures/page-tweak.cjs');
+const pages = require('../modules/copy-desk/pages.js');
+const api = require('../src/module-api.js');
+
+const { db, seen } = installPageLedger(api, {
+  builders: [
+    { id: '7', github_login: 'alice', display_name: 'Alice', preferred_disciplines: ['artist'] },
+    { id: '8', github_login: 'bob', display_name: 'Bob', preferred_disciplines: ['artist'] },
+  ],
+});
+const ALICE = '7';
+const BOB = '8';
+
+api.requireBuilder = (req, res, next) => {
+  req.builder = { id: String(req.headers['x-builder'] || ALICE), rank: 'metic' };
+  next();
+};
+
+const seams = require('../src/module-seams.js');
+const lifecyclePort = require('../modules/lifecycle/lifecycle.js');
+if (!seams.hasProvider('lifecycle')) seams.registerProvider('lifecycle', lifecyclePort);
+
+const pageData = require('../modules/copy-desk/page-data.js');
+const express = require('express');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildRouter = require('../modules/copy-desk/routes/copy-desk.js');
+
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const base = `http://127.0.0.1:${server.address().port}`;
+
+async function call(method, p, builder, body = {}) {
+  const r = await fetch(base + p, { method, headers: { 'content-type': 'application/json', 'x-builder': builder }, body: method === 'GET' ? undefined : JSON.stringify(body) });
+  return { status: r.status, body: await r.json() };
+}
+const errCode = (b) => (b && b.error && b.error.code) || null;
+const errDetail = (b) => (b && b.error && b.error.details) || {};
+
+// The studio reading, in page-reader.js's shape: a shared line with its
+// registry row, a shared line without one, placed lines, one with {…} holes,
+// and an unplaced line.
+const L = (key, section, text, placement, row) => ({ key, section, text, placement, ...(row || {}) });
+const STUDIO_LINES = [
+  L('L0001', 'top bar', 'Studio', 'shared', { file: 'modules/hall-ui/public/shell.js', line: 40, string_id: 'sh0001' }),
+  L('L0002', 'top bar', 'Ctrl K', 'shared'),
+  L('L0003', 'greeting', 'Welcome back', 'placed', { file: 'modules/hall-ui/public/studio.html', line: 12, string_id: 'st0003' }),
+  L('L0004', 'greeting', '{…} pages tweaked', 'placed', { file: 'modules/hall-ui/public/studio.js', line: 88, string_id: 'st0004' }),
+  L('L0005', 'greeting', 'Your desk is quiet today', 'unplaced'),
+];
+const INDEX_LINES = [
+  L('L0001', 'hero', 'Build here', 'placed', { file: 'modules/public-landing/public/index.html', line: 3, string_id: 'ix0001' }),
+  L('L0002', 'hero', 'Start a project', 'placed', { file: 'modules/public-landing/public/index.html', line: 4, string_id: 'ix0002' }),
+];
+const readingsWith = (studio, index) => ({
+  schema: 1,
+  pages: [
+    { id: 'builders:studio', reading_hash: studio.hash, lines: studio.lines },
+    { id: 'landing:index', reading_hash: index.hash, lines: index.lines },
+  ],
+});
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'page-submit-'));
+fs.mkdirSync(path.join(tmp, 'docs'), { recursive: true });
+fs.writeFileSync(path.join(tmp, 'docs/page-inventory.json'), JSON.stringify(F.INVENTORY));
+function writeReadings(r) {
+  fs.writeFileSync(path.join(tmp, 'docs/page-readings.json'), JSON.stringify(r));
+  pageData._setRoot(tmp); // drop the (mtime, size) cache
+}
+
+const { test, summary } = makeRunner();
+const STUDIO = '/copy-desk/pages/builders:studio';
+const INDEX = '/copy-desk/pages/landing:index';
+const studioTask = () => db.tasks.find((t) => t.source_ref === 'page-tweak/builders:studio/r1');
+const DRAFT = {
+  reading_hash: 'studio-h1',
+  lines: [
+    { key: 'L0003', after: 'Welcome home' },
+    { key: 'L0004', after: '{…} pages rewritten so far' },
+    { key: 'L0005', after: 'Nothing is waiting for you' },
+    { key: 'L0002', after: 'Control K' },
+  ],
+};
+
+try {
+  writeReadings(readingsWith({ hash: 'studio-h1', lines: STUDIO_LINES }, { hash: 'index-h1', lines: INDEX_LINES }));
+
+  await test('no round yet: a draft save is no_open_round, and nothing is written', async () => {
+    const r = await call('PUT', `${STUDIO}/draft`, ALICE, DRAFT);
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'no_open_round');
+    assert.equal(db.tasks.length, 0);
+  });
+
+  await test('the holder saves a draft: it rests on the round task, resolved from the reading', async () => {
+    assert.equal((await call('POST', `${STUDIO}/claim`, ALICE)).status, 201);
+    const r = await call('PUT', `${STUDIO}/draft`, ALICE, DRAFT);
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.equal(r.body.outcome, 'saved');
+    assert.deepEqual(r.body.counter, { changed: 4, total: 5 });
+    const parsed = pages.parseDraftBlock(studioTask().description);
+    assert.equal(parsed.ok, true);
+    assert.deepEqual(parsed.draft.lines.map((l) => [l.key, l.before, l.after, l.placement]), [
+      ['L0002', 'Ctrl K', 'Control K', 'shared'],
+      ['L0003', 'Welcome back', 'Welcome home', 'placed'],
+      ['L0004', '{…} pages tweaked', '{…} pages rewritten so far', 'placed'],
+      ['L0005', 'Your desk is quiet today', 'Nothing is waiting for you', 'unplaced'],
+    ]);
+    assert.match(studioTask().description, /^Page tweak round 1/, 'the round body stays; the block is added below it');
+    assert.equal(studioTask().status, 'active');
+  });
+
+  await test('the same autosave again writes nothing: unchanged, and the task is not touched', async () => {
+    const writes = db.writes;
+    const stamp = studioTask().updated_at;
+    const before = seen.length;
+    const r = await call('PUT', `${STUDIO}/draft`, ALICE, DRAFT);
+    assert.equal(r.status, 200);
+    assert.equal(r.body.outcome, 'unchanged');
+    assert.equal(db.writes, writes);
+    assert.equal(studioTask().updated_at, stamp);
+    assert.equal(seen.slice(before).some((q) => /^UPDATE tasks/.test(q)), false);
+    // The save reads this page's rounds only, never the whole instance's.
+    assert.equal(db.pageScopes[db.pageScopes.length - 1], 'page-tweak/builders:studio/');
+  });
+
+  await test('a whole-draft replace: a line left out of the next save leaves the draft', async () => {
+    const r = await call('PUT', `${STUDIO}/draft`, ALICE, { ...DRAFT, lines: DRAFT.lines.slice(0, 3) });
+    assert.equal(r.body.outcome, 'saved');
+    assert.deepEqual(pages.parseDraftBlock(studioTask().description).draft.lines.map((l) => l.key), ['L0003', 'L0004', 'L0005']);
+    const back = await call('PUT', `${STUDIO}/draft`, ALICE, DRAFT);
+    assert.equal(back.body.outcome, 'saved');
+    assert.equal((studioTask().description.match(/```page-tweak-draft/g) || []).length, 1, 'replaced in place, never a second block');
+  });
+
+  await test('another artist cannot save it: page_not_held, naming the holder', async () => {
+    const r = await call('PUT', `${STUDIO}/draft`, BOB, DRAFT);
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'page_not_held');
+    assert.deepEqual(errDetail(r.body).holder, { id: ALICE, login: 'alice', name: 'Alice' });
+  });
+
+  await test('a draft built on an older reading is refused reading_moved, and nothing is written', async () => {
+    const writes = db.writes;
+    const r = await call('PUT', `${STUDIO}/draft`, ALICE, { ...DRAFT, reading_hash: 'studio-h0' });
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'reading_moved');
+    assert.equal(errDetail(r.body).reading_hash, 'studio-h1');
+    assert.equal(db.writes, writes);
+  });
+
+  await test('the body is strict: a target field at the top level is refused', async () => {
+    const r = await call('PUT', `${STUDIO}/draft`, ALICE, { ...DRAFT, file: 'modules/hall-ui/public/studio.html' });
+    assert.equal(errCode(r.body), 'validation_failed');
+  });
+
+  await test('another artist cannot submit it', async () => {
+    const r = await call('POST', `${STUDIO}/submit`, BOB);
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'page_not_held');
+    assert.equal(pages.blockPresence(studioTask().description).batch, false);
+  });
+
+  await test('submit freezes the batch, files an engineer task per unplaced line, and releases the claim', async () => {
+    const r = await call('POST', `${STUDIO}/submit`, ALICE);
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.equal(r.body.outcome, 'submitted');
+    assert.deepEqual(r.body.round, { task_id: studioTask().id, state: 'submitted', status: 'ready' });
+    assert.equal(r.body.batch.line_count, 2);
+    assert.deepEqual(r.body.next, { path: '/copy-desk/next' });
+
+    // The batch: placed lines with their registry rows, from the reading.
+    const b = pages.parseBatchBlock(studioTask().description);
+    assert.equal(b.ok, true);
+    assert.deepEqual(b.batch.lines.map((l) => [l.key, l.file, l.line, l.string_id, l.before, l.after]), [
+      ['L0003', 'modules/hall-ui/public/studio.html', 12, 'st0003', 'Welcome back', 'Welcome home'],
+      ['L0004', 'modules/hall-ui/public/studio.js', 88, 'st0004', '{…} pages tweaked', '{…} pages rewritten so far'],
+    ]);
+    assert.equal(b.batch.reading_hash, 'studio-h1');
+
+    // The unplaced split: the unplaced line, and the shared line with no row.
+    const eng = db.tasks.filter((t) => t.source === 'page-tweak-unplaced');
+    assert.deepEqual(eng.map((t) => t.source_ref).sort(), [
+      `page-tweak-unplaced/${studioTask().id}/L0002`,
+      `page-tweak-unplaced/${studioTask().id}/L0005`,
+    ]);
+    for (const t of eng) {
+      assert.deepEqual([t.status, t.discipline, t.kind, t.version_id, t.goal_id, t.created_by], ['backlog', 'engineer', 'feature', 'V9', '77', ALICE]);
+      assert.match(t.description, /builders:studio/);
+    }
+    const quiet = eng.find((t) => t.source_ref.endsWith('/L0005'));
+    assert.match(quiet.description, /"Your desk is quiet today"/);
+    assert.match(quiet.description, /"Nothing is waiting for you"/);
+    assert.deepEqual([...b.batch.unplaced_tasks].sort(), eng.map((t) => t.id).sort(), 'the batch names the engineer tasks');
+    assert.deepEqual(r.body.unplaced_tasks.map((u) => u.created), [true, true]);
+
+    // The claim is released and the round is ready: the /tweak queue.
+    assert.equal(studioTask().status, 'ready');
+    const claim = db.claims.find((c) => c.task_id === studioTask().id);
+    assert.ok(claim.released_at, 'the web claim is released');
+    assert.equal(claim.outcome, 'partial');
+    // The draft stays beside the batch (ADR 0341 D7: it may be amended later).
+    assert.equal(pages.parseDraftBlock(studioTask().description).ok, true);
+  });
+
+  await test('the page reads submitted, and nobody can claim it back into writing', async () => {
+    const page = await call('GET', STUDIO, BOB);
+    assert.equal(page.status, 200);
+    assert.equal(page.body.open_round.state, 'submitted');
+    const claim = await call('POST', `${STUDIO}/claim`, BOB);
+    assert.equal(errCode(claim.body), 'page_in_flight');
+  });
+
+  await test('a repeated submit is already_submitted: no second batch, no second engineer task', async () => {
+    const tasks = db.tasks.length;
+    const r = await call('POST', `${STUDIO}/submit`, ALICE);
+    assert.equal(r.status, 200);
+    assert.equal(r.body.outcome, 'already_submitted');
+    assert.equal(r.body.unplaced_tasks.length, 2);
+    assert.equal(db.tasks.length, tasks);
+    assert.equal((studioTask().description.match(/```page-tweak\n/g) || []).length, 1);
+  });
+
+  await test('after submit the draft is frozen: a save is page_in_flight', async () => {
+    const r = await call('PUT', `${STUDIO}/draft`, ALICE, DRAFT);
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'page_in_flight');
+  });
+
+  await test('a line whose reading moved is refused target_gone at submit; the round stays with its artist', async () => {
+    assert.equal((await call('POST', `${INDEX}/claim`, BOB)).status, 201);
+    const saved = await call('PUT', `${INDEX}/draft`, BOB, { reading_hash: 'index-h1', lines: [{ key: 'L0001', after: 'Build it here' }, { key: 'L0002', after: 'Start yours' }] });
+    assert.equal(saved.body.outcome, 'saved');
+    // A ship rewords the hero line: the page no longer shows "Build here".
+    writeReadings(readingsWith({ hash: 'studio-h1', lines: STUDIO_LINES }, {
+      hash: 'index-h2',
+      lines: [L('L0001', 'hero', 'Build anything here', 'placed', { file: 'x', line: 3, string_id: 'ix0009' }), INDEX_LINES[1]],
+    }));
+    const writes = db.writes;
+    const r = await call('POST', `${INDEX}/submit`, BOB);
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'lines_refused');
+    assert.deepEqual(errDetail(r.body).refused, [{ key: 'L0001', section: 'hero', before: 'Build here', code: 'target_gone' }]);
+    const t = db.tasks.find((x) => x.source_ref === 'page-tweak/landing:index/r1');
+    assert.equal(t.status, 'active');
+    assert.equal(pages.blockPresence(t.description).batch, false);
+    assert.equal(db.writes, writes);
+    assert.ok(db.claims.find((c) => c.task_id === t.id && c.released_at == null), 'the claim is still held');
+  });
+
+  await test('two submits at once: one freezes, the other is the same double-click, and one engineer task per line', async () => {
+    // Bob drops the gone line on the current reading, adds an unplaced-free
+    // rewrite, and double-submits.
+    const t = db.tasks.find((x) => x.source_ref === 'page-tweak/landing:index/r1');
+    const saved = await call('PUT', `${INDEX}/draft`, BOB, { reading_hash: 'index-h2', lines: [{ key: 'L0002', after: 'Start yours' }] });
+    assert.equal(saved.body.outcome, 'saved');
+    const [a, b] = await Promise.all([call('POST', `${INDEX}/submit`, BOB), call('POST', `${INDEX}/submit`, BOB)]);
+    assert.deepEqual([a.body.outcome, b.body.outcome].sort(), ['already_submitted', 'submitted'], JSON.stringify([a.body, b.body]));
+    assert.equal((t.description.match(/```page-tweak\n/g) || []).length, 1);
+    assert.equal(t.status, 'ready');
+  });
+} finally {
+  server.close();
+  pageData._setRoot(null);
+}
+summary();

package/tests/fitness.mjs

@@ -922,9 +922,14 @@ test('write-route validation check actually CATCHES an unvalidated write route (
   assert.ok(/POST \/widgets/.test(flagged[0]), 'the offending route is named');
 });
 
-test('write-route validation exemptions are the known dynamic-key prefs routes only', () => {
+test('write-route validation exemptions are the known dynamic-key prefs routes, plus the one raw-file upload', () => {
+  // The .docx upload (task 1004320) has no JSON body to hold a field schema: its
+  // body is the file's bytes, capped by the route's parser and read by
+  // docx.readUpload. Named here so a second raw-body exemption is a reviewed diff.
+  const RAW_FILE_UPLOADS = ['POST /copy-desk/pages/:pageId/draft.docx'];
   const exempt = [...fitness.WRITE_VALIDATION_EXEMPT];
-  assert.ok(exempt.length >= 1 && exempt.every((e) => e.startsWith('PATCH /me/')), 'exemptions are all /me/* prefs patches: ' + exempt.join(', '));
+  assert.ok(exempt.length >= 1 && exempt.every((e) => e.startsWith('PATCH /me/') || RAW_FILE_UPLOADS.includes(e)),
+    'exemptions are all /me/* prefs patches or a named raw-file upload: ' + exempt.join(', '));
 });
 
 test('identity gate strips comments on CRLF checkouts too (task 1002428)', () => {

package/tests/fixtures/page-ledger.mjs

@@ -11,7 +11,8 @@
 // An unknown statement THROWS: a route that sends SQL this ledger does not
 // model fails loudly instead of reading an empty answer.
 //
-// Shared by tests/copy_desk_page_claim.mjs and tests/copy_desk_page_next.mjs
+// Shared by tests/copy_desk_page_claim.mjs, tests/copy_desk_page_next.mjs and
+// tests/copy_desk_page_submit.mjs
 // (a fixture, not a test: the runner discovers tests/*.mjs only).
 
 import { strict as assert } from 'node:assert';
@@ -120,10 +121,40 @@ export function installPageLedger(api, { builders }) {
     if (/^SELECT id, name, status, scope_doc_path, started_at, shipped_at, done_when FROM versions/.test(q)) {
       return { rows: db.building ? [{ id: 'V9', name: 'V9', status: 'building' }] : [{ id: 'V8', name: 'V8', status: 'shipped' }] };
     }
+    // The draft save and the submit (task 1004319 / TW08,
+    // modules/lifecycle/page-tweak-write.js). The task row lock is a real
+    // mutex too, so a raced second submit waits for the first to commit.
+    if (/^SELECT id, status, title, description, source, source_ref, version_id, goal_id, touches FROM tasks WHERE id = \$1 FOR UPDATE$/.test(q)) {
+      assert.ok(owner, 'the task row must be locked on the transaction client');
+      await lock(`task:${p[0]}`, owner);
+      const t = db.tasks.find((x) => String(x.id) === String(p[0]));
+      return { rows: t ? [{ ...t }] : [] };
+    }
+    if (/^UPDATE tasks SET description = \$2, (status = 'ready', )?updated_at = now\(\) WHERE id = \$1 RETURNING id, status, description, source_ref, updated_at$/.test(q)) {
+      assert.ok(owner, 'a description write runs inside the transaction');
+      const t = db.tasks.find((x) => String(x.id) === String(p[0]));
+      t.description = p[1];
+      if (/status = 'ready'/.test(q)) t.status = 'ready';
+      t.updated_at = new Date().toISOString();
+      db.writes = (db.writes || 0) + 1;
+      return { rows: [{ id: t.id, status: t.status, description: t.description, source_ref: t.source_ref, updated_at: t.updated_at }] };
+    }
+    if (/^SELECT id, source_ref FROM tasks WHERE source = \$1 AND source_ref = ANY\(\$2::text\[\]\)$/.test(q)) {
+      return { rows: db.tasks.filter((t) => t.source === p[0] && p[1].includes(t.source_ref)).map((t) => ({ id: t.id, source_ref: t.source_ref })) };
+    }
+    if (/^UPDATE claims SET released_at = now\(\), outcome = \$2 WHERE id = \$1 AND released_at IS NULL$/.test(q)) {
+      const c = db.claims.find((x) => String(x.id) === String(p[0]) && x.released_at == null);
+      if (c) Object.assign(c, { released_at: new Date().toISOString(), outcome: p[1] });
+      return { rows: [] };
+    }
     // The page reads (listPageTweakTasks), computed from the ledger's state.
     if (/FROM tasks t LEFT JOIN task_grades g/.test(q)) {
       assert.match(q, /WHERE t\.source = 'page-tweak'/);
-      return { rows: db.tasks.filter((t) => t.source === 'page-tweak').map(pageTweakRow) };
+      // The optional page scope (task 1004319): $1 is the round-ref prefix or null.
+      assert.match(q, /left\(t\.source_ref, length\(\$1::text\)\) = \$1::text/);
+      const prefix = p[0] == null ? null : String(p[0]);
+      (db.pageScopes = db.pageScopes || []).push(prefix);
+      return { rows: db.tasks.filter((t) => t.source === 'page-tweak' && (prefix == null || String(t.source_ref).startsWith(prefix))).map(pageTweakRow) };
     }
     // The flag SQL (the page ask).
     if (/FROM copy_desk_flags f WHERE f\.scope = 'page' AND f\.page_id = \$1 AND f\.flagged_by = \$2 AND f\.status = 'open'/.test(q)) {