@bongos/core 1.19.1060 → 1.19.1062

package/modules/copy-desk/pages.js

@@ -215,6 +215,211 @@ function roundOpenForWriting(task) {
   return !!task && task.status === 'ready' && !blockPresence(task.description).batch;
 }
 
+// ---------------------------------------------------------------------------
+// The draft and the submit (task 1004319 / BV2.TW08, ADR 0341 D4).
+//
+// Both resolve every TARGET from the page reading (docs/page-readings.json),
+// never from the request body (ADR 0233 §7). A draft save sends only
+// { reading_hash, lines: [{ key, after }] }; the line's section, its current
+// text (`before`) and its placement are copied from the reading. The submit
+// re-resolves each draft line against the CURRENT reading, so a line the page
+// no longer shows is refused by name (`target_gone`) instead of being frozen
+// against a sentence that is not there.
+// ---------------------------------------------------------------------------
+
+// The interpolation hole the inventory writes for `${...}` (proposals.js's
+// PLACEHOLDER; restated here because this file requires nothing).
+const PLACEHOLDER = '{…}';
+// One rewritten line. The longest line any page shows today is 760 characters,
+// so 1000 leaves room to rewrite it and still bounds a draft.
+const MAX_LINE_CHARS = 1000;
+// A draft holds changed lines only, and the longest page has under 500 lines.
+const MAX_DRAFT_LINES = 1000;
+const UNPLACED_SOURCE = 'page-tweak-unplaced';
+const LINE_KEY_RE = /^L[0-9]{4,}$/;
+
+// The inventory's own whitespace rule (proposals.js tidy): a line is measured
+// and compared in the form the reading records it.
+function tidy(raw) {
+  return String(raw == null ? '' : raw).replace(/\s+/g, ' ').trim();
+}
+
+function placeholderCount(text) {
+  return String(text || '').split(PLACEHOLDER).length - 1;
+}
+
+// Replace the ONE block of a fence in a description, or append it when there is
+// none. A description carrying two is refused rather than guessed at.
+function replaceBlock(markdown, fence, block) {
+  const src = String(markdown || '');
+  const re = new RegExp('```' + fence.replace(/-/g, '\\-') + '[ \\t]*\\r?\\n[\\s\\S]*?\\r?\\n```', 'g');
+  const hits = src.match(re) || [];
+  if (hits.length > 1) return fail('multiple_blocks', { fence, count: hits.length });
+  if (hits.length === 1) return { ok: true, description: src.replace(re, () => block) };
+  return { ok: true, description: src.trimEnd() + (src.trim() ? '\n\n' : '') + block };
+}
+
+// resolveDraft({ readingPage, body, savedAt }) -> { ok, draft } | refusal
+//
+// A WHOLE-DRAFT replace: the body is every changed line the artist has, and the
+// draft becomes exactly that. A line whose `after` equals the page's current
+// text is not a change and is dropped, so only changed lines are stored (D4).
+// Placeholder arithmetic is NOT checked here: an autosave lands mid-sentence,
+// and the check belongs to the submit (and again to the applier).
+function resolveDraft({ readingPage, body, savedAt }) {
+  if (!readingPage || !Array.isArray(readingPage.lines)) return fail('reading_missing');
+  const b = body || {};
+  if (String(b.reading_hash || '') !== String(readingPage.reading_hash || '')) {
+    return fail('reading_moved', { reading_hash: readingPage.reading_hash || null, sent: b.reading_hash || null });
+  }
+  const list = Array.isArray(b.lines) ? b.lines : [];
+  if (list.length > MAX_DRAFT_LINES) return fail('too_many_lines', { max: MAX_DRAFT_LINES, was: list.length });
+  const byKey = new Map(readingPage.lines.map((l) => [l.key, l]));
+  const seen = new Set();
+  const unknown = [];
+  const tooLong = [];
+  const empty = [];
+  const out = [];
+  for (const raw of list) {
+    const key = raw && typeof raw.key === 'string' ? raw.key : '';
+    if (!LINE_KEY_RE.test(key) || typeof raw.after !== 'string') return fail('line_malformed', { line: raw == null ? null : raw });
+    if (seen.has(key)) return fail('duplicate_line', { key });
+    seen.add(key);
+    const at = byKey.get(key);
+    if (!at) { unknown.push(key); continue; }
+    const after = tidy(raw.after);
+    if (after === tidy(at.text)) continue;
+    if (!after) { empty.push(key); continue; }
+    if (after.length > MAX_LINE_CHARS) { tooLong.push(key); continue; }
+    out.push({ key, section: at.section == null ? null : at.section, before: at.text, after, placement: at.placement });
+  }
+  if (unknown.length) return fail('unknown_line', { keys: unknown });
+  if (empty.length) return fail('line_empty', { keys: empty });
+  if (tooLong.length) return fail('line_too_long', { keys: tooLong, max: MAX_LINE_CHARS });
+  // Page order, whatever order the editor sent them in.
+  const order = new Map(readingPage.lines.map((l, i) => [l.key, i]));
+  out.sort((x, y) => order.get(x.key) - order.get(y.key));
+  return { ok: true, draft: { page_id: readingPage.id, reading_hash: readingPage.reading_hash, saved_at: savedAt, lines: out } };
+}
+
+// Is a newly resolved draft the one already saved? Then the save writes
+// nothing: an autosave that changed nothing must not touch the task.
+function sameDraft(saved, next) {
+  if (!saved || !next) return false;
+  const pick = (d) => JSON.stringify([d.page_id, d.reading_hash,
+    (d.lines || []).map((l) => [l.key, l.section == null ? null : l.section, l.before, l.after, l.placement])]);
+  return pick(saved) === pick(next);
+}
+
+// saveDraftInto(description, draft) -> { ok, description, draft } | refusal
+//
+// The one way a resolved draft is written into a round's description, shared by
+// the autosave (PUT .../draft) and the Word upload (POST .../draft.docx, task
+// 1004320), so both save through the same rules: the same draft again keeps the
+// stored block (saved_at included) and so writes nothing; no draft yet and
+// nothing changed stores nothing; otherwise the block is replaced in place.
+function saveDraftInto(description, draft) {
+  const prev = parseDraftBlock(description);
+  if (prev.ok && sameDraft(prev.draft, draft)) return { ok: true, description, draft: prev.draft };
+  if (prev.code === 'no_block' && !draft.lines.length) return { ok: true, description, draft };
+  const r = replaceBlock(description, FENCES.draft, composeDraftBlock(draft));
+  return r.ok ? { ok: true, description: r.description, draft } : r;
+}
+
+// Find a draft line on the CURRENT reading: the same key showing the same text,
+// else the one line showing that text in the same section, else the one line
+// showing it anywhere on the page. Anything else is gone, or too ambiguous to
+// pick for the artist.
+function locateLine(lines, draftLine) {
+  const same = (l) => l.text === draftLine.before;
+  const byKey = lines.find((l) => l.key === draftLine.key);
+  if (byKey && same(byKey)) return { line: byKey };
+  const inSection = lines.filter((l) => same(l) && l.section === draftLine.section);
+  if (inSection.length === 1) return { line: inSection[0] };
+  const anywhere = lines.filter(same);
+  if (anywhere.length === 1) return { line: anywhere[0] };
+  return { code: anywhere.length > 1 ? 'ambiguous_target' : 'target_gone' };
+}
+
+// A line the applier cannot place goes to an engineer (spec decision 7). That
+// is every `unplaced` line, and a `shared` line the registry has no row for:
+// shell text with no file behind it cannot be applied mechanically either.
+function goesToEngineer(line) {
+  return line.placement === 'unplaced' || (line.placement === 'shared' && !line.file);
+}
+
+// freezeBatch({ readingPage, draft, submittedAt }) -> { ok, batch, unplaced } | refusal
+//
+// The submit's pure half. Every draft line is re-resolved on the current
+// reading; a refused line (`target_gone`, `ambiguous_target`,
+// `placeholder_mismatch`) refuses the submit, naming each line, and nothing is
+// frozen: the artist fixes those lines and submits again. `batch` is the
+// `page-tweak` block's content without its `unplaced_tasks` (the lifecycle
+// transaction fills those in once the engineer tasks exist). `unplaced` is the
+// lines taken out of it.
+function freezeBatch({ readingPage, draft, submittedAt }) {
+  if (!readingPage || !Array.isArray(readingPage.lines)) return fail('reading_missing');
+  if (!draft || !Array.isArray(draft.lines) || !draft.lines.length) return fail('nothing_to_submit');
+  const refused = [];
+  const placed = [];
+  const unplaced = [];
+  const keys = new Set();
+  for (const d of draft.lines) {
+    const found = locateLine(readingPage.lines, d);
+    if (!found.line) { refused.push({ key: d.key, section: d.section == null ? null : d.section, before: d.before, code: found.code }); continue; }
+    const at = found.line;
+    if (keys.has(at.key)) { refused.push({ key: d.key, section: d.section == null ? null : d.section, before: d.before, code: 'ambiguous_target' }); continue; }
+    keys.add(at.key);
+    const line = { key: at.key, section: at.section == null ? null : at.section, before: at.text, after: d.after, placement: at.placement };
+    if (goesToEngineer(at)) { unplaced.push(line); continue; }
+    const want = placeholderCount(at.text);
+    const got = placeholderCount(d.after);
+    if (want !== got) { refused.push({ key: at.key, section: line.section, before: at.text, code: 'placeholder_mismatch', expected: want, got }); continue; }
+    placed.push({ ...line, file: at.file, line: at.line == null ? null : at.line, string_id: at.string_id == null ? null : at.string_id });
+  }
+  if (refused.length) return fail('lines_refused', { refused });
+  const order = new Map(readingPage.lines.map((l, i) => [l.key, i]));
+  const byOrder = (x, y) => order.get(x.key) - order.get(y.key);
+  return {
+    ok: true,
+    batch: { page_id: readingPage.id, reading_hash: readingPage.reading_hash, submitted_at: submittedAt, lines: placed.sort(byOrder) },
+    unplaced: unplaced.sort(byOrder),
+  };
+}
+
+// The engineer task an unplaced rewrite files (ADR 0341 D4): one per line,
+// keyed so a repeated submit finds the task it already filed.
+function unplacedSourceRef(roundTaskId, key) {
+  return `${UNPLACED_SOURCE}/${roundTaskId}/${key}`;
+}
+
+function clip(text, n) {
+  const s = String(text || '');
+  return s.length > n ? `${s.slice(0, n - 1)}…` : s;
+}
+
+function unplacedTaskTitle(page, line) {
+  return `Place and reword "${clip(line.before, 60)}" (${page.id})`;
+}
+
+function unplacedTaskBody(page, line, roundTaskId) {
+  const where = line.placement === 'shared'
+    ? 'It is shared shell text (it shows on every page of the surface), and the copy registry has no row for it.'
+    : 'The copy registry cannot place it: the string is built somewhere the inventory does not read (data from an API, a string assembled in code, or markup the extractors miss).';
+  return [
+    `An artist rewrote a line on **${String(page.title || page.id)}** (\`${page.id}\`${page.path ? `, ${page.path}` : ''}) that the applier cannot change mechanically, so it comes to an engineer (ADR 0341 D4, spec decision 7).`,
+    '',
+    where,
+    '',
+    `- Section: ${line.section == null ? '(none)' : line.section}`,
+    `- Line: ${line.key} in the page reading`,
+    `- It says now: ${JSON.stringify(line.before)}`,
+    `- The artist's wording: ${JSON.stringify(line.after)}`,
+    '',
+    `Find where this text is rendered and change it to the artist's wording, or make it a string the copy registry can place so the next tweak can change it directly. The page's tweak round (task ${roundTaskId}) does not wait for this.`,
+  ].join('\n');
+}
+
 module.exports = {
   SCHEMA,
   SOURCE,
@@ -235,4 +440,15 @@ module.exports = {
   parseSentBackBlocks,
   blockPresence,
   roundOpenForWriting,
+  MAX_LINE_CHARS,
+  MAX_DRAFT_LINES,
+  UNPLACED_SOURCE,
+  replaceBlock,
+  resolveDraft,
+  sameDraft,
+  saveDraftInto,
+  freezeBatch,
+  unplacedSourceRef,
+  unplacedTaskTitle,
+  unplacedTaskBody,
 };