strom-research 1.18.0-beta.3 → 1.18.0-beta.5

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.18.0
 
-*Připravuje se: bety do 1.18.0-beta.3. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.18.0-beta.5. Oddíl bude úplný s vydáním.*
 
 - **Fotky z telefonu nastojato.** Fotka otočená podle údaje EXIF se čte tak, jak se má dívat, nastojato; místa na ní
   vyznačená (výřezy, poloviny dvoustrany, uložená část) jsou místa obrázku, jak se ukazuje. Fotka sama zůstává, jak
@@ -20,7 +20,8 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   z matriky, dopis, listinu, náhrobek, rub fotky: přepis slovo od slova, překlad, význam starých slov a zkratek
   a osoby, které jmenuje, i s tím, kdo ze stromu to může být. Nic se nedomýšlí: jméno, které v dokumentu není,
   vypadne — i příjmení, nikdy se nebere od otce ani z jiné rodiny —, co nejde přečíst, je označené; druhý čtenář
-  může číst naslepo. Do stromu se z toho nic nezapíše samo.
+  může číst naslepo. Do stromu se z toho nic nezapíše samo. Dokument už přečtený to o sobě řekne, takže se omylem
+  nečte podruhé. Dokument čtený znovu se ukazuje pod názvem svého souboru, nikdy pod kódem.
 - **Fotky z telefonu.** `strom phone on`, které zapíná jen člověk, pustí k počítači telefon v domácí síti (Wi-Fi
   nebo kabel — nikdy mobilní síť ani VPN). Telefon se jednou spáruje přes QR kód; jeho stránka pak fotí nebo vybírá
   z galerie a posílá fotky celé do stromu výzkumu, s poznámkou a osobou, kterou ukazují — stejně jako „Přidat

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.18.0
 
-*In Vorbereitung: die Betas bis 1.18.0-beta.3. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.18.0-beta.5. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Handyfotos aufrecht.** Ein Foto, das nach seiner EXIF-Ausrichtung gedreht ist, wird gelesen, wie es gesehen
   werden soll, aufrecht; die darauf markierten Stellen (Ausschnitte, die Hälften einer Doppelseite, ein gespeicherter
@@ -21,7 +21,9 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Abschrift Wort für Wort, ihre Übersetzung, was alte Wörter und Abkürzungen bedeuten, und die genannten Personen,
   samt wem im Stammbaum sie entsprechen können. Nichts wird ergänzt: ein Name, der nicht im Dokument steht, fällt
   weg — auch ein Nachname, nie vom Vater oder aus einer anderen Familie genommen —, Unleserliches wird markiert; ein
-  zweiter Leser kann blind lesen. In den Stammbaum gelangt nichts von selbst.
+  zweiter Leser kann blind lesen. In den Stammbaum gelangt nichts von selbst. Ein schon gelesenes Dokument sagt es,
+  so wird es nicht versehentlich ein zweites Mal gelesen. Ein erneut gelesenes Dokument wird unter dem Namen seiner
+  Datei gezeigt, nie unter einem Code.
 - **Fotos vom Handy.** `strom phone on`, das nur ein Mensch einschaltet, lässt ein Handy im Heimnetz (WLAN oder
   Kabel — nie ein Mobilfunknetz oder ein VPN) zu diesem Computer. Das Handy wird einmal per QR-Code gekoppelt; seine
   Seite fotografiert dann oder wählt aus der Galerie und schickt die Fotos ganz in einen Stammbaum der Forschung, mit

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.18.0
 
-*In preparation: the betas up to 1.18.0-beta.3. The section is complete with the release.*
+*In preparation: the betas up to 1.18.0-beta.5. The section is complete with the release.*
 
 - **Phone photos upright.** A photo turned by its EXIF orientation is read as it is meant to be seen, upright; the
   places marked on it (excerpts, the halves of a spread, a cut-out part) are of the picture as it is shown. The
@@ -20,7 +20,9 @@ The changes of each version in short. The full notes and the install lines are o
   entry, a letter, a deed, a gravestone, the back of a photo: the transcript word for word, its translation, what its
   old words and abbreviations mean, and the people it names, with who of the tree they may be. Nothing is filled in:
   a name the document does not have is left out — a surname too, never taken from a father or another family —,
-  what cannot be read is marked; a second reader can read it blind. Nothing of it enters the tree by itself.
+  what cannot be read is marked; a second reader can read it blind. Nothing of it enters the tree by itself. A
+  document read already says so, so it is not read a second time by mistake. A document read again is shown under
+  the name of its file, never a code.
 - **Photos from a phone.** `strom phone on`, turned on by the person alone, lets a phone on the home network (Wi-Fi
   or a cable — never a mobile network or a VPN) reach this computer. The phone is paired once by its QR code; its
   page then takes photos or picks them from the gallery and sends them whole into a tree of the research, with a

package/assets/lang/cs.json

@@ -674,6 +674,15 @@
   "sync.reading.note": "Uživatel přečetl tento záznam v aplikaci Strom jinak ({source}); čtení výzkumu platí, dokud se záznam nepřečte znovu:",
   "sync.reading.page": "strana",
   "sync.reading.text": "přepis",
+  "read.note.source.edited": "Přepis byl upraven v aplikaci Strom; čtení {read} má: {text}",
+  "read.note.edited": "Přepis byl upraven v aplikaci Strom: vodítko, dokud se záznam nepřečte ({read})",
+  "read.note.one": "Přečetl jeden čtenář ({read}): možné do druhého, slepého čtení a vlastního pohledu výzkumu na záznam",
+  "read.note.differ": "Čtenáři {read} přečetli jinak: {list} — vodítko, dokud se záznam nepřečte",
+  "read.note.absent": "Čtení {read} to tak neuvádí: vodítko, dokud se záznam nepřečte",
+  "read.note.uncertain": "Čtenář {read} si tím nebyl jistý: vodítko, dokud se záznam nepřečte",
+  "read.verify.what": "Ověřit čtení dokumentu u osoby {name}: {list}",
+  "read.verify.why": "údaje stojí na čtení čtenářů stromu ({read}, potvrzeném v aplikaci Strom, {source}), které ještě není jisté: jeden čtenář, rozdílná čtení, nebo ručně upravený přepis; druhé, slepé čtení a vlastní pohled výzkumu na záznam je doloží, nebo ukáže chybu",
+  "read.verify.done": "po jednom čtenáři druhý, slepý (strom document again {read} --readers 2) a zápis prohlédnutý výzkumem samotným (strom source show {source}, jeho snímek): čtení se shodují → pravděpodobné, prokázané až po tomto pohledu a jen u primární informace; liší se → rozpor s oběma čteními",
   "archive.held": "odloženo: výzkum je Archiv Stromu (data přicházejí z aplikace Strom); do fronty se vrátí, až se zapne práce s agentem",
   "archive.removed": "odebráno v aplikaci Strom",
   "archive.wait": "Rozhodnutí o stahování z archivu {title}",
@@ -1172,6 +1181,8 @@
   "ui.sync.do.family.cite.read": "bude ho citovat rodina (její sňatek), na čtení záznamu z aplikace",
   "ui.sync.do.source.new": "pramen výzkumu; přepis z aplikace je vodítko, dokud záznam nepřečte výzkum",
   "ui.sync.do.source.new.read": "pramen výzkumu; přepis z aplikace platí jako čtení záznamu",
+  "ui.sync.do.source.new.reading": "pramen výzkumu z jeho vlastního čtení dokumentu (snímek a výřez zápisu): údaje tak jisté, jak je čtenáři přečetli",
+  "ui.sync.do.source.new.reading.edited": "pramen výzkumu z jeho čtení dokumentu, přepis upravený v aplikaci: údaje jsou vodítko, dokud záznam nepřečte výzkum",
   "ui.sync.do.source.changed": "převezme se: je to čtení z aplikace",
   "ui.sync.do.source.changed.read": "převezme se: je to čtení z aplikace a platí",
   "ui.sync.do.source.reading": "uloží se vedle čtení výzkumu; výzkum záznam přečte znovu",
@@ -1180,6 +1191,7 @@
   "ui.sync.do.fact.cite": "údaj výzkumu ho bude citovat (vodítko, dokud záznam nepřečte výzkum)",
   "ui.sync.do.fact.cite.read": "údaj výzkumu ho bude citovat a stojí na čtení záznamu z aplikace",
   "ui.sync.do.reading": "přidá se na čtení záznamu z aplikace",
+  "ui.sync.do.reading.document": "přidá se tak jistý, jak ho čtenáři dokumentu přečetli (jeden čtenář: možné, dva ve shodě: pravděpodobné, rozdílně: vodítko)",
   "ui.sync.family.new": "{n}. nová rodina: {who}{kids}",
   "ui.sync.child.new": "{n}. {who}: dítě — {child}",
   "ui.sync.child.gone": "{n}. {who}: už to není jejich dítě — {child}",

package/assets/lang/de.json

@@ -674,6 +674,15 @@
   "sync.reading.note": "Der Benutzer hat diesen Eintrag in der Strom-App anders gelesen ({source}); die Lesung der Forschung gilt, bis er erneut gelesen ist:",
   "sync.reading.page": "Seite",
   "sync.reading.text": "Abschrift",
+  "read.note.source.edited": "Die Abschrift wurde in der Strom-App geändert; die Lesung {read} hat: {text}",
+  "read.note.edited": "Die Abschrift wurde in der Strom-App geändert: ein Hinweis, bis der Eintrag gelesen ist ({read})",
+  "read.note.one": "Von einem Leser gelesen ({read}): möglich bis zu einer zweiten, blinden Lesung und dem eigenen Blick der Forschung auf den Eintrag",
+  "read.note.differ": "Die Leser von {read} lasen es verschieden: {list} — ein Hinweis, bis der Eintrag gelesen ist",
+  "read.note.absent": "Die Lesung {read} sagt es nicht so: ein Hinweis, bis der Eintrag gelesen ist",
+  "read.note.uncertain": "Der Leser von {read} war sich dessen nicht sicher: ein Hinweis, bis der Eintrag gelesen ist",
+  "read.verify.what": "Die Lesung eines Dokuments für {name} prüfen: {list}",
+  "read.verify.why": "die Angaben stehen auf einer Lesung der Leser von strom ({read}, in der Strom-App bestätigt, {source}), die noch nicht sicher ist: ein Leser, verschiedene Lesungen oder die Abschrift von Hand geändert; eine zweite, blinde Lesung und der eigene Blick der Forschung auf den Eintrag belegen sie oder zeigen einen Fehler",
+  "read.verify.done": "nach einem Leser ein zweiter, blinder (strom document again {read} --readers 2), und der Eintrag von der Forschung selbst angesehen (strom source show {source}, sein Bild): die Lesungen stimmen überein → wahrscheinlich, belegt erst nach diesem Blick und nur bei primärer Information; sie weichen ab → ein Widerspruch mit beiden Lesungen",
   "archive.held": "zurückgestellt: die Forschung ist ein Strom-Archiv (die Daten kommen aus der Strom-App); zurück in der Warteschlange, wenn die Arbeit mit einem Agenten eingeschaltet wird",
   "archive.removed": "in der Strom-App entfernt",
   "archive.wait": "Entscheidung über das Herunterladen aus dem Archiv {title}",
@@ -1172,6 +1181,8 @@
   "ui.sync.do.family.cite.read": "die Familie (ihre Heirat) zitiert sie, auf die eigene Lesung des Eintrags",
   "ui.sync.do.source.new": "eine Quelle der Forschung; die eigene Abschrift ist ein Hinweis, bis die Forschung den Eintrag liest",
   "ui.sync.do.source.new.read": "eine Quelle der Forschung; die eigene Abschrift gilt als Lesung des Eintrags",
+  "ui.sync.do.source.new.reading": "eine Quelle der Forschung aus ihrer eigenen Lesung des Dokuments (Bild und Ausschnitt des Eintrags): die Angaben so sicher, wie die Leser sie lasen",
+  "ui.sync.do.source.new.reading.edited": "eine Quelle der Forschung aus ihrer Lesung des Dokuments, die Abschrift in der App geändert: die Angaben ein Hinweis, bis die Forschung den Eintrag liest",
   "ui.sync.do.source.changed": "übernommen: es ist die eigene Lesung",
   "ui.sync.do.source.changed.read": "übernommen: es ist die eigene Lesung, und sie gilt",
   "ui.sync.do.source.reading": "neben der Lesung der Forschung festgehalten; die Forschung liest den Eintrag erneut",
@@ -1180,6 +1191,7 @@
   "ui.sync.do.fact.cite": "die Angabe der Forschung zitiert sie (ein Hinweis, bis die Forschung den Eintrag liest)",
   "ui.sync.do.fact.cite.read": "die Angabe der Forschung zitiert sie und steht auf der eigenen Lesung des Eintrags",
   "ui.sync.do.reading": "hinzugefügt auf der eigenen Lesung des Eintrags",
+  "ui.sync.do.reading.document": "wird so sicher hinzugefügt, wie die Leser des Dokuments es lasen (ein Leser: möglich, zwei übereinstimmend: wahrscheinlich, verschieden: ein Hinweis)",
   "ui.sync.family.new": "{n}. eine neue Familie: {who}{kids}",
   "ui.sync.child.new": "{n}. {who}: ein Kind — {child}",
   "ui.sync.child.gone": "{n}. {who}: nicht mehr ihr Kind — {child}",

package/dist/brief/brief.js

@@ -22,6 +22,7 @@ import { clock, hostAllowed, hostState, REFUSED_FOREVER } from "../core/net.js";
 import { archiveLevel } from "../core/terms.js";
 import { onHost, permissionQuestions, setHosts } from "../core/archivewait.js";
 import { runs, runsArg, shellArg } from "../cli/format.js";
+import { readingsLine, readingsOf } from "../core/readsync.js";
 import { commandSheet } from "./sheet.js";
 import { foldText } from "../core/text.js";
 import { subjectPeople } from "../core/records.js";
@@ -933,9 +934,13 @@ export function buildBrief(tree, opts) {
                         const file = inputPath(tree, i);
                         // all that strom input show says of it, so it needs no extra command (K6)
                         const small = !i.text && i.kind === "text" && file && (i.size ?? 0) < 20_000 && /\.(txt|md|csv)$/i.test(file) ? readSmall(file) : undefined;
+                        // read already (strom document read): its result, the file not read again
+                        const read = readingsLine(tree, i);
+                        const readDone = readingsOf(tree, i).some((r) => r.state === "done");
                         return [
                             `${i.id} ${i.name} [${i.kind} · ${i.state}]${i.from ? ` from ${i.from}` : ""}${i.mime ? ` · ${i.mime}${i.size !== undefined ? ` ${Math.round(i.size / 1024)} kB` : ""}` : ""}`,
-                            file ? `file: ${file}${i.kind === "document" || i.kind === "photo" ? " — open it and read it yourself" : ""}` : "",
+                            file ? `file: ${file}${(i.kind === "document" || i.kind === "photo") && !readDone ? " — open it and read it yourself" : ""}` : "",
+                            read ? `read: ${read}` : "",
                             i.batch ? `batch: ${i.batch}${i.path ? ` · ${i.path}` : ""}` : "",
                             i.persons?.length ? `of: ${i.persons.join(", ")}` : "",
                             i.sorted ? `sorted: ${i.sorted.as}${i.sorted.source ? ` → ${i.sorted.source}` : ""}${i.sorted.reason ? ` (${i.sorted.reason})` : ""}` : "",

package/dist/cli/ui.js

@@ -1073,6 +1073,8 @@ export const UI = {
     "ui.sync.do.family.cite.read": "the family (its marriage) cites it, on the file's reading of the record",
     "ui.sync.do.source.new": "a source of the research; the file's transcript is a lead until the research reads the record",
     "ui.sync.do.source.new.read": "a source of the research; the file's transcript counts as a reading of the record",
+    "ui.sync.do.source.new.reading": "a source of the research from its own reading of the document (its picture and the entry's excerpt): the facts as sure as its readers read them",
+    "ui.sync.do.source.new.reading.edited": "a source of the research from its reading of the document, the transcript changed in the app: the facts a lead until the research reads the record",
     "ui.sync.do.source.changed": "taken: it is the file's reading",
     "ui.sync.do.source.changed.read": "taken: it is the file's reading, and it counts",
     "ui.sync.do.source.reading": "kept beside the research's reading; the research reads the record again",
@@ -1081,6 +1083,7 @@ export const UI = {
     "ui.sync.do.fact.cite": "the research's fact cites it (a lead on it until the research reads the record)",
     "ui.sync.do.fact.cite.read": "the research's fact cites it and stands on the file's reading of the record",
     "ui.sync.do.reading": "added on the file's reading of the record",
+    "ui.sync.do.reading.document": "added as sure as the readers of the document read it (one reader: possible; two alike: probable; apart: a lead)",
     "ui.sync.family.new": "{n}. a new family: {who}{kids}",
     "ui.sync.child.new": "{n}. {who}: a child — {child}",
     "ui.sync.child.gone": "{n}. {who}: no longer their child — {child}",

package/dist/commands/document.js

@@ -20,7 +20,7 @@ import { addReaders } from "../core/session.js";
 import { READER_MINUTES_HELP } from "../core/reader.js";
 import { stamp } from "../core/net.js";
 import { readers } from "./readers.js";
-import { alive, APP_READ_FROM, backBefore, beforeOf, buildResult, cancelPath, DOC_NEXT, DOC_PAGES, DOC_VIEWS, docPrompt, endState, FINAL_STATES, listReadings, loadState, newReadId, nextVersion, parseRegion, READ_ID, reportPath, resultPath, saveState, SMALL_PX, withoutDocNext, } from "../core/document.js";
+import { alive, APP_READ_FROM, backBefore, beforeOf, buildResult, cancelPath, DOC_NEXT, DOC_PAGES, DOC_VIEWS, docPrompt, endState, FINAL_STATES, listReadings, loadState, newReadId, nextVersion, parseRegion, READ_ID, reportPath, resultPath, saveState, shownName, SMALL_PX, withoutDocNext, } from "../core/document.js";
 /** How often a reading at work looks whether it was cancelled (strom document cancel, from another process). */
 const CANCEL_LOOK_MS = 500;
 /** The image types a document is read from: a photo, a scan, a PDF (HEIC and PDF converted for the reader). */
@@ -73,6 +73,24 @@ function regionsOf(said) {
     }
     return out;
 }
+/** --name [<file>:]<name>: the name each file is shown under in the reading (the first file's without a number). */
+function namesOf(said, files) {
+    const out = new Map();
+    for (const v of Array.isArray(said) ? said : said === undefined ? [] : [said]) {
+        const m = /^(\d{1,2}):(.*)$/su.exec(String(v));
+        const at = m && Number(m[1]) >= 1 && Number(m[1]) <= files ? Number(m[1]) : 1;
+        const name = shownName(m && at === Number(m[1]) ? m[2] : String(v));
+        if (!name)
+            throw new UsageError(`invalid --name "${String(v).slice(0, 60)}"`, { hint: 'the file\'s name as the person knows it: --name "back of the photo.jpg" (the second file\'s: --name 2:<name>)' });
+        out.set(at, name);
+    }
+    return out;
+}
+/** An image's name for a person: the file it came as (its `from`: "the Strom app: x.jpg", "portal · x.jpg"), else its ID — never its hash. */
+function mediaName(m) {
+    const last = m.from?.split(/: | · /u).at(-1)?.trim();
+    return (last && !last.includes(m.sha.slice(0, 12)) && shownName(last)) || m.id;
+}
 function readersOf(said, dflt) {
     if (said === undefined)
         return dflt;
@@ -97,7 +115,7 @@ function filesOf(ctx, tree, args, persons, note) {
             const id = normId(a.trim(), a.trim().toUpperCase().startsWith("M") ? "media" : "input");
             const file = fileOf(tree, shared, id);
             const rec = id.startsWith("M") ? requireRecord(tree, id, "media") : requireRecord(tree, id, "input");
-            records.push({ id, file, name: "name" in rec && rec.name ? rec.name : path.basename(file), ...(rec.sha ? { sha: rec.sha } : {}) });
+            records.push({ id, file, name: rec.type === "input" ? rec.name : mediaName(rec), ...(rec.sha ? { sha: rec.sha } : {}) });
             continue;
         }
         const p = ctx.resolvePath(a);
@@ -442,6 +460,7 @@ register({
         { name: "region", type: "string", multiple: true, value: "[<page>:]x,y,w,h", description: "read only this part of a page: fractions of it from its top left (repeatable, one per page)" },
         { name: "note", type: "string", value: "<text>", description: "what the person says the document is (\"the back of a photo\") — a description only, never names to find" },
         { name: "person", type: "string", multiple: true, value: "<P…>", description: "a person it is of, as the person says (repeatable)" },
+        { name: "name", type: "string", multiple: true, value: "[<file>:]<name>", description: "the name a file is shown under in the reading (default: its input's name, an image's original file name; repeatable, 2:<name> for the second file)" },
         { name: "model", type: "string", value: "<model>", description: "model of the readers (default: model.vision — never weaker for handwriting)" },
         { name: "minutes", type: "string", value: "<n>", description: READER_MINUTES_HELP, mistaken: ["timeout", "time", "time-limit", "max-minutes"] },
         { name: "queue", type: "boolean", description: "keep it to be read later, read nothing now (strom document read D… reads it)" },
@@ -465,6 +484,8 @@ register({
         tree.withTreeLock(() => {
             try {
                 const { records, added } = filesOf(ctx, tree, args, persons, note);
+                for (const [at, name] of namesOf(opts.name, records.length))
+                    records[at - 1].name = name;
                 pages = pagesOf(tree, records, regions);
                 for (const r of new Set(records.map((x) => x.id)))
                     if (r.startsWith("I"))
@@ -562,20 +583,21 @@ register({
     tree: true,
     args: [{ name: "reading", description: "the reading: D…", required: true }],
     examples: ["strom document show D20260101120000-ab12 --json"],
-    run: (ctx, { args }) => {
-        const tree = ctx.tree();
-        const id = readId(args[0]);
-        const s = loadState(tree.root, id);
-        let result;
-        if (s)
-            result = buildResult(tree, settled(tree, s));
-        else if (fs.existsSync(resultPath(tree.root, id)))
-            result = JSON.parse(fs.readFileSync(resultPath(tree.root, id), "utf8"));
-        else
-            throw new UsageError(`no reading ${id}`, { hint: "strom document list" });
-        return { text: said(ctx, result), data: result };
-    },
+    run: (ctx, { args }) => showReading(ctx, readId(args[0])),
 });
+/** A reading of a document as strom document show (and strom readings D…) says it: its result, or what its readers wrote so far. */
+export function showReading(ctx, id) {
+    const tree = ctx.tree();
+    const s = loadState(tree.root, id);
+    let result;
+    if (s)
+        result = buildResult(tree, settled(tree, s));
+    else if (fs.existsSync(resultPath(tree.root, id)))
+        result = JSON.parse(fs.readFileSync(resultPath(tree.root, id), "utf8"));
+    else
+        throw new UsageError(`no reading ${id}`, { hint: "strom document list" });
+    return { text: said(ctx, result), data: result };
+}
 register({
     path: ["document", "list"],
     summary: "The readings of documents of this research, newest first",

package/dist/commands/intake.js

@@ -8,6 +8,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { register } from "../cli/registry.js";
 import { counted, lines, moreLine, paginate, table, truncate } from "../cli/format.js";
+import { readingsLine, readingsOf } from "../core/readsync.js";
 import { notFound, UsageError } from "../core/errors.js";
 import { collectFiles, fileSha256, inputPath, MAX_IN_TREE, mimeOf, storeShared } from "../core/media.js";
 import { create, normId, requireRecord, update } from "../core/records.js";
@@ -248,8 +249,9 @@ register({
         const all = ctx.tree().list("input").filter((i) => !opts.state || i.state === opts.state);
         const page = paginate(all, ctx.limit, ctx.page);
         return {
-            text: all.length ? lines(table(page.items.map((i) => [i.id, i.kind, i.state, truncate(i.name, 60)])), moreLine(page, "strom input list")) : 'no inputs → strom intake <files or folder>',
-            data: { total: all.length, inputs: opts.full ? page.items : page.items.map((i) => ({ id: i.id, kind: i.kind, state: i.state, name: i.name })) },
+            // a file read already (strom document read) says so: its reading, not read again
+            text: all.length ? lines(table(page.items.map((i) => [i.id, i.kind, i.state, truncate(i.name, 60), i.read?.length ? `read ${i.read[i.read.length - 1]} (strom readings ${i.read[i.read.length - 1]})` : ""])), moreLine(page, "strom input list")) : 'no inputs → strom intake <files or folder>',
+            data: { total: all.length, inputs: opts.full ? page.items : page.items.map((i) => ({ id: i.id, kind: i.kind, state: i.state, name: i.name, ...(i.read?.length ? { read: i.read } : {}) })) },
         };
     },
 }, {
@@ -263,10 +265,10 @@ register({
         const i = requireRecord(tree, args[0], "input");
         const abs = inputPath(tree, i);
         const tasks = tree.list("task").filter((t) => t.where.includes(i.id));
-        const text = lines(`${i.id} ${i.name}  [${i.kind} · ${i.state}]`, abs ? `file   ${abs}` : undefined, i.from ? `from   ${i.from}` : undefined, i.batch ? `batch  ${i.batch}${i.path ? ` · ${i.path}` : ""}` : undefined, i.persons?.length ? `of     ${i.persons.join(", ")}` : undefined, i.sorted ? `sorted ${i.sorted.as}${i.sorted.source ? ` → ${i.sorted.source}` : ""}${i.sorted.reason ? ` (${i.sorted.reason})` : ""}` : undefined, i.mime ? `type   ${i.mime}${i.size !== undefined ? ` · ${Math.round(i.size / 1024)} kB` : ""}` : undefined, i.imported ? `import ${i.imported.persons} persons, ${i.imported.families} families as leads, cited as ${i.source}` : undefined, i.text ? `\n${i.text}` : undefined, !i.text && i.kind === "text" && abs && fs.existsSync(abs) && (i.size ?? 0) < 20_000 && /\.(txt|md|csv)$/i.test(abs) ? `\n${fs.readFileSync(abs, "utf8").trim()}` : undefined, tasks.length ? `\ntasks\n${table(tasks.map((t) => [`  ${t.id}`, t.state, truncate(t.what, 60)]))}` : undefined, ...i.notes.map((n) => `note   ${n.text}`), i.kind === "document" && abs
+        const text = lines(`${i.id} ${i.name}  [${i.kind} · ${i.state}]`, abs ? `file   ${abs}` : undefined, i.from ? `from   ${i.from}` : undefined, i.batch ? `batch  ${i.batch}${i.path ? ` · ${i.path}` : ""}` : undefined, i.persons?.length ? `of     ${i.persons.join(", ")}` : undefined, i.sorted ? `sorted ${i.sorted.as}${i.sorted.source ? ` → ${i.sorted.source}` : ""}${i.sorted.reason ? ` (${i.sorted.reason})` : ""}` : undefined, i.mime ? `type   ${i.mime}${i.size !== undefined ? ` · ${Math.round(i.size / 1024)} kB` : ""}` : undefined, i.imported ? `import ${i.imported.persons} persons, ${i.imported.families} families as leads, cited as ${i.source}` : undefined, i.read?.length ? `read   ${readingsLine(tree, i)}` : undefined, i.text ? `\n${i.text}` : undefined, !i.text && i.kind === "text" && abs && fs.existsSync(abs) && (i.size ?? 0) < 20_000 && /\.(txt|md|csv)$/i.test(abs) ? `\n${fs.readFileSync(abs, "utf8").trim()}` : undefined, tasks.length ? `\ntasks\n${table(tasks.map((t) => [`  ${t.id}`, t.state, truncate(t.what, 60)]))}` : undefined, ...i.notes.map((n) => `note   ${n.text}`), i.kind === "document" && abs && !readingsOf(tree, i).some((r) => r.state === "done")
             ? `\nread the file (a big image: strom media view ${i.id} --grid, then --crop), then record what it says: strom source add … --input ${i.id}`
             : undefined);
-        return { text, data: { input: i, path: abs, tasks: tasks.map((t) => t.id) } };
+        return { text, data: { input: i, path: abs, tasks: tasks.map((t) => t.id), ...(i.read?.length ? { readings: readingsOf(tree, i) } : {}) } };
     },
 }, {
     path: ["input", "done"],

package/dist/commands/output.js

@@ -13,7 +13,7 @@ import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
 import { Settings } from "../core/config.js";
-import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts } from "../core/stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsReadings, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsSourceReads, appShowsFactStatus, appShowsStoryDrafts, appTurnsExcerpts } from "../core/stromapp.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 import { ui } from "../cli/ui.js";
 import { isAgent } from "../core/which.js";
@@ -91,7 +91,9 @@ export function writeTreeGed(tree, opts) {
     const hypothesisLinks = opts.for === "strom" && appShowsHypothesisLinks(new Settings(tree.env, {}), opts.stromVersion);
     // …and the sides of a conflict of the user's edit, for an app that decides it
     const conflictSides = opts.for === "strom" && appDecidesConflicts(new Settings(tree.env, {}), opts.stromVersion);
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}) });
+    // …and the reading of a document each source is an entry of, for an app that opens it
+    const readings = opts.for === "strom" && appShowsReadings(new Settings(tree.env, {}), opts.stromVersion);
+    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {

package/dist/commands/readings.js

@@ -9,6 +9,8 @@ import { counted, lines, runs, shellArg, truncate } from "../cli/format.js";
 import { UsageError } from "../core/errors.js";
 import { requireRecord } from "../core/records.js";
 import { imageRange } from "../core/media.js";
+import { listReadings, READ_ID } from "../core/document.js";
+import { showReading } from "./document.js";
 import { parseReport } from "../core/reader.js";
 import { foldText } from "../core/text.js";
 import { REDUCED_BELOW, viewRegion } from "../core/views.js";
@@ -396,20 +398,29 @@ register({
         "blocks with nothing found only what the reader could not read (a possible match is often there), the gaps in\n" +
         "the page numbering and the parts of the book they saw. One image's block word for word: --image N.\n" +
         "Default: the newest reading; with --images, --image or --match all of them. Nothing is written.",
-    args: [{ name: "which", description: "a record set (B…), or a reading: its report's name or the start of it (a day)" }],
+    args: [{ name: "which", description: "a record set (B…), a reading: its report's name or the start of it (a day), or a reading of a document (D…)" }],
     options: [
         { name: "images", type: "string", value: "<from-to>", description: "only these image numbers, e.g. 40-69 or 5-113,130-228" },
         { name: "image", type: "string", value: "<n>", description: "that image's whole block, word for word (a few: 35-38)" },
         { name: "match", type: "string", multiple: true, value: "<words>", description: "only blocks that mention it — any spelling of accents (repeatable: variants)" },
         { name: "list", type: "boolean", description: "the readings there are, one line each" },
     ],
-    examples: ["strom readings", "strom readings B0001 --images 40-69 --match Novák --match Nowak", "strom readings B0001 --image 57", "strom readings --list"],
+    examples: ["strom readings", "strom readings B0001 --images 40-69 --match Novák --match Nowak", "strom readings B0001 --image 57", "strom readings D20260101120000-ab12", "strom readings --list"],
     run(ctx, { args, opts }) {
         const tree = ctx.tree();
+        const which = args[0]?.trim();
+        // a reading of a document (strom document read): its result, as strom document show says it
+        if (which && READ_ID.test(which))
+            return showReading(ctx, which);
         let all = loadReadings(tree);
-        if (all.length === 0)
+        // the readings of documents, one line each, after those of the books (--list)
+        const documents = () => listReadings(tree.root).map((r) => ({ line: `${r.id} · document · ${r.state} · ${r.files.join(", ")} · ${counted(r.pages, "page")} — strom readings ${r.id}`, data: { id: r.id, state: r.state, files: r.files, pages: r.pages } }));
+        if (all.length === 0) {
+            const docs = opts.list ? documents() : [];
+            if (docs.length)
+                return { text: lines(...docs.map((d) => d.line)), data: { readings: [], documents: docs.map((d) => d.data) } };
             return { text: "no readings yet (strom read writes them into notes/readings)", data: { readings: [] } };
-        const which = args[0]?.trim();
+        }
         let book;
         if (which && /^[Bb]\d+$/.test(which))
             book = requireRecord(tree, which, "recordset").id;
@@ -439,8 +450,9 @@ register({
         if (shown.length === 0)
             return { text: `no reader reported ${image !== undefined ? `image ${runs([...image])}` : "these images"}${book ? ` of ${book}` : ""} · strom readings --list`, data: { readings: [] } };
         if (opts.list) {
-            const text = lines(...shown.flatMap(({ r, blocks }) => readingHead(r, blocks)[0].concat(r.question ? ` · "${truncate(r.question, 60)}"` : "")));
-            return { text, data: { readings: shown.map(({ r, blocks }) => ({ stem: r.stem, question: r.question, reports: r.reports, images: blocks.map((b) => b.num) })) } };
+            const docs = which || ranges || image !== undefined || match.length ? [] : documents();
+            const text = lines(...shown.flatMap(({ r, blocks }) => readingHead(r, blocks)[0].concat(r.question ? ` · "${truncate(r.question, 60)}"` : "")), ...docs.map((d) => d.line));
+            return { text, data: { readings: shown.map(({ r, blocks }) => ({ stem: r.stem, question: r.question, reports: r.reports, images: blocks.map((b) => b.num) })), ...(docs.length ? { documents: docs.map((d) => d.data) } : {}) } };
         }
         if (image !== undefined) {
             const text = lines(...shown.flatMap(({ r, blocks }) => blocks.flatMap((b) => [`${b.report}${b.recordset ? ` · ${b.recordset}` : ""}${r.question ? ` · question: ${truncate(r.question, 120)}` : ""}`, `## ${b.text}`, ""])));

package/dist/commands/sync.js

@@ -77,7 +77,7 @@ function newReads(c, incoming) {
     return !!s && s.quay !== 0 && (incoming.transcripts === "evidence" || !!s.verified);
 }
 /** One change as the user reads it, with what strom does with it. */
-function changeLine(tree, c, incoming, lang) {
+function changeLine(tree, c, incoming, lang, readings) {
     const name = (key) => {
         if (!key)
             return "?";
@@ -150,11 +150,16 @@ function changeLine(tree, c, incoming, lang) {
                                             ? "ui.sync.do.detail"
                                             : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
                                                 ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
-                                                : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
-                                                    ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
-                                                    : c.kind === "fact.new" && c.reads
-                                                        ? "ui.sync.do.reading"
-                                                        : `ui.sync.do.${c.action}`;
+                                                : c.kind === "source.new" && c.reading?.ok
+                                                    ? `ui.sync.do.source.new.reading${c.reading.edited ? ".edited" : ""}`
+                                                    : c.kind.startsWith("source.") || c.kind === "fact.cite" || c.kind === "person.cite" || c.kind === "family.cite"
+                                                        ? `ui.sync.do.${c.kind}${c.reads || (c.kind === "source.new" && newReads(c, incoming)) ? ".read" : ""}`
+                                                        : c.kind === "fact.new" && c.reads
+                                                            ? "ui.sync.do.reading"
+                                                            // a fact on an entry of the research's reading of a document: as sure as its readers read it
+                                                            : c.kind === "fact.new" && c.fact?.cites?.some((x) => readings?.get(x.source)?.ok)
+                                                                ? "ui.sync.do.reading.document"
+                                                                : `ui.sync.do.${c.action}`;
     // an archive: nobody reads a record there, nor is an agent told — said without it
     const said = actsAsArchive(tree) && `${does}.archive` in UI ? `${does}.archive` : does;
     return `${ui(lang, key, v)} → ${ui(lang, said)}`;
@@ -163,7 +168,7 @@ function planText(tree, plan, incoming, file, lang, edits) {
     const shown = file.includes(" ") ? `"${file}"` : file;
     if (!plan.changes.length)
         return ui(lang, "ui.sync.nothing", { file: path.basename(file) });
-    return lines(ui(lang, "ui.sync.title", { file: path.basename(file), n: plan.changes.length }), plan.base ? ui(lang, "ui.sync.base", { head: plan.head?.slice(0, 8) ?? incoming.since ?? "" }) : ui(lang, plan.head ? "ui.sync.headmissing" : "ui.sync.nobase", { head: plan.head?.slice(0, 8) ?? "" }), plan.partial ? ui(lang, "ui.sync.partial") : undefined, plan.identity.strangers.length ? ui(lang, "ui.sync.strangers", { ids: plan.identity.strangers.join(", ") }) : undefined, "", ...plan.changes.map((c) => `  ${changeLine(tree, c, incoming, lang)}`), "", 
+    return lines(ui(lang, "ui.sync.title", { file: path.basename(file), n: plan.changes.length }), plan.base ? ui(lang, "ui.sync.base", { head: plan.head?.slice(0, 8) ?? incoming.since ?? "" }) : ui(lang, plan.head ? "ui.sync.headmissing" : "ui.sync.nobase", { head: plan.head?.slice(0, 8) ?? "" }), plan.partial ? ui(lang, "ui.sync.partial") : undefined, plan.identity.strangers.length ? ui(lang, "ui.sync.strangers", { ids: plan.identity.strangers.join(", ") }) : undefined, "", ...plan.changes.map((c) => `  ${changeLine(tree, c, incoming, lang, plan.readings)}`), "", 
     // an archive mirrors the app whatever the setting says (planSync)
     actsAsArchive(tree) ? ui(lang, "ui.sync.edits.archive") : ui(lang, "ui.sync.edits", { mode: ui(lang, edits === "user" ? "ui.sync.mode.user" : "ui.sync.mode.conflict") }), ui(lang, "ui.sync.next", { file: shown }));
 }

package/dist/core/document.js

@@ -831,6 +831,10 @@ export function backBefore(s) {
 export function nextVersion(s) {
     return Math.max(s.version, ...s.reports.map((r) => r.version)) + 1;
 }
+/** A file's name for a person: its last part, no control characters, at most 200 characters. */
+export function shownName(name) {
+    return path.basename(name.normalize("NFC").replace(/[\\/]+/gu, "/")).replace(/[\p{Cc}]/gu, "").trim().slice(0, 200);
+}
 /** Whoever asked a reading from the Strom app (its bridge). */
 export const APP_READ_FROM = "app:read";
 export function readsDir(root) {

package/dist/core/live-read.js

@@ -15,7 +15,7 @@ import path from "node:path";
 import { spawn } from "node:child_process";
 import { newerTree, Tree } from "./tree.js";
 import { actsAsArchive } from "./state.js";
-import { APP_READ_FROM, alive, backBefore, buildResult, DOC_PAGES, FINAL_STATES, loadState, parseRegion, READ_ID, readsDir, reportPath, resultPath, saveState, statePath } from "./document.js";
+import { APP_READ_FROM, alive, backBefore, buildResult, DOC_PAGES, FINAL_STATES, loadState, parseRegion, READ_ID, readsDir, reportPath, resultPath, saveState, shownName, statePath } from "./document.js";
 import { knownOriginal } from "./originals.js";
 import { readableTypes } from "./readable.js";
 import { makeView } from "./views.js";
@@ -297,6 +297,8 @@ function notReady(tree, settings, env, seen, now) {
     return undefined;
 }
 const BODY_MAX = 16 * 1024;
+/** The names of files sent to be read kept until they are asked (the last ones). */
+const NAMES_KEPT = 200;
 /**
  * The readings of the app: POST /read, /read/<id>/again, /read/<id>/cancel; GET /read/<id>, /read/<id>/page/<n>.jpg,
  * /reads; the queue read one at a time (tick, each tick of the bridge); what changed, for the event read.
@@ -309,11 +311,26 @@ export class AppReadings {
     starting = new Map();
     told = new Map();
     primed = false;
+    /** The name each file to read came under (X-Strom-Name of its last PUT): a file the research had already keeps its own. */
+    names = new Map();
     b;
     constructor(b) {
         this.b = b;
         this.seen = new ReadingsSeen(b.root, b.env);
     }
+    /** A file sent to be read (PUT /media with X-Strom-Read) under its name in the app: the reading of it shown so (sent with no name: its record's own). */
+    named(sha, name) {
+        this.names.delete(sha);
+        // cleaned as strom document read --name cleans it: nothing left (only slashes, control characters) = no name
+        const shown = name && shownName(name);
+        if (shown)
+            this.names.set(sha, shown);
+        for (const old of this.names.keys()) {
+            if (this.names.size <= NAMES_KEPT)
+                break;
+            this.names.delete(old);
+        }
+    }
     /** A reading of the app at work or queued (the bridge does not end idle meanwhile). */
     active() {
         return this.pending > 0 || this.appStates().some((s) => !FINAL_STATES.includes(s.state));
@@ -508,6 +525,8 @@ export class AppReadings {
         }
         const shared = this.b.settings().shared()?.value;
         const records = [];
+        // each file under the name the app sent it with last, else its record's own (never its hash)
+        const names = [];
         const types = readableTypes(this.b.env);
         for (const f of files) {
             const sha = f.toLowerCase();
@@ -521,13 +540,16 @@ export class AppReadings {
             if (known.bytes > READ_MAX_BYTES)
                 return { code: 413, body: refusal(`larger than a reading takes (${READ_MAX_BYTES / 1024 / 1024} MB)`, "read.large", { sha, mb: String(READ_MAX_BYTES / 1024 / 1024) }) };
             records.push(known.id);
+            const name = this.names.get(sha);
+            if (name)
+                names.push(`--name=${records.length}:${name}`);
         }
         const limited = this.limited();
         if (limited)
             return limited;
         return {
             what: "a reading",
-            args: ["document", "read", ...records, "--queue", "--readers", String(readers), "--into", lang, ...(person ? ["--person", person] : []), ...(note ? [`--note=${note}`] : []), ...(region ? [`--region=${region}`] : [])],
+            args: ["document", "read", ...records, "--queue", "--readers", String(readers), "--into", lang, ...(person ? ["--person", person] : []), ...(note ? [`--note=${note}`] : []), ...(region ? [`--region=${region}`] : []), ...names],
             asked: "read",
         };
     }

package/dist/core/live.js

@@ -112,7 +112,7 @@ import { knownNewerVersion, updateChannel } from "./update.js";
 import { whatsNew } from "./whatsnew.js";
 import { gitProgram, runGit } from "./git.js";
 import { RECENT_HOURS, recentChanges, recentNow } from "./recent.js";
-import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, appUrlSetting, isAppVersion, isStromAppOrigin } from "./stromapp.js";
+import { appKnowsArchive, appKnowsNoCouple, appShowsHypothesisLinks, appShowsReadings, appDecidesConflicts, appOpensLinks, appReadsTitles, appShowsCoupleEvents, appShowsEdges, appShowsFactStatus, appShowsSourceReads, appShowsStoryDrafts, appTurnsExcerpts, appUrlSetting, isAppVersion, isStromAppOrigin } from "./stromapp.js";
 import { Settings } from "./config.js";
 import { LINK_SCHEME, linkActions, linkHandlerState, linkHandlerStateLater, linkScheme } from "./links.js";
 import { autoTidy } from "./tidy.js";
@@ -702,7 +702,7 @@ function idsOf(applied, known) {
     return Object.keys(ids.persons).length || Object.keys(ids.sources).length ? { ids } : {};
 }
 /** What the bridge does that an app may ask about (each added once, never taken away). */
-export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now"];
+export const BRIDGE_FEATURES = ["sync.again", "sync.undoneSince", "sync.takenBack", "sync.conflictEdit", "sync.since", "sync.ids", "family.noCouple", "family.alone", "adopt.transfer", "adopt.empty", "material.list", "person.titles", "media.codes", "hypothesis.links", "status.recent", "spend.readers", "hypothesis.intree", "archive.permission", "task.check", "waiting.groups", "waiting.sent", "waiting.note", "batch.kept", "live.end", "whats.new", "terminal.choice", "person.marriedSurname", "phone", "read.now", "read.sync"];
 /** /status recent, when it is ready. */
 function recentOf(root, env, head) {
     const recent = head ? recentNow(root, env, head) : undefined;
@@ -1364,12 +1364,13 @@ export function serveLive(root, env) {
             const titles = appReadsTitles(new Settings(env, {}), version);
             const hypothesisLinks = appShowsHypothesisLinks(new Settings(env, {}), version);
             const conflictSides = appDecidesConflicts(new Settings(env, {}), version);
+            const readings = appShowsReadings(new Settings(env, {}), version);
             const offered = opens ? links(env) : [];
             ged = {
                 head: h,
                 links: offered.join(" "),
                 version: version ?? "",
-                text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
+                text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(sourceReads ? { sourceReads } : {}), ...(factStatus ? { factStatus } : {}), ...(archive ? { archive } : {}), ...(turnsExcerpts ? { turnsExcerpts } : {}), ...(noCouple ? { noCouple } : {}), ...(titles ? { titles } : {}), ...(hypothesisLinks ? { hypothesisLinks } : {}), ...(conflictSides ? { conflictSides } : {}), ...(readings ? { readings } : {}), ...(offered.length ? { links: offered, ...(linkScheme(env) !== LINK_SCHEME ? { linkScheme: linkScheme(env) } : {}) } : {}) }).text,
             };
         }
         res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Strom-Head": h }).end(ged.text);
@@ -1701,6 +1702,11 @@ export function serveLive(root, env) {
                             : {}),
                         // the changes the research could not write (the rest is written): what and why
                         ...(data.skipped?.length ? { skipped: data.skipped } : {}),
+                        // the sources that said they are an entry of a reading of a document (_STROM_READING): taken as the
+                        // research's reading, or not (why: a stable code) and so the app's own source as any
+                        ...(changes.some((c) => c.reading)
+                            ? { readings: changes.filter((c) => c.reading).map((c) => ({ source: c.source.startsWith("x:") ? `@${c.source.slice(2)}@` : c.source, read: c.reading.id, ok: c.reading.ok, ...(c.reading.entry ? { entry: c.reading.entry } : {}), ...(c.reading.code ? { code: c.reading.code } : {}), ...(c.reading.edited ? { edited: true } : {}) })) }
+                            : {}),
                         head: head(root),
                         ...(data.input ? { input: data.input } : {}),
                         conflicts,
@@ -1964,6 +1970,7 @@ export function serveLive(root, env) {
             return typeof v === "string" ? v : undefined;
         };
         let name;
+        let named;
         let note;
         let meta;
         let region;
@@ -1985,7 +1992,8 @@ export function serveLive(root, env) {
             at = "X-Strom-Path";
             where = header("x-strom-path") ? batchPath(decodeURIComponent(header("x-strom-path"))) : undefined;
             at = "X-Strom-Name";
-            name = decodeURIComponent(header("x-strom-name") ?? "") || sha.slice(0, 12);
+            named = decodeURIComponent(header("x-strom-name") ?? "").trim() || undefined;
+            name = named ?? sha.slice(0, 12);
             at = "X-Strom-Note";
             note = header("x-strom-note") ? decodeURIComponent(header("x-strom-note")).slice(0, 500) : undefined;
             at = "X-Strom-Person";
@@ -2028,6 +2036,9 @@ export function serveLive(root, env) {
             if (no)
                 return refuse(409, refusal(no.message, no.code === "task.no-file" ? "waiting.no-file" : "waiting.none", { id: forTask }));
         }
+        // a file to read: its reading shown under the name it came with now — also when the research had it already
+        if (read)
+            reads.named(sha, named);
         receiveOriginal(receiver, req, res, { sha, name, note, persons: meta.persons, source: meta.source, region, batch, where, zip, task: forTask, ...(read ? { read } : {}) });
     };
     const closeBatchNow = (id, extra, reply) => closeBatchBy(receiver, id, extra, reply);