@bongos/core 1.19.1060 → 1.19.1062

package/modules/copy-desk/routes/copy-desk.js

@@ -14,6 +14,9 @@
 // task 1004317): POST /copy-desk/pages/:pageId/claim opens or takes a page's
 // tweak round as a TASK with a web claim, and POST /copy-desk/pages/:pageId/asks
 // files a page ask, a flag row whose target is a page id. Neither stores copy.
+// TW08 (task 1004319) added the draft autosave and the submit, and TW09 (task
+// 1004320) the Word round trip, GET and POST /copy-desk/pages/:pageId/draft.docx:
+// the upload lands in the round's DRAFT, through the autosave's own port call.
 //
 // THE RANK SHAPE, AND WHY IT IS ASYMMETRIC:
 //
@@ -53,6 +56,7 @@ const proposals = require('../proposals');
 const pageData = require('../page-data');
 const pageStatus = require('../page-status');
 const pages = require('../pages');
+const docx = require('../docx');
 
 const { validateOrRespond } = api;
 
@@ -103,6 +107,133 @@ const CLAIM_BODY_SCHEMA = Object.freeze({});
 const ASK_BODY_SCHEMA = Object.freeze({
   reason: { required: true, type: 'string', maxLength: flags.MAX_REASON_CHARS, minLength: 1 },
 });
+// The draft autosave (task 1004319 / TW08): the reading the editor was built
+// on, and every changed line as { key, after }. Nothing else, and in
+// particular no `before`, `section`, `placement` or file: every fact about a
+// target is resolved from the page reading (pages.resolveDraft).
+const DRAFT_BODY_SCHEMA = Object.freeze({
+  reading_hash: { required: true, type: 'string', maxLength: 64, minLength: 1 },
+  lines:        { required: true, type: 'array', maxItems: pages.MAX_DRAFT_LINES },
+});
+// The submit takes nothing: it freezes the draft already on the task.
+const SUBMIT_BODY_SCHEMA = Object.freeze({});
+
+// The refusals of pages.resolveDraft / freezeBatch, as HTTP statuses.
+const PAGE_REFUSAL_STATUS = Object.freeze({
+  reading_missing: 503,
+  reading_moved: 409,
+  lines_refused: 409,
+  nothing_to_submit: 409,
+  multiple_blocks: 409,
+  block_unreadable: 409,
+  block_schema_unknown: 409,
+  block_field_missing: 409,
+  wrong_page: 409,
+  // The Word upload (task 1004320, ADR 0341 D12).
+  structure_changed: 409,
+  not_a_docx: 415,
+  upload_too_large: 413,
+});
+const PAGE_REFUSAL_MEANS = Object.freeze({
+  reading_moved: 'The page changed since the editor loaded it, so a line key may now mean a different line. Reload the page to get the current reading; nothing was saved.',
+  unknown_line: 'The page reading has no line with that key. Reload the editor.',
+  line_empty: 'A line cannot be rewritten to nothing. Removing text from a page is a code change; leave the line as it is or give it new words.',
+  line_too_long: `A line holds at most ${pages.MAX_LINE_CHARS} characters.`,
+  lines_refused: 'Some lines cannot be frozen as written: the page no longer shows them (target_gone), shows the same words in more than one place (ambiguous_target), or the rewrite dropped or added a {…} hole (placeholder_mismatch). Fix or remove each named line and submit again; nothing was submitted.',
+  nothing_to_submit: 'The draft has no rewritten lines yet.',
+  structure_changed: 'The file\'s lines no longer match the page: a paragraph was added, removed or moved, or a heading changed. Each one is listed. Put them back (one paragraph per line, in the page\'s order) or download the page again, and upload once more; nothing was saved.',
+  not_a_docx: 'Upload the .docx file this page downloaded, as the request body. Nothing was saved.',
+  upload_too_large: `A page file is at most ${Math.round(docx.MAX_UPLOAD_BYTES / (1024 * 1024))} MB. Nothing was saved.`,
+});
+// The upload's answers when the file is readable but is not this page's, or not
+// this reading's (task 1004320, ADR 0341 D12).
+const UPLOAD_WRONG_PAGE_MEANS = 'This file is not the download of this page, or the program that saved it dropped the page details Word keeps. Download this page again and make your changes in that file. Nothing was saved.';
+const UPLOAD_READING_MOVED_MEANS = 'The page has changed since this file was downloaded, so its lines may no longer line up with the page. Download the page again and copy your changes across. Nothing was saved.';
+
+// The upload's body is the .docx itself, never JSON (the global parser only
+// reads application/json, so it passes this through). Capped at the parser, and
+// never inflated from a Content-Encoding, so the cap is the bytes on the wire.
+const DOCX_BODY_TYPES = [docx.DOCX_MIME, 'application/zip', 'application/x-zip-compressed', 'application/octet-stream'];
+const rawDocxBody = express.raw({ type: DOCX_BODY_TYPES, limit: docx.MAX_UPLOAD_BYTES, inflate: false });
+function docxBody(req, res, next) {
+  rawDocxBody(req, res, (err) => {
+    if (!err) return next();
+    if (err.type === 'entity.too.large') return refusePage(res, { code: 'upload_too_large', detail: { max_bytes: docx.MAX_UPLOAD_BYTES } });
+    return refusePage(res, { code: 'not_a_docx', detail: { reason: 'the upload could not be read' } });
+  });
+}
+
+function refusePage(res, r) {
+  const status = PAGE_REFUSAL_STATUS[r.code] || 400;
+  const means = PAGE_REFUSAL_MEANS[r.code];
+  return res.fail(r.code, status, { ...(r.detail || {}), ...(means ? { what_this_means: means } : {}) });
+}
+
+// The page's reading, which every draft and batch target comes from. Returns
+// null when it has already responded.
+function readingPageOrFail(res, pageId) {
+  const readings = readingsState();
+  if (!readings.data) {
+    res.fail('readings_missing', 503, {
+      run: readings.info.run || 'node scripts/gds/page-reader.js',
+      what_this_means: 'A draft is resolved against the committed page readings, and this instance has none. Nothing was saved.',
+    });
+    return null;
+  }
+  const readingPage = (readings.data.pages || []).find((p) => p && p.id === pageId);
+  if (!readingPage) {
+    res.fail('page_unread', 503, {
+      page_id: pageId,
+      what_this_means: 'The page readings do not include this page yet, so there are no lines to resolve a draft against.',
+    });
+    return null;
+  }
+  return readingPage;
+}
+
+// The page's OPEN round, from the same read the page routes use.
+function openRoundOf(tasks, pageId) {
+  const open = (tasks || []).filter((t) => {
+    const ref = pages.parseRoundRef(t.source_ref);
+    return ref && ref.page_id === pageId && t.status !== 'shipped' && t.status !== 'abandoned';
+  });
+  return open.length ? open[open.length - 1] : null;
+}
+
+// The answer to a repeated submit: the round is in the queue (ready, a frozen
+// batch, nobody holding it) and the caller is its artist, the builder of its
+// latest web claim. Null when that is not the case.
+function alreadySubmitted(round, builderId, pageId) {
+  if (round.holder_id != null || round.status !== 'ready' || String(round.artist_id) !== String(builderId)) return null;
+  const b = pages.parseBatchBlock(round.description);
+  if (!b.ok) return null;
+  return {
+    ok: true, outcome: 'already_submitted', page_id: pageId,
+    round: { task_id: String(round.id), state: 'submitted', status: 'ready' },
+    batch: { line_count: b.batch.lines.length, submitted_at: b.batch.submitted_at, reading_hash: b.batch.reading_hash },
+    unplaced_tasks: (b.batch.unplaced_tasks || []).map((id) => ({ task_id: String(id) })),
+    next: { path: '/copy-desk/next' },
+  };
+}
+
+// The port's not_held outcome, as the answer the editor shows.
+function refuseNotHeld(res, pageId, r, round) {
+  // Nobody holds it and its batch is frozen: it is in the /tweak queue.
+  if (!r.holder && round && pages.blockPresence(round.description).batch) {
+    return res.fail('page_in_flight', 409, {
+      page_id: pageId,
+      what_this_means: 'This page has been submitted and is on its way to the site. Its draft is frozen until it ships or is sent back.',
+    });
+  }
+  const who = r.holder ? (r.holder.name || r.holder.login || 'Another builder') : null;
+  return res.fail('page_not_held', 409, {
+    page_id: pageId,
+    holder: r.holder ? { id: r.holder.id, login: r.holder.login, name: r.holder.name } : null,
+    what_this_means: who
+      ? `${who} holds this page now, so only they can change its draft.`
+      : 'You do not hold this page. Claim it again (POST /copy-desk/pages/:pageId/claim) and the draft is still there.',
+  });
+}
 
 // Load the registry or answer the named "no registry" state. Returns null when
 // it has already responded, so every handler is `if (!reg) return;`.
@@ -841,6 +972,342 @@ module.exports = function buildCopyDeskRouter() {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // PUT /copy-desk/pages/:pageId/draft — autosave the artist's draft (task
+  // 1004319 / BV2.TW08, ADR 0341 D4).
+  //
+  // Body: { reading_hash, lines: [{ key, after }] }, the WHOLE draft: every line
+  // the artist has changed. The saved draft becomes exactly that (a line sent
+  // back at its current text is dropped, so only changed lines are stored).
+  // rank: any signed-in builder; only the HOLDER of the page's writing claim
+  //       (the web claim the page claim took) may save, checked in the
+  //       lifecycle transaction.
+  //
+  // Every target is resolved from the page reading by key: section, current
+  // text (`before`) and placement are the reading's, never the body's. A body
+  // built on an older reading is refused `reading_moved`, whole, since its keys
+  // may now mean other lines.
+  //
+  // Cheap and idempotent: a save that resolves to the draft already stored
+  // writes nothing (200 `unchanged`; `updated_at` does not move). The editor
+  // debounces; the server only has to make a repeated save free.
+  //
+  //   200 saved | unchanged   with the draft and "N of M rewritten"
+  //   409 page_not_held       the caller does not hold the page (holder named)
+  //   409 no_open_round       the page has no round: claim it first
+  //   409 reading_moved · 400 unknown_line / line_empty / line_too_long
+  // -------------------------------------------------------------------------
+  router.put('/copy-desk/pages/:pageId/draft', api.requireBuilder, async (req, res) => {
+    try {
+      if (validateOrRespond(req, res, DRAFT_BODY_SCHEMA)) return;
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { pageId } = found;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      if (typeof lifecycle.updateHeldTaskDescription !== 'function') {
+        return res.fail('lifecycle_unavailable', 503, { what_this_means: 'This instance cannot save a page draft. Nothing was saved.' });
+      }
+      const readingPage = readingPageOrFail(res, pageId);
+      if (!readingPage) return;
+
+      const resolved = pages.resolveDraft({ readingPage, body: req.body, savedAt: new Date().toISOString() });
+      if (!resolved.ok) return refusePage(res, resolved);
+
+      const round = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+      if (!round) {
+        return res.fail('no_open_round', 409, {
+          page_id: pageId,
+          what_this_means: 'Nobody is writing this page. Claim it first (POST /copy-desk/pages/:pageId/claim).',
+        });
+      }
+
+      let draft = resolved.draft;
+      const r = await lifecycle.updateHeldTaskDescription({
+        taskId: round.id,
+        builderId: req.builder.id,
+        source: pages.SOURCE,
+        // The same draft again keeps the stored block (saved_at included) and
+        // writes nothing; see pages.saveDraftInto, which the upload shares.
+        compose: (task) => {
+          const s = pages.saveDraftInto(task.description, resolved.draft);
+          if (s.ok) draft = s.draft;
+          return s;
+        },
+      });
+      switch (r.outcome) {
+        case 'saved':
+        case 'unchanged':
+          return res.json({
+            ok: true,
+            outcome: r.outcome,
+            page_id: pageId,
+            round: { task_id: String(round.id), state: 'writing' },
+            draft: { reading_hash: draft.reading_hash, saved_at: draft.saved_at, lines: draft.lines },
+            // The editor's counter, "N of M rewritten · saved" (Editor.dc.html).
+            counter: { changed: draft.lines.length, total: readingPage.lines.length },
+          });
+        case 'not_held':
+          return refuseNotHeld(res, pageId, r, round);
+        case 'refused':
+          return refusePage(res, r.refusal);
+        default:
+          throw new Error(`updateHeldTaskDescription: unexpected outcome ${r.outcome}`);
+      }
+    } catch (err) {
+      log.error({ err }, 'PUT /copy-desk/pages/:pageId/draft failed');
+      if (!res.headersSent) res.fail('copy_page_draft_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // GET /copy-desk/pages/:pageId/draft.docx — download the page's words as a
+  // Word document, to work on offline (task 1004320 / BV2.TW09, ADR 0341 D12).
+  //
+  // The file is built from the page reading plus the open round's draft (a line
+  // the artist has rewritten shows its rewrite). A draft saved on an older
+  // reading is not shown, since its keys may now name other lines.
+  // rank: any signed-in builder. The words are the page's own, and the draft is
+  //       on a task description every builder can already read; only the
+  //       upload is the holder's.
+  // -------------------------------------------------------------------------
+  router.get('/copy-desk/pages/:pageId/draft.docx', api.requireBuilder, async (req, res) => {
+    try {
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { page, pageId } = found;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      const readingPage = readingPageOrFail(res, pageId);
+      if (!readingPage) return;
+      const round = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+      const d = round ? pages.parseDraftBlock(round.description) : null;
+      const file = docx.composeDownload({ readingPage, title: page.title, draft: d && d.ok ? d.draft : null });
+      res.set('Content-Type', docx.DOCX_MIME);
+      res.set('Content-Disposition', `attachment; filename="${docx.downloadName(pageId)}"`);
+      res.set('Cache-Control', 'no-store');
+      res.send(file);
+    } catch (err) {
+      log.error({ err }, 'GET /copy-desk/pages/:pageId/draft.docx failed');
+      if (!res.headersSent) res.fail('copy_page_docx_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // POST /copy-desk/pages/:pageId/draft.docx — upload the Word file back into
+  // the DRAFT (task 1004320 / BV2.TW09, ADR 0341 D12). Never to the site: the
+  // words land in the round's draft block, exactly where the autosave puts
+  // them, through the same port call (holder only) and the same resolver
+  // (every target from the page reading by key, never from the file).
+  //
+  // Body: the .docx bytes (Content-Type: the Word type, application/zip or
+  //       application/octet-stream), at most docx.MAX_UPLOAD_BYTES.
+  // rank: any signed-in builder; only the HOLDER of the page's writing claim.
+  //
+  // A MERGE, not a replace: a line is taken from the file only when the artist
+  // changed it in Word (against the text the download showed), so a line they
+  // rewrote in the studio after downloading keeps that rewrite.
+  //
+  //   200 saved | unchanged   the draft, the counter, and `merge` (which lines
+  //                           came from the file, and how they were matched)
+  //   409 structure_changed   a line added, dropped or reordered, or a heading
+  //                           changed; each is named (section, first words)
+  //   409 wrong_page · reading_moved · page_not_held · no_open_round
+  //   413 upload_too_large · 415 not_a_docx
+  // -------------------------------------------------------------------------
+  router.post('/copy-desk/pages/:pageId/draft.docx', api.requireBuilder, docxBody, async (req, res) => {
+    try {
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { pageId } = found;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      if (typeof lifecycle.updateHeldTaskDescription !== 'function') {
+        return res.fail('lifecycle_unavailable', 503, { what_this_means: 'This instance cannot save a page draft. Nothing was saved.' });
+      }
+      const readingPage = readingPageOrFail(res, pageId);
+      if (!readingPage) return;
+
+      const upload = docx.readUpload(Buffer.isBuffer(req.body) ? req.body : null);
+      if (!upload.ok) return refusePage(res, upload);
+      if (upload.page_id !== pageId) {
+        return res.fail('wrong_page', 409, { page_id: pageId, file_page_id: upload.page_id, what_this_means: UPLOAD_WRONG_PAGE_MEANS });
+      }
+      if (upload.reading_hash !== readingPage.reading_hash) {
+        return res.fail('reading_moved', 409, { reading_hash: readingPage.reading_hash || null, file_reading_hash: upload.reading_hash, what_this_means: UPLOAD_READING_MOVED_MEANS });
+      }
+      const mapped = docx.mapUpload({ readingPage, upload });
+      if (!mapped.ok) return refusePage(res, mapped);
+
+      const round = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+      if (!round) {
+        return res.fail('no_open_round', 409, {
+          page_id: pageId,
+          what_this_means: 'Nobody is writing this page. Claim it first (POST /copy-desk/pages/:pageId/claim), then upload the file.',
+        });
+      }
+
+      const savedAt = new Date().toISOString();
+      let draft = null;
+      let merge = null;
+      const r = await lifecycle.updateHeldTaskDescription({
+        taskId: round.id,
+        builderId: req.builder.id,
+        source: pages.SOURCE,
+        // Merged on the LOCKED task, so the draft the file merges into is the
+        // one stored now, not one read before the lock.
+        compose: (task) => {
+          const prev = pages.parseDraftBlock(task.description);
+          const m = docx.mergeUpload({ readingPage, texts: mapped.texts, baseline: upload.baseline, draft: prev.ok ? prev.draft : null });
+          const resolved = pages.resolveDraft({ readingPage, body: { reading_hash: readingPage.reading_hash, lines: m.lines }, savedAt });
+          if (!resolved.ok) return resolved;
+          const s = pages.saveDraftInto(task.description, resolved.draft);
+          if (s.ok) { draft = s.draft; merge = m; }
+          return s;
+        },
+      });
+      switch (r.outcome) {
+        case 'saved':
+        case 'unchanged':
+          return res.json({
+            ok: true,
+            outcome: r.outcome,
+            page_id: pageId,
+            round: { task_id: String(round.id), state: 'writing' },
+            draft: { reading_hash: draft.reading_hash, saved_at: draft.saved_at, lines: draft.lines },
+            counter: { changed: draft.lines.length, total: readingPage.lines.length },
+            // What the editor shows after an upload ("uploaded · 3 lines from
+            // your doc", Editor.dc.html): the lines the file changed, the draft
+            // lines it left alone, and whether lines were matched by tag or by
+            // position, with or without the file's record of what it showed.
+            merge: { mode: mapped.mode, baseline: !!upload.baseline, from_file: merge.from_file, kept_from_draft: merge.kept_from_draft },
+          });
+        case 'not_held':
+          return refuseNotHeld(res, pageId, r, round);
+        case 'refused':
+          return refusePage(res, r.refusal);
+        default:
+          throw new Error(`updateHeldTaskDescription: unexpected outcome ${r.outcome}`);
+      }
+    } catch (err) {
+      log.error({ err }, 'POST /copy-desk/pages/:pageId/draft.docx failed');
+      if (!res.headersSent) res.fail('copy_page_docx_upload_failed', 500);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // POST /copy-desk/pages/:pageId/submit — freeze the draft and queue the page
+  // for /tweak (task 1004319 / BV2.TW08, ADR 0341 D4, D7).
+  //
+  // Body: {} (it freezes the draft already on the task; nothing is taken from
+  //       the request). rank: any signed-in builder; the holder only.
+  //
+  // One lifecycle transaction:
+  //   * every draft line is re-resolved on the CURRENT page reading; a line the
+  //     page no longer shows is refused by name (target_gone), as are an
+  //     ambiguous one and a {…} hole added or dropped. Any refusal refuses the
+  //     submit, listing the lines, and nothing is frozen;
+  //   * a rewrite of an UNPLACED line (and of shared shell text with no
+  //     registry row) leaves the batch and files its own engineer task
+  //     (source page-tweak-unplaced, backlog), carrying the page, the line and
+  //     the wording. The page does not wait for it;
+  //   * the rest is frozen into the `page-tweak` block with each line's file,
+  //     line and string id from the reading, naming the engineer tasks;
+  //   * the artist's web claim is released and the task goes back to `ready`:
+  //     the round reads `submitted`, the /tweak queue.
+  //
+  //   200 submitted            with the batch, the engineer tasks, and where
+  //                            "next up" reads (GET /copy-desk/next)
+  //   200 already_submitted    a repeated submit by the round's artist
+  //   409 lines_refused · nothing_to_submit · page_not_held · no_open_round
+  // -------------------------------------------------------------------------
+  router.post('/copy-desk/pages/:pageId/submit', api.requireBuilder, async (req, res) => {
+    try {
+      if (validateOrRespond(req, res, SUBMIT_BODY_SCHEMA)) return;
+      const found = pageOrFail(req, res);
+      if (!found) return;
+      const { page, pageId } = found;
+      const lifecycle = pageReadsOrFail(res);
+      if (!lifecycle) return;
+      if (typeof lifecycle.submitPageTweak !== 'function') {
+        return res.fail('lifecycle_unavailable', 503, { what_this_means: 'This instance cannot submit a page. Nothing was submitted.' });
+      }
+      const readingPage = readingPageOrFail(res, pageId);
+      if (!readingPage) return;
+
+      const round = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+      if (!round) {
+        return res.fail('no_open_round', 409, {
+          page_id: pageId,
+          what_this_means: 'Nobody is writing this page. Claim it first (POST /copy-desk/pages/:pageId/claim).',
+        });
+      }
+      // A double-click: the round's own artist submitting what is already in
+      // the queue gets the same answer, not a refusal.
+      const again = alreadySubmitted(round, req.builder.id, pageId);
+      if (again) return res.json(again);
+
+      const building = proposals.resolveTargetVersion(await lifecycle.listVersions());
+      const submittedAt = new Date().toISOString();
+      let frozen = null;
+      const r = await lifecycle.submitPageTweak({
+        taskId: round.id,
+        builderId: req.builder.id,
+        versionId: building ? building.id : null,
+        freeze: (task) => {
+          const d = pages.parseDraftBlock(task.description);
+          if (!d.ok) return d.code === 'no_block' ? { ok: false, code: 'nothing_to_submit', detail: {} } : d;
+          if (d.draft.page_id !== pageId) return { ok: false, code: 'wrong_page', detail: { page_id: pageId, draft_page_id: d.draft.page_id } };
+          const f = pages.freezeBatch({ readingPage, draft: d.draft, submittedAt });
+          if (!f.ok) return f;
+          const probe = pages.replaceBlock(task.description, pages.FENCES.batch, '');
+          if (!probe.ok) return probe;
+          frozen = f;
+          return {
+            ok: true,
+            unplaced: f.unplaced.map((l) => ({
+              key: l.key,
+              source: pages.UNPLACED_SOURCE,
+              sourceRef: pages.unplacedSourceRef(task.id, l.key),
+              title: pages.unplacedTaskTitle(page, l),
+              description: pages.unplacedTaskBody(page, l, task.id),
+              touches: Array.isArray(page.files) ? page.files : [],
+            })),
+            description: (ids) => pages.replaceBlock(task.description, pages.FENCES.batch,
+              pages.composeBatchBlock({ ...f.batch, unplaced_tasks: ids })).description,
+          };
+        },
+      });
+      switch (r.outcome) {
+        case 'submitted':
+          return res.json({
+            ok: true, outcome: 'submitted', page_id: pageId,
+            round: { task_id: String(r.task.id), state: 'submitted', status: r.task.status },
+            batch: { line_count: frozen.batch.lines.length, submitted_at: submittedAt, reading_hash: frozen.batch.reading_hash },
+            unplaced_tasks: r.unplaced_tasks.map((u) => ({ task_id: u.id, key: u.key, created: u.created })),
+            // "Next up" (the editor's closing card) reads the recommendation.
+            next: { path: '/copy-desk/next' },
+          });
+        case 'not_held': {
+          // A second submit that raced the first waits on the task's row
+          // lock and then finds the claim released: read the round again,
+          // and if the first froze it, this is the same double-click.
+          const now = openRoundOf(await lifecycle.listPageTweakTasks({ pageId }), pageId);
+          const same = now && alreadySubmitted(now, req.builder.id, pageId);
+          if (same) return res.json(same);
+          return refuseNotHeld(res, pageId, r, now || round);
+        }
+        case 'refused':
+          return refusePage(res, r.refusal);
+        default:
+          throw new Error(`submitPageTweak: unexpected outcome ${r.outcome}`);
+      }
+    } catch (err) {
+      log.error({ err }, 'POST /copy-desk/pages/:pageId/submit failed');
+      if (!res.headersSent) res.fail('copy_page_submit_failed', 500);
+    }
+  });
+
   return router;
 };