domma-cms 1.6.56 → 1.6.57

package/plugins/feedback/admin/views/send.js

@@ -10,14 +10,19 @@
  * the same screen files straight into the inbox: nothing waits, nothing travels.
  */
 
-import {FILES, FILE_TYPES, api, esc, fileRow, fileSize, isImage, openPanel, refreshBadge, showFiles, stamp, uploadFile, when} from '../lib/kit.js';
+import {
+    FILES, FILE_TYPES, api, copyText, esc, fileRow, fileSize, guardPanel, isImage, offerDraft, openPanel, panelSet, refreshBadge, rowKeys, showFiles, stamp,
+    uploadFile, when
+} from '../lib/kit.js';
+import {DRAFT_KEYS, draftValues, newDraftQuestion} from '../lib/drafts.js';
 
 const ROW = `
-<div class="fb-row" data-id="{{key}}" tabindex="0" role="button">
+<div class="fb-row" data-id="{{key}}" tabindex="0" role="button" aria-haspopup="menu">
   <span class="fb-type" data-bind-title="typeLabel"><span data-icon="{{icon}}" data-icon-size="16"></span></span>
   <span class="fb-main"><strong data-bind-text="title"></strong><small data-bind-text="meta"></small></span>
   <span class="fb-dot" data-bind-hidden="!unread" title="New reply from Domma"></span>
   <span class="fb-chip" data-bind-class="tone" data-bind-text="statusLabel"></span>
+  <button type="button" class="fb-kebab" aria-label="Actions" title="Actions">&#8942;</button>
 </div>`;
 
 const TONE = {new: 'info', acknowledged: 'muted', planned: 'info', 'in-progress': 'warning', done: 'success', declined: 'muted',
@@ -51,6 +56,8 @@ export async function mount(root, ctx) {
     const connected = M.observable(Boolean(ctx.mode.connected));
     const reports = M.observable([]);
     const loading = M.observable(true);
+    const panels = panelSet();
+    scope(() => panels.leave());
     const reachable = M.observable(true);
     const error = M.observable('');
     const rows = M.observable([]);
@@ -94,7 +101,7 @@ export async function mount(root, ctx) {
     <button type="button" class="btn btn-ghost btn-xs" data-on-click="reload">Try now</button>
   </p>
   <p class="fb-note is-warn" data-bind-hidden="reachable.value || loading.value">Domma could not be reached just now, so the statuses below may be out of date.</p>
-  <p class="fb-note" data-bind-hidden="!loading.value">Loading...</p>
+  <div class="fb-loading dm-loading-slot" data-bind-hidden="!loading.value">Loading...</div>
   <p class="fb-note is-bad" data-bind-hidden="!error.value" data-bind-text="error.value"></p>
   <p class="fb-note" data-bind-hidden="loading.value || rows.value.length">Nothing sent yet. Found something odd, or wish the CMS did something it does not? Send feedback.</p>
   <div class="fb-list" data-each="rows.value key=key"></div>
@@ -112,29 +119,52 @@ export async function mount(root, ctx) {
         Promise.resolve().then(() => { M.flush?.(); I.scan(listEl); });
     }));
 
+    // The first load shows a skeleton in the slot; a reload keeps the list on screen.
+    let loaded = false;
     async function load() {
-        loading.value = true;
+        const first = !loaded;
         try {
-            const res = await api.sent();
+            const asked = api.sent();
+            const res = first ? await kit.whileLoading(view.querySelector('.fb-loading'), asked, kit.SHAPES.iconRows) : await asked;
             if (!here()) return;
             connected.value = Boolean(res.connected);
             reachable.value = Boolean(res.reachable) || !res.connected;
             reports.value = Array.isArray(res.reports) ? res.reports : [];
             error.value = '';
+            loaded = true;
         } catch (err) {
-            error.value = `Could not load your feedback: ${err.message || err}`;
+            if (here()) error.value = `Could not load your feedback: ${err.message || err}`;
         } finally {
-            loading.value = false;
-            I.scan(view);
+            if (here()) { loading.value = false; I.scan(view); }
         }
     }
 
     const byKey = (k) => reports.peek().find(r => (r.id || r.ref) === k);
 
-    function compose() {
+    const FORM = {type: 'bug', title: '', description: '', where: '', severity: 'minor'};
+    const formOf = (f) => ({type: f.type.value, title: f.title.value, description: f.description.value, where: f.where.value, severity: f.severity.value});
+
+    async function compose() {
+        if (!panels.claim('compose')) return;
+        let p = null;
+        try {
+            // Something left unsent last time is offered back first; it goes only on "Throw away".
+            const offer = await offerDraft(DRAFT_KEYS.compose, {here, question: (d) => newDraftQuestion(d, 'the feedback')});
+            if (offer.state === 'gone') { panels.release('compose'); return; }
+            const start = offer.state === 'keep' ? draftValues(offer.draft, FORM) : {...FORM};
+            p = await openCompose(start);
+        } catch (err) {
+            panels.release('compose');
+            E.toast(err.message || String(err), {type: 'error'});
+            return;
+        }
+        if (!p) panels.release('compose');
+    }
+
+    async function openCompose(start) {
         const f = {
-            type: M.observable('bug'), title: M.observable(''), description: M.observable(''),
-            where: M.observable(''), severity: M.observable('minor'), busy: M.observable(false)
+            type: M.observable(start.type), title: M.observable(start.title), description: M.observable(start.description),
+            where: M.observable(start.where), severity: M.observable(start.severity), busy: M.observable(false)
         };
         const isBug = M.computed(() => f.type.value === 'bug');
         // The files picked so far: uploaded as soon as they are chosen, sent by id with the report.
@@ -143,12 +173,18 @@ export async function mount(root, ctx) {
         const uploading = M.computed(() => picked.value.some(x => x.busy));
         const localUrls = [];
         let filesHandle = null;
-        let panel = null;
-        openPanel({
+        let guard = null;
+        const offs = [];
+        const p = await openPanel({
             title: COPY.title,
             size: 'md',
             model: {...f, isBug, room, uploading},
-            cleanup: () => { filesHandle?.dispose(); for (const u of localUrls.splice(0)) URL.revokeObjectURL(u); },
+            cleanup: () => {
+                filesHandle?.dispose();
+                for (const off of offs.splice(0)) off();
+                for (const u of localUrls.splice(0)) URL.revokeObjectURL(u);
+                [isBug, room, uploading].forEach(c => c.dispose?.());
+            },
             html: `<div class="fb-form">
   <label class="form-label">What is it?</label>
   <div class="fb-types" role="radiogroup" aria-label="Type">
@@ -166,7 +202,7 @@ export async function mount(root, ctx) {
   </div>
   <label class="form-label" for="fb-where">Where <span data-help="The screen or page it is about, if there is one - e.g. Pages, the Blog editor, /contact. Optional."></span></label>
   <input id="fb-where" class="form-input" maxlength="300" data-model="where.value" placeholder="Optional">
-  <label class="form-label">Screenshots and files <span data-help="${esc(`Up to ${caps.max} files of ${fileSize(caps.maxBytes)} each: PNG, JPEG, GIF or WebP images, a PDF or a text file. A screenshot of what went wrong helps most. They are seen only by the Domma team.`)}"></span></label>
+  <label class="form-label">Screenshots and files <span data-help="${esc(`Up to ${caps.max} files of ${fileSize(caps.maxBytes)} each: PNG, JPEG, GIF or WebP images, a PDF or a text file. A screenshot of what went wrong helps most. They are seen only by the Domma team. What you type is kept if you leave before sending; files are not - attach them again.`)}"></span></label>
   <div class="fb-files-host" data-files></div>
   <div class="fb-attach" data-bind-hidden="!room.value">
     <button type="button" class="btn btn-sm btn-outline" data-on-click="pickFiles"><span data-icon="paperclip" data-icon-size="13"></span> Attach a file</button>
@@ -180,78 +216,106 @@ export async function mount(root, ctx) {
   </div>
 </div>`,
             methods: {
-                cancel: () => panel?.close(),
-                pickFiles: () => panel?.panel.querySelector('.fb-file-input')?.click(),
+                cancel: () => guard?.close(),
+                pickFiles: () => p?.panel.querySelector('.fb-file-input')?.click(),
                 async send() {
                     if (f.busy.peek() || uploading.peek()) return;
                     f.busy.value = true;
+                    // The panel closes once sent: locked meanwhile, so nothing typed during the request is lost.
+                    guard?.lock(true);
                     try {
                         const r = await api.send({type: f.type.peek(), title: f.title.peek(), description: f.description.peek(),
                             where: f.where.peek(), severity: f.type.peek() === 'bug' ? f.severity.peek() : '',
                             attachments: picked.peek().filter(x => x.id && !x.busy).map(x => ({id: x.id, name: x.name, type: x.type, size: x.size}))});
                         E.toast(r.message || 'Sent.', {type: r.state === 'sent' ? 'success' : 'warning'});
-                        panel?.close();
+                        guard?.settle();
+                        guard?.close(true);
                         refreshBadge();
-                        await load();
+                        if (here()) await load();
                     } catch (err) {
+                        guard?.lock(false);
                         E.toast(err.message || String(err), {type: 'error'});
                     } finally {
                         f.busy.value = false;
                     }
                 }
             }
-        }).then(p => {
-            panel = p;
-            p.panel.querySelector('.fb-types').addEventListener('click', (e) => {
-                const b = e.target.closest('[data-type]');
-                if (b) f.type.value = b.dataset.type;
-            });
-            // The file list is bound on its own, after the panel: the panel's model has no `files`.
-            const host = p.panel.querySelector('[data-files]');
-            host.innerHTML = FILES;
-            const files = M.computed(() => picked.value.map(x => fileRow(x, {key: x.key, thumb: x.thumb, removable: !x.busy,
-                meta: x.busy ? 'Uploading...' : fileSize(x.size), title: x.name})));
-            const bound = M.applyBindings({files}, host);
-            filesHandle = {dispose: () => { bound.dispose(); files.dispose?.(); }};
-            host.addEventListener('click', (e) => {
-                const x = e.target.closest('.fb-file-x');
-                if (x) picked.value = picked.peek().filter(r => r.key !== x.closest('.fb-file').dataset.key);
-            });
-            const add = async (list) => {
-                for (const file of list) {
-                    if (picked.peek().length >= caps.max) { E.toast(`Up to ${caps.max} files.`, {type: 'warning'}); break; }
-                    if (file.size > caps.maxBytes) { E.toast(`${esc(file.name)} is too big - up to ${fileSize(caps.maxBytes)} each.`, {type: 'warning'}); continue; }
-                    if (!FILE_TYPES.split(',').includes(file.type)) { E.toast(`${esc(file.name)} cannot be attached - images, PDF or text only.`, {type: 'warning'}); continue; }
-                    const key = `k${Date.now()}${Math.random().toString(16).slice(2)}`;
-                    let thumb = '';
-                    if (isImage(file.type)) { thumb = URL.createObjectURL(file); localUrls.push(thumb); }
-                    picked.value = [...picked.peek(), {key, name: file.name || 'screenshot.png', type: file.type, size: file.size, thumb, busy: true}];
-                    try {
-                        const a = await uploadFile(file);
-                        picked.value = picked.peek().map(r => (r.key === key ? {...r, ...a, key, busy: false} : r));
-                    } catch (err) {
-                        picked.value = picked.peek().filter(r => r.key !== key);
-                        E.toast(esc(err.message || String(err)), {type: 'error'});
-                    }
-                }
-            };
-            const input = p.panel.querySelector('.fb-file-input');
-            input.addEventListener('change', () => { const list = [...input.files]; input.value = ''; add(list); });
-            // A screenshot pasted into the description is the quickest way there is.
-            p.panel.querySelector('#fb-desc')?.addEventListener('paste', (e) => {
-                const list = [...(e.clipboardData?.files || [])];
-                if (!list.length) return;
-                e.preventDefault();
-                add(list.map(file => (file.name && file.name !== 'image.png' ? file
-                    : new File([file], `screenshot-${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-')}.png`, {type: file.type}))));
-            });
-            p.panel.querySelector('#fb-title')?.focus();
         });
+        guard = guardPanel(p, {
+            key: DRAFT_KEYS.compose,
+            values: () => formOf(f),
+            baseline: {...FORM},
+            extraDirty: () => picked.peek().length > 0,
+            onClosed: () => panels.release('compose')
+        });
+        panels.set('compose', {close: (how) => guard.close(how)});
+        const typesEl = p.panel.querySelector('.fb-types');
+        const onType = (e) => { const b = e.target.closest('[data-type]'); if (b) f.type.value = b.dataset.type; };
+        typesEl.addEventListener('click', onType);
+        offs.push(() => typesEl.removeEventListener('click', onType));
+        // The file list is bound on its own, after the panel: the panel's model has no `files`.
+        const host = p.panel.querySelector('[data-files]');
+        host.innerHTML = FILES;
+        const files = M.computed(() => picked.value.map(x => fileRow(x, {key: x.key, thumb: x.thumb, removable: !x.busy,
+            meta: x.busy ? 'Uploading...' : fileSize(x.size), title: x.name})));
+        const bound = M.applyBindings({files}, host);
+        filesHandle = {dispose: () => { bound.dispose(); files.dispose?.(); }};
+        const onRemove = (e) => {
+            const x = e.target.closest('.fb-file-x');
+            if (x) picked.value = picked.peek().filter(r => r.key !== x.closest('.fb-file').dataset.key);
+        };
+        host.addEventListener('click', onRemove);
+        offs.push(() => host.removeEventListener('click', onRemove));
+        let live = true;
+        offs.push(() => { live = false; });
+        const add = async (list) => {
+            for (const file of list) {
+                if (!live) return;
+                if (picked.peek().length >= caps.max) { E.toast(`Up to ${caps.max} files.`, {type: 'warning'}); break; }
+                if (file.size > caps.maxBytes) { E.toast(`${file.name} is too big - up to ${fileSize(caps.maxBytes)} each.`, {type: 'warning'}); continue; }
+                if (!FILE_TYPES.split(',').includes(file.type)) { E.toast(`${file.name} cannot be attached - images, PDF or text only.`, {type: 'warning'}); continue; }
+                const key = `k${Date.now()}${Math.random().toString(16).slice(2)}`;
+                let thumb = '';
+                if (isImage(file.type)) { thumb = URL.createObjectURL(file); localUrls.push(thumb); }
+                picked.value = [...picked.peek(), {key, name: file.name || 'screenshot.png', type: file.type, size: file.size, thumb, busy: true}];
+                try {
+                    const a = await uploadFile(file);
+                    if (!live) return;
+                    picked.value = picked.peek().map(r => (r.key === key ? {...r, ...a, key, busy: false} : r));
+                } catch (err) {
+                    if (!live) return;
+                    picked.value = picked.peek().filter(r => r.key !== key);
+                    E.toast(err.message || String(err), {type: 'error'});
+                }
+            }
+        };
+        const input = p.panel.querySelector('.fb-file-input');
+        const onChange = () => { const list = [...input.files]; input.value = ''; add(list); };
+        input.addEventListener('change', onChange);
+        offs.push(() => input.removeEventListener('change', onChange));
+        // A screenshot pasted into the description is the quickest way there is.
+        const desc = p.panel.querySelector('#fb-desc');
+        const onPaste = (e) => {
+            const list = [...(e.clipboardData?.files || [])];
+            if (!list.length) return;
+            e.preventDefault();
+            add(list.map(file => (file.name && file.name !== 'image.png' ? file
+                : new File([file], `screenshot-${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-')}.png`, {type: file.type}))));
+        };
+        desc?.addEventListener('paste', onPaste);
+        offs.push(() => desc?.removeEventListener('paste', onPaste));
+        p.panel.querySelector('#fb-title')?.focus();
+        return p;
     }
 
+    /** One report open at a time: opening another closes the one showing. */
     async function open(k) {
         const r = byKey(k);
         if (!r) return;
+        const showing = panels.get('detail');
+        if (showing?.key === k) return;
+        if (showing) { await showing.close?.(); if (panels.get('detail')) return; }
+        if (!here() || !panels.claim('detail')) return;
         const lines = [
             ['Type', labelOf(r.type)],
             ['Status', r.statusLabel],
@@ -262,18 +326,26 @@ export async function mount(root, ctx) {
             ...(r.lastError ? [['Last try', r.lastError]] : [])
         ];
         let filesView = null;
-        const p = await openPanel({
-            title: r.title,
-            size: 'md',
-            cleanup: () => filesView?.dispose(),
-            html: `<div class="fb-detail">
+        let p;
+        try {
+            p = await openPanel({
+                title: r.title,
+                size: 'md',
+                cleanup: () => { filesView?.dispose(); panels.release('detail'); },
+                html: `<div class="fb-detail">
   <dl class="fb-facts">${lines.map(([a, b]) => `<div><dt>${esc(a)}</dt><dd>${esc(b)}</dd></div>`).join('')}</dl>
   <h4>What was sent</h4>
   <div class="fb-text">${esc(r.description)}</div>
   ${(r.attachments || []).length ? '<h4>Files</h4><div class="fb-files-host" data-files></div>' : ''}
   ${r.reply ? `<h4><span data-icon="corner-up-left" data-icon-size="14"></span> ${esc(COPY.replied)} <small>${esc(stamp(r.replyAt))}</small></h4><div class="fb-text fb-reply">${esc(r.reply)}</div>` : `<p class="fb-note">${esc(COPY.noReply)}</p>`}
 </div>`
-        });
+            });
+        } catch (err) {
+            panels.release('detail');
+            E.toast(err.message || String(err), {type: 'error'});
+            return;
+        }
+        panels.set('detail', {key: k, close: (how) => p.so.close(how)});
         const host = p.panel.querySelector('[data-files]');
         if (host) {
             host.innerHTML = FILES;
@@ -281,13 +353,30 @@ export async function mount(root, ctx) {
             // Domma's copy is still on its way. The manager's own reports read theirs in place.
             filesView = showFiles(host, (r.attachments || []).map(a => ({...a, stored: true})), (a) => api.ownFileUrl(a.id));
         }
-        if (r.unread && r.id) {
-            try {
-                await api.seen(r.id, r.replyAt);
-                reports.value = reports.peek().map(x => (x === r ? {...x, unread: false} : x));
-                refreshBadge();
-            } catch { /* the badge catches up next time */ }
-        }
+        await markRead(r);
+    }
+
+    async function markRead(r) {
+        if (!r.unread || !r.id) return;
+        try {
+            await api.seen(r.id, r.replyAt);
+            if (!here()) return;
+            reports.value = reports.peek().map(x => ((x.id || x.ref) === (r.id || r.ref) ? {...x, unread: false} : x));
+            refreshBadge();
+        } catch { /* the badge catches up next time */ }
+    }
+
+    /** The row menu: right-click, the ⋮ button and Shift+F10 all open this one definition. */
+    function menuItems(r) {
+        const k = r.id || r.ref;
+        return [
+            {label: 'Open', icon: 'eye', action: () => open(k)},
+            ...(r.unread && r.id ? [{label: 'Mark reply as read', icon: 'check', action: () => markRead(r)}] : []),
+            ...(r.status === 'waiting' ? [{label: 'Try sending now', icon: 'send', action: () => load()}] : []),
+            {type: 'divider'},
+            {label: 'Copy what was sent', icon: 'copy', action: () => copyText(`${r.title}\n\n${r.description || ''}`, 'Copied')},
+            ...(r.reply ? [{label: local ? 'Copy the reply' : 'Copy Domma\'s reply', icon: 'copy', action: () => copyText(r.reply, 'Reply copied')}] : [])
+        ];
     }
 
     const bindings = M.applyBindings({connected, loading, reachable, error, rows, waitingCount}, view, {
@@ -295,12 +384,14 @@ export async function mount(root, ctx) {
     });
     scope(() => bindings.dispose());
 
+    // Rows: click or Enter opens; right-click, the ⋮ or Shift+F10 = the menu.
     const list = view.querySelector('.fb-list');
-    const onClick = (e) => { const row = e.target.closest('.fb-row'); if (row) open(row.dataset.id); };
-    const onKey = (e) => { const row = e.target.closest('.fb-row'); if (row && (e.key === 'Enter' || e.key === ' ')) { e.preventDefault(); open(row.dataset.id); } };
-    list.addEventListener('click', onClick);
-    list.addEventListener('keydown', onKey);
-    scope(() => { list.removeEventListener('click', onClick); list.removeEventListener('keydown', onKey); });
+    const menu = E.contextMenu(list, {
+        cursor: 'glyph', match: '.fb-row', inherit: false, density: 'compact',
+        items: (row) => { const r = byKey(row.dataset.id); return r ? menuItems(r) : []; }
+    });
+    scope(() => menu?.destroy?.());
+    scope(rowKeys(list, {rowSel: '.fb-row', kebabSel: '.fb-kebab', openMenuAt: kit.openMenuAt, primary: open}));
 
     I.scan(view);
     if (connected.peek()) {

package/plugins/feedback/plugin.json

@@ -1,11 +1,11 @@
 {
   "name": "feedback",
   "displayName": "Feedback",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "tier": "free",
   "description": "Tell Domma what is broken, missing or good - straight from your admin - and see what became of it: seen, planned, in progress, done, with Domma's reply.",
   "author": "Domma CMS",
-  "date": "2026-10-13",
+  "date": "2026-10-15",
   "icon": "message-square",
   "permissions": [
     {
@@ -40,7 +40,7 @@
     ],
     "views": {
       "plugin-feedback": {
-        "entry": "feedback/admin/views/feedback.js?v=1.1.8",
+        "entry": "feedback/admin/views/feedback.js?v=1.2.0",
         "exportName": "feedbackView"
       }
     }

package/plugins/feedback/tests/drafts.test.js

@@ -0,0 +1,93 @@
+/**
+ * Kept drafts (admin/lib/drafts.js): what a panel keeps of unsaved typing, and
+ * the question it is offered back with - OK always throws away, so Cancel,
+ * Escape and a backdrop click (all `false` from E.confirm) keep.
+ */
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    DRAFT_KEYS, RESTORE_CONFIRM, changedFields, differs, draftFate, draftQuestion, draftText, draftValues, isDraft, makeDraft, newDraftQuestion,
+    reportForm, reportPrint, settingsPrint, shortWhen, stableJson
+} from '../admin/lib/drafts.js';
+
+test('stableJson ignores key order; differs compares by it', () => {
+    assert.equal(stableJson({b: 1, a: [1, {d: 2, c: 3}]}), stableJson({a: [1, {c: 3, d: 2}], b: 1}));
+    assert.equal(differs({a: '1'}, {a: '1'}), false);
+    assert.equal(differs({a: '1'}, {a: '2'}), true);
+});
+
+test('keys are one per panel and record - no shared map', () => {
+    assert.equal(DRAFT_KEYS.report('r1'), 'feedback.draft.report.r1');
+    assert.notEqual(DRAFT_KEYS.report('r1'), DRAFT_KEYS.report('r2'));
+    assert.notEqual(DRAFT_KEYS.compose, DRAFT_KEYS.settings);
+});
+
+test('makeDraft / isDraft / draftValues', () => {
+    const d = makeDraft({title: 'x', extra: 'y', n: 5}, 'fp', '2026-10-15T10:00:00.000Z');
+    assert.deepEqual(d, {data: {title: 'x', extra: 'y', n: 5}, was: 'fp', at: '2026-10-15T10:00:00.000Z'});
+    assert.ok(isDraft(d));
+    for (const bad of [null, 'x', {}, {data: []}, {data: 'x'}]) assert.equal(isDraft(bad), false);
+    // Only the form's own keys, as strings; missing ones keep the defaults.
+    assert.deepEqual(draftValues(d, {title: '', where: 'here', n: ''}), {title: 'x', where: 'here', n: '5'});
+    assert.deepEqual(draftValues(null, {title: 'a'}), {title: 'a'});
+});
+
+test('reportPrint: new counts as acknowledged (opening a report acknowledges it)', () => {
+    const r = {status: 'new', reply: '', notes: 'n', title: 'ignored'};
+    assert.equal(reportPrint(r), reportPrint({...r, status: 'acknowledged'}));
+    assert.notEqual(reportPrint(r), reportPrint({...r, status: 'planned'}));
+    assert.notEqual(reportPrint(r), reportPrint({...r, reply: 'Thanks'}));
+    assert.equal(reportPrint(r), reportPrint({...r, title: 'other', updatedAt: 'later'}), 'only what the panel edits counts');
+    assert.deepEqual(reportForm({status: 'done'}), {status: 'done', reply: '', notes: ''});
+    assert.equal(reportPrint(null), '');
+});
+
+test('draftFate: deleted, changed since, or neither', () => {
+    const d = {was: 'A'};
+    assert.equal(draftFate(d, null), 'deleted');
+    assert.equal(draftFate(d, 'B'), 'changed');
+    assert.equal(draftFate(d, 'A'), '');
+    assert.equal(draftFate({was: ''}, 'B'), '', 'no was (something new) - nothing to compare');
+});
+
+test('draftQuestion: OK throws away; the text says what happened since', () => {
+    const d = makeDraft({reply: 'Hi'}, 'A', '2026-10-15T10:00:00.000Z');
+    const plain = draftQuestion(d, 'A', {what: 'the report “X”'});
+    assert.match(plain.text, /^Throw away the changes you left unsaved on the report “X” \(15 Oct, \d\d:00\)\?/);
+    assert.match(plain.text, /puts them back in the form/);
+    assert.deepEqual(plain.options, RESTORE_CONFIRM);
+    assert.equal(plain.options.confirmText, 'Throw away', 'the destructive answer is OK');
+    assert.equal(plain.options.cancelText, 'Keep them', 'Cancel / Escape / backdrop keep');
+
+    const changed = draftQuestion(d, 'B', {what: 'the report “X”', changedAt: '2026-10-15T11:30:00.000Z'});
+    assert.equal(changed.fate, 'changed');
+    assert.match(changed.text, /changed since \(15 Oct, \d\d:30\) - keeping them puts your changes over that/);
+
+    const gone = draftQuestion(d, null, {what: 'a report'});
+    assert.equal(gone.fate, 'deleted');
+    assert.match(gone.text, /deleted since/);
+    assert.equal(gone.options.confirmText, 'Throw away');
+    assert.equal(gone.options.cancelText, 'Copy them');
+});
+
+test('newDraftQuestion and settingsPrint', () => {
+    const q = newDraftQuestion(makeDraft({title: 't'}, '', '2026-10-15T09:05:00.000Z'));
+    assert.match(q.text, /^Throw away the feedback you left unsent \(15 Oct, \d\d:05\)\? Keeping it puts it back in the form\.$/);
+    assert.equal(q.options.confirmText, 'Throw away');
+    assert.equal(settingsPrint({b: '2', a: '1'}), settingsPrint({a: '1', b: '2'}));
+});
+
+test('draftText keeps the words, for copying when the record has gone', () => {
+    assert.equal(draftText(makeDraft({status: 'planned', reply: 'Thanks', notes: ' '})), 'status:\nplanned\n\nreply:\nThanks');
+    assert.equal(draftText(null), '');
+    assert.equal(shortWhen('nope'), '');
+});
+
+test('changedFields keeps only what was edited, so a picked-up draft leaves the rest as the record has it now', () => {
+    const saved = {status: 'acknowledged', reply: '', notes: ''};
+    const kept = changedFields({status: 'acknowledged', reply: 'Thanks', notes: ''}, saved);
+    assert.deepEqual(kept, {reply: 'Thanks'});
+    // Later, someone else set the status and wrote notes: the draft puts back only the reply.
+    assert.deepEqual(draftValues(makeDraft(kept), {status: 'planned', reply: '', notes: 'theirs'}), {status: 'planned', reply: 'Thanks', notes: 'theirs'});
+    assert.deepEqual(changedFields({a: '1'}, {a: '1'}), {});
+});