strom-research 1.22.0 → 1.23.0-beta.1

package/CHANGELOG.cs.md

@@ -5,6 +5,27 @@
 Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou na
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (anglicky).
 
+## 1.23.0
+
+*Připravuje se: bety do 1.23.0-beta.1. Oddíl bude úplný s vydáním.*
+
+- **Osoba ukázaná zvoleným jménem.** Žena narozená pod jedním jménem, provdaná pod druhým a po rozvodu zase u prvního
+  se dá ukazovat tímto jménem znovu, aniž by se přidávalo podruhé: `strom name primary <osoba> "<jméno>"` (a
+  `--clear`), nebo `strom name add --primary`. Volba patří jen uživateli, nikdy se nečte ze záznamu; opravy, citace
+  i synchronizace s aplikací Strom se dál řídí rodným jménem. Soubor pro Strom zvolené jméno označí, standardní soubor
+  GEDCOM ho dá na první místo.
+- **Soubor pro aplikaci Strom bez varování.** Export pro aplikaci Strom varoval před nestandardní značkou u každé
+  osoby se zvoleným jménem a u několika značek zdrojů; kontrola teď zná všechny vlastní značky Stromu.
+
+## 1.22.1
+
+*29. 10. 2026 · patří k aplikaci Strom 3.17.0.*
+
+- **Událost místa se u regionu nezapíše znovu.** Když se dějiny místa hledaly dřív než dějiny regionů, do kterých
+  patří, mohly dějiny regionu přidat tutéž událost ještě jednou (stejný druh, stejné roky). Region teď vynechá, co už
+  má některé z jeho míst; událost, která se týkala celého regionu, se zapíše dál. To, co agent k místu čte, říká
+  i to, které z jeho regionů se ještě neprošly.
+
 ## 1.22.0
 
 *29. 10. 2026 · patří k aplikaci Strom 3.17.0.*

package/CHANGELOG.de.md

@@ -5,6 +5,30 @@
 Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Installationszeilen stehen bei
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases) (auf Englisch).
 
+## 1.23.0
+
+*In Vorbereitung: die Betas bis 1.23.0-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+
+- **Eine Person unter dem gewählten Namen.** Eine Frau, unter einem Namen geboren, unter einem anderen verheiratet und
+  nach einer Scheidung wieder beim ersten, lässt sich wieder unter diesem Namen zeigen, ohne dass er ein zweites Mal
+  hinzukommt: `strom name primary <Person> "<Name>"` (und `--clear`) oder `strom name add --primary`. Die Wahl trifft
+  allein der Nutzer, nie wird sie aus einem Eintrag gelesen; Korrekturen, Zitate und der Abgleich mit der Strom-App
+  richten sich weiter nach dem Geburtsnamen. Die Strom-Datei markiert den gewählten Namen, die Standard-GEDCOM-Datei
+  setzt ihn an die erste Stelle.
+- **Die Datei für die Strom-App ohne Warnungen.** Der Export für die Strom-App warnte bei jeder Person mit gewähltem
+  Namen und bei mehreren Kennzeichen von Quellen vor einem nicht standardisierten Tag; die Prüfung kennt jetzt alle
+  eigenen Tags von Strom.
+
+## 1.22.1
+
+*29.10.2026 · gehört zur Strom-App 3.17.0.*
+
+- **Ein Ereignis eines Ortes wird bei seiner Region nicht noch einmal geschrieben.** Wurde die Geschichte eines Ortes
+  vor den Regionen gesucht, zu denen er gehört, konnte die Geschichte der Region dasselbe Ereignis noch einmal
+  hinzufügen (dieselbe Art, dieselben Jahre). Die Region lässt jetzt aus, was einer ihrer Orte schon hat; ein
+  Ereignis, das die ganze Region betraf, wird weiter geschrieben. Was der Agent zu einem Ort liest, sagt auch, welche
+  seiner Regionen noch nicht durchgesehen sind.
+
 ## 1.22.0
 
 *29.10.2026 · gehört zur Strom-App 3.17.0.*

package/CHANGELOG.md

@@ -5,6 +5,27 @@ English · [Čeština](CHANGELOG.cs.md) · [Deutsch](CHANGELOG.de.md)
 The changes of each version in short. The full notes and the install lines are on
 [GitHub Releases](https://github.com/ACiDekCZ/strom-research/releases).
 
+## 1.23.0
+
+*In preparation: the betas up to 1.23.0-beta.1. The section is complete with the release.*
+
+- **A person shown by the name chosen.** A woman born under one name, married under another and back at the first
+  after a divorce can be shown by that name again without it being added twice: `strom name primary <person>
+  "<name>"` (and `--clear`), or `strom name add --primary`. The choice is the user's alone, never read from a record;
+  corrections, citations and the sync with the Strom app still go by the birth name. The Strom file marks the chosen
+  name, the standard GEDCOM file gives it first.
+- **The file for the Strom app without warnings.** Exporting for the Strom app warned of a non-standard tag on each
+  person with a chosen name and on several marks of sources; the check now knows every tag of Strom's own.
+
+## 1.22.1
+
+*2026-10-29 · goes with the Strom app 3.17.0.*
+
+- **An event of a place is not written again for its region.** When the history of a place was looked for before the
+  regions it lies in, the region's history could add the same event once more (the same kind, the same years). The
+  region now leaves out what one of its places has already; an event that touched the whole region is still written.
+  What the agent reads for a place also says which of its regions are not looked through yet.
+
 ## 1.22.0
 
 *2026-10-29 · goes with the Strom app 3.17.0.*

package/assets/lang/cs.json

@@ -1060,6 +1060,7 @@
   "ui.show.name.married": "po sňatku",
   "ui.show.name.religious": "řeholní",
   "ui.show.name.alias": "jinak též",
+  "ui.show.name.current": "hlavní",
   "ui.show.role.godparent": "kmotr",
   "ui.show.role.witness": "svědek",
   "ui.show.role.officiant": "duchovní",
@@ -1348,7 +1349,10 @@
   "ui.sync.do.name.gone": "odebere se (měly ho jen úpravy v aplikaci nebo jiné rodokmeny)",
   "ui.sync.do.name.kept": "zůstává: dokládá ho záznam",
   "ui.sync.do.name.user": "platí úprava z aplikace: osoba se ukazuje pod novým jménem, jméno ze záznamu zůstane vedle něj",
+  "ui.sync.do.name.shown": "osoba se ukazuje tímto jménem",
+  "ui.sync.do.name.shown.conflict": "rozpor k rozhodnutí (výzkum ho změnil také)",
   "ui.sync.name.title": "{n}. {who}: {title} — {old} → {new}",
+  "ui.sync.name.shown": "{n}. {who}: hlavní jméno — {old} → {new}",
   "ui.sync.do.title": "doplní se ke jménu s odkazem na strom z aplikace",
   "ui.sync.do.title.user": "platí úprava z aplikace (verze výzkumu zůstane v historii)",
   "ui.sync.sex.changed": "{n}. {who}: pohlaví {text}",
@@ -2242,6 +2246,8 @@
   "log.note.edit": "Opravená poznámka: {name}",
   "log.name.retract": "Odvolané jméno: {name} – {who}",
   "log.name.restore": "Vrácené jméno: {name} – {who}",
+  "log.name.primary": "Hlavní jméno: {name} – {who}",
+  "log.name.primary.clear": "Hlavní jméno zase rodné: {name} – {who}",
   "log.note.retract": "Odvolaná poznámka: {name}",
   "log.note.restore": "Vrácená poznámka: {name}",
   "log.event.status": "Změněná jistota údaje: {who} – {fact}",
@@ -2507,6 +2513,8 @@
   "ui.conflict.sex": "pohlaví",
   "ui.conflict.sex.U": "neznámé",
   "ui.conflict.name": "jméno",
+  "ui.conflict.primary": "hlavní jméno",
+  "ui.conflict.primary.none": "nezvoleno",
   "ui.conflict.titleBefore": "titul před jménem",
   "ui.conflict.titleAfter": "titul za jménem",
   "ui.conflict.parents": "rodiče",

package/assets/lang/de.json

@@ -1060,6 +1060,7 @@
   "ui.show.name.married": "nach der Heirat",
   "ui.show.name.religious": "Ordensname",
   "ui.show.name.alias": "auch genannt",
+  "ui.show.name.current": "Hauptname",
   "ui.show.role.godparent": "Pate",
   "ui.show.role.witness": "Zeuge",
   "ui.show.role.officiant": "Geistlicher",
@@ -1348,7 +1349,10 @@
   "ui.sync.do.name.gone": "wird entfernt (nur Änderungen in der App oder andere Stammbäume gaben ihn)",
   "ui.sync.do.name.kept": "bleibt: ein Eintrag belegt ihn",
   "ui.sync.do.name.user": "Die eigene Änderung gilt: die Person erscheint unter dem neuen Namen, der Name aus dem Eintrag bleibt daneben",
+  "ui.sync.do.name.shown": "die Person wird so angezeigt",
+  "ui.sync.do.name.shown.conflict": "ein Widerspruch zum Entscheiden (auch die Forschung hat es geändert)",
   "ui.sync.name.title": "{n}. {who}: {title} — {old} → {new}",
+  "ui.sync.name.shown": "{n}. {who}: Hauptname — {old} → {new}",
   "ui.sync.do.title": "wird dem Namen hinzugefügt, mit Verweis auf den eigenen Stammbaum",
   "ui.sync.do.title.user": "Die eigene Änderung gilt (die der Forschung bleibt in ihrer Geschichte)",
   "ui.sync.sex.changed": "{n}. {who}: Geschlecht {text}",
@@ -2242,6 +2246,8 @@
   "log.note.edit": "Notiz berichtigt: {name}",
   "log.name.retract": "Name zurückgezogen: {name} – {who}",
   "log.name.restore": "Name wiederhergestellt: {name} – {who}",
+  "log.name.primary": "Hauptname: {name} – {who}",
+  "log.name.primary.clear": "Hauptname wieder der Geburtsname: {name} – {who}",
   "log.note.retract": "Notiz zurückgezogen: {name}",
   "log.note.restore": "Notiz wiederhergestellt: {name}",
   "log.event.status": "Sicherheit einer Angabe geändert: {who} – {fact}",
@@ -2507,6 +2513,8 @@
   "ui.conflict.sex": "Geschlecht",
   "ui.conflict.sex.U": "unbekannt",
   "ui.conflict.name": "Name",
+  "ui.conflict.primary": "Hauptname",
+  "ui.conflict.primary.none": "nicht gewählt",
   "ui.conflict.titleBefore": "Titel vor dem Namen",
   "ui.conflict.titleAfter": "Titel nach dem Namen",
   "ui.conflict.parents": "Eltern",

package/dist/brief/brief.js

@@ -116,7 +116,7 @@ function personBlock(tree, p, depth, short = false) {
     const out = [`  ${label(p)} ${p.sex}`];
     // other names, and where any name comes from
     if (p.names.length > 1 || p.names.some((n) => n.citations?.length))
-        out.push(`    names: ${p.names.map((n) => `${formatName(n)}${n.kind ? ` (${n.kind})` : ""}${n.citations?.length ? ` ← ${citesOf(n.citations)}` : ""}`).join("; ")}`);
+        out.push(`    names: ${p.names.map((n) => `${formatName(n)}${n.kind ? ` (${n.kind})` : ""}${n.primary ? " (shown by it)" : ""}${n.citations?.length ? ` ← ${citesOf(n.citations)}` : ""}`).join("; ")}`);
     for (const e of p.events.filter((x) => !x.retracted))
         out.push(eventLine(e));
     const parents = parentsOf(tree, p.id);

package/dist/brief/history.js

@@ -200,6 +200,9 @@ function placeSections(tree, id, shared, alone) {
     const events = c?.events ?? [];
     const live = events.filter((e) => !e.retracted);
     const theirs = regionEventsAt(tree, shared, p.id, at);
+    // its regions not looked through yet (K7.1a): what touched the whole region is theirs, written when they are
+    const maps = readPlaces(tree);
+    const waiting = [...new Set((at?.keys ?? []).flatMap((k) => maps[k]?.regions ?? []).map((g) => g.id))].filter((g) => !shared || !readCatalog(shared, g)?.done);
     const out = [];
     out.push({
         name: "history",
@@ -237,6 +240,9 @@ function placeSections(tree, id, shared, alone) {
                 : ["  none yet"]),
             theirs.length ? `The regions' events at this place in its years (${theirs.length}) — the Strom app shows them here already, never written for the place (refused):` : "No region's event at this place yet.",
             ...theirs.slice(0, EVENTS_SHOWN).map(({ event: e, region }) => `  ${e.id} ${years(e.from, e.to)} ${e.kind} (${region.region.id}) "${short(e.text[lang] ?? e.text.en ?? Object.values(e.text)[0] ?? "")}"`),
+            waiting.length
+                ? `Regions of this place not looked through yet (${waiting.join(", ")}): what touched the whole region (a war of the land, its epidemic, a reform of the state) is theirs, written when they are — here only what happened at the place or near enough to touch its people`
+                : "",
             c?.tried.length ? `Pages strom could not read (never tried again): ${c.tried.slice(-20).map((t) => `${t.url} (${short(t.why, 40)})`).join(" · ")}` : "",
         ].filter(Boolean).join("\n"),
     });

package/dist/cli/ui.js

@@ -884,6 +884,7 @@ export const UI = {
     "ui.show.name.married": "married",
     "ui.show.name.religious": "religious",
     "ui.show.name.alias": "alias",
+    "ui.show.name.current": "current",
     "ui.show.role.godparent": "godparent",
     "ui.show.role.witness": "witness",
     "ui.show.role.officiant": "officiant",
@@ -1313,7 +1314,10 @@ export const UI = {
     "ui.sync.do.name.gone": "taken off (only edits in the app or other family trees gave it)",
     "ui.sync.do.name.kept": "kept: a record gives it",
     "ui.sync.do.name.user": "the edit wins: shown by the new name, the record's kept beside it",
+    "ui.sync.do.name.shown": "the person shown by it",
+    "ui.sync.do.name.shown.conflict": "a conflict to decide (the research changed it too)",
     "ui.sync.name.title": "{n}. {who}: {title} — {old} → {new}",
+    "ui.sync.name.shown": "{n}. {who}: name shown — {old} → {new}",
     "ui.sync.do.title": "added to the name, citing the tree sent",
     "ui.sync.do.title.user": "the edit wins (the research's in its history)",
     "ui.sync.sex.changed": "{n}. {who}: sex {text}",
@@ -2432,6 +2436,8 @@ export const UI = {
     "ui.conflict.sex": "sex",
     "ui.conflict.sex.U": "not known",
     "ui.conflict.name": "name",
+    "ui.conflict.primary": "name shown",
+    "ui.conflict.primary.none": "none chosen",
     "ui.conflict.titleBefore": "title before the name",
     "ui.conflict.titleAfter": "title after the name",
     "ui.conflict.parents": "parents",

package/dist/commands/history.js

@@ -15,7 +15,7 @@ import { resolvePerson } from "../core/people.js";
 import { checkQuotes, cleanText, findPassages, mainQuote, pageParts, PageError, quotesShape, readPage, PART_CHARS } from "../core/pagecheck.js";
 import { currentSession } from "../core/session.js";
 import { addLocalEvent, addRegionEvent, askFirst, assignPlace, checkKind, checkTexts, checkYears, deleteEvent, ensureRegion, factPlaceKey, hideEvent, historyAnswer, historyStatus, forGaps, forHistory, gapsOfTask, gapText, historyOrder, historyHeld, historyTurn, mapPlace, raiseHistoryTasks, markDone, donePeriod, noteTried, readCatalog, redoRegion, refuseBeforePage, REGION_LANGS, regionIdOk, regionOfTask, requireHistoryOn, requireRegionId, retractEvent, skipHistory, EVENT_KINDS, yearsToSearch, whoSees, readPlaces, inRegion, regionName, placeRecordOf, } from "../core/pastevents.js";
-import { addPlaceEvent, askPlace, refusePlaceAsk, ensurePlaceCatalog, markPlaceDone, factsByRecord, notePlaceTried, placeEstimate, placeKeyOf, placeLabel, placeOfTask, readPlaceCatalog, refusePlaceBeforePage, requirePlace, setArea, yearsAt, } from "../core/placehistory.js";
+import { addPlaceEvent, askPlace, refusePlaceAsk, ensurePlaceCatalog, markPlaceDone, factsByRecord, notePlaceTried, placeEstimate, placeKeyOf, placeLabel, placeOfTask, readPlaceCatalog, refusePlaceBeforePage, refusePlaceSame, requirePlace, setArea, yearsAt, } from "../core/placehistory.js";
 // strom history list
 import { moreLine, paginate } from "../cli/format.js";
 import { displayName } from "../core/people.js";
@@ -336,8 +336,11 @@ register({
         }
         if (place)
             refusePlaceBeforePage(tree, sh, place, { kind, from, to }, s, url);
-        else
+        else {
             refuseBeforePage(sh, region, { kind, from, to }, s, url);
+            if (!s.sameAs && !s.distinct)
+                refusePlaceSame(tree, sh, region, { kind, from, to });
+        }
         let checked;
         try {
             checked = await checkQuotes(url, quotes, { from, to }, sh, ctx.env);
@@ -363,6 +366,9 @@ register({
             sha: checked.page.sha,
         };
         const event = { from, to, ...(date ? { date } : {}), kind, text, ...(why ? { why } : {}), ...(tip ? { tip } : {}), ...(opts.sensitive ? { sensitive: true } : {}), source };
+        // a place looked for before its region (K7.1a): its own events checked again once the page is read
+        if (!place && !s.sameAs && !s.distinct)
+            refusePlaceSame(tree, sh, region, { kind, from, to });
         const r = place ? addPlaceEvent(tree, sh, place, event, s) : addRegionEvent(sh, tree.config.id, { region: region, ...event }, s);
         const where = place ? `at ${placeLabel(place, "en")} (${place.id}) and its surroundings` : `in ${region}`;
         // who it shows at (their person in the Strom app, their story): for the agent to say to the person who asked

package/dist/commands/people.js

@@ -3,13 +3,13 @@ import { register } from "../cli/registry.js";
 import { lines, moreLine, paginate, table, truncate } from "../cli/format.js";
 import { suggestionLines, suggestPeople } from "../core/participantlinks.js";
 import { checkStreetPlace } from "../core/streets.js";
-import { addChild, addEvent, addFamily, addName, addNote, addPerson, citeEvent, citeRecord, editEvent, editFamily, editPerson, findEventOwner, mergeFamilies, notRetracted, mergePersons, parseParticipant, retractEvent, retractPerson } from "../core/actions.js";
+import { addChild, addEvent, addFamily, addName, addNote, addPerson, citeEvent, citeRecord, editEvent, editFamily, editPerson, findEventOwner, markPrimaryName, mergeFamilies, notRetracted, mergePersons, parseParticipant, retractEvent, retractPerson } from "../core/actions.js";
 import { listOpt, normId, requireRecord } from "../core/records.js";
 import { SINGLE_KINDS } from "../core/actions.js";
 import { UsageError } from "../core/errors.js";
 import { INFORMATION } from "../core/evidence.js";
 import { EVENT_KINDS, NAME_KINDS } from "../core/model.js";
-import { ancestorGenerations, displayName, familiesAsChild, familiesAsPartner, findPersons, formatName, gedcomName, label, lifespan, parseName, primaryName, relationTo, resolvePerson, sameName, titledName, } from "../core/people.js";
+import { ancestorGenerations, currentName, displayName, familiesAsChild, familiesAsPartner, findPersons, formatName, gedcomName, label, lifespan, parseName, primaryName, relationTo, resolvePerson, sameName, titledName, } from "../core/people.js";
 import { resolveResearch } from "./research.js";
 import { editNote, notesOf, restoreName, restoreNote, retractName, retractNote } from "../core/retractions.js";
 import { DEATH_AFTER_YEARS, unprovenPeople } from "../core/review.js";
@@ -126,7 +126,7 @@ function citesOf(citations, w = ENGLISH) {
 }
 function nameLine(n, w = ENGLISH) {
     const cites = citesOf(n.citations, w);
-    return `${titledName(n)}${n.kind ? ` (${w.word("name", n.kind)})` : ""}${cites ? `  ← ${cites}` : ""}`;
+    return `${titledName(n)}${n.kind ? ` (${w.word("name", n.kind)})` : ""}${n.primary ? ` · ${w.word("name", "current")}` : ""}${cites ? `  ← ${cites}` : ""}`;
 }
 function historyOf(p) {
     const out = [];
@@ -305,7 +305,7 @@ register({
         const who = (x) => (shown.add(x), relative(x, w));
         const out = [
             ...(removed ? [removed.line, ""] : []),
-            `${p.id} ${titledName(primaryName(p))}${lifespan(p) ? ` (${lifespan(p)})` : ""}  ${w.lang ? w.word("sex", p.sex) : `sex ${p.sex}`}`,
+            `${p.id} ${titledName(currentName(p))}${lifespan(p) ? ` (${lifespan(p)})` : ""}  ${w.lang ? w.word("sex", p.sex) : `sex ${p.sex}`}`,
             ...(p.names.length > 1 || p.names.some((n) => n.citations?.length) ? ["", w.say("ui.show.names", "names"), ...p.names.map((n) => `  ${nameLine(n, w)}`)] : []),
             "",
             w.say("ui.show.facts", "facts"),
@@ -426,14 +426,15 @@ register({
     tree: true,
     writes: true,
     description: "A name without a surname (\"Markéta\") is completed by the full one and the person is shown by it; the same\n" +
-        "name again only adds its citation. A woman is shown by her birth name; --kind married keeps the married one aside.",
+        "name again only adds its citation. A woman is shown by her birth name; --kind married keeps the married one aside.\n" +
+        "--primary shows the person by this name from now on (strom name primary marks a name they have already).",
     args: [
         { name: "person", description: "ID (P0001) or name", required: true },
         { name: "name", description: 'the name, surname in slashes: "Markéta /Růžičková/"', required: true },
     ],
     options: [
         { name: "kind", type: "string", value: "<kind>", description: `${NAME_KINDS.join(", ")} (default: plain)` },
-        { name: "primary", type: "boolean", description: "show the person by this name" },
+        { name: "primary", type: "boolean", description: "show the person by this name now (their identity stays the birth name)" },
         ...TITLE_OPTIONS,
         ...CITE_OPTIONS.filter((o) => o.name !== "status"),
     ],
@@ -454,6 +455,34 @@ register({
         const r = addName(tree, p.id, { name: args[1], kind: opts.kind, citation: citationOf(opts), primary: Boolean(opts.primary), prefix: opts.prefix, suffix: opts.suffix });
         return { text: written(tree), data: { person: r.person, name: r.name } };
     },
+}, {
+    path: ["name", "primary"],
+    summary: "Show a person by one of their names now — a divorced woman back at her birth surname — without adding it again",
+    group: "people",
+    tree: true,
+    writes: true,
+    description: "The user's choice, never told from a record (a divorce does not say it): the name is marked, every other name\n" +
+        "stays as it is. person show, lists, the brief, the Strom app show the person by it; their identity — what a\n" +
+        "correction (person edit --name), a citation of the person and pairing go by — stays the birth name. --clear takes\n" +
+        "the mark off: shown by the birth name again (the Strom app: by the married surname, as before).",
+    args: [
+        { name: "person", description: "ID (P0001) or name", required: true },
+        { name: "name", description: 'one of their names, surname in slashes: "Jana /Lhotová/" (none with --clear)' },
+    ],
+    options: [
+        { name: "clear", type: "boolean", description: "take the mark off: no name chosen" },
+    ],
+    examples: ['strom name primary P0002 "Josef /Nowak/"', "strom name primary P0002 --clear"],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const p = resolvePerson(tree, args[0]);
+        if (opts.clear && args[1] !== undefined)
+            throw new UsageError("a name or --clear, not both", { hint: `strom name primary ${p.id} "<Given /Surname/>" · strom name primary ${p.id} --clear` });
+        if (!opts.clear && args[1] === undefined)
+            throw new UsageError("which name?", { hint: `its names: ${p.names.map((n) => `"${gedcomName(n)}"`).join(", ")} · strom name primary ${p.id} "<Given /Surname/>" · --clear` });
+        const r = markPrimaryName(tree, p.id, opts.clear ? undefined : args[1], opts.reason);
+        return { text: written(tree), data: { person: r.person, name: r.name, ...(r.was ? { was: r.was } : {}) } };
+    },
 }, {
     path: ["name", "retract"],
     summary: "Take back a name of a person that turned out wrong (kept with the reason, shown nowhere but in the history)",

package/dist/commands/sync.js

@@ -110,8 +110,8 @@ function changeLine(tree, c, incoming, lang, readings) {
         now: c.kind === "fact.detail" ? detailText(c.fact, lang, short) : factText(c.fact, lang, short),
         when: [humanDate(c.fact?.date, lang), humanPlace(c.fact?.place, undefined, lang)].filter(Boolean).join(", "),
         text: truncate(c.text ?? "", 120),
-        old: c.note ? truncate(c.note.was, 80) : c.title ? truncate(c.title.was, 80) || "—" : c.wasTitle !== undefined ? truncate(c.wasTitle, 80) : shownName(c.wasName),
-        new: c.note ? truncate(c.text ?? "", 80) : c.title || c.wasTitle !== undefined ? truncate(c.text ?? "", 80) || "—" : shownName(c.text),
+        old: c.note ? truncate(c.note.was, 80) : c.title ? truncate(c.title.was, 80) || "—" : c.wasTitle !== undefined ? truncate(c.wasTitle, 80) : c.shown ? shownName(c.wasName) || ui(lang, "ui.conflict.primary.none") : shownName(c.wasName),
+        new: c.note ? truncate(c.text ?? "", 80) : c.title || c.wasTitle !== undefined ? truncate(c.text ?? "", 80) || "—" : c.shown ? shownName(c.text) || ui(lang, "ui.conflict.primary.none") : shownName(c.text),
         title: c.title ? ui(lang, c.title.part === "before" ? "ui.conflict.titleBefore" : "ui.conflict.titleAfter") : "",
         child: name(c.child),
         // a child's tie to each parent: one word for both, else each parent's
@@ -148,30 +148,32 @@ function changeLine(tree, c, incoming, lang, readings) {
                         ? `ui.sync.do.removed${c.action === "conflict" ? ".conflict" : ""}`
                         : c.kind === "name.changed" && c.action === "user"
                             ? "ui.sync.do.name.user"
-                            : c.kind === "name.gone"
-                                ? `ui.sync.do.name.${c.action === "remove" ? "gone" : "kept"}`
-                                : c.kind === "name.title" && (c.action === "add" || c.action === "user")
-                                    ? `ui.sync.do.title${c.action === "user" ? ".user" : ""}`
-                                    : c.kind === "note.changed" && c.action !== "pick"
-                                        ? "ui.sync.do.note.changed"
-                                        : c.kind === "family.union" && c.action !== "report"
-                                            ? "ui.sync.do.family.union"
-                                            : c.kind === "fact.detail" && c.action === "add"
-                                                ? "ui.sync.do.detail"
-                                                : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
-                                                    ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
-                                                    : c.kind === "source.title"
-                                                        ? `ui.sync.do.source.title${c.action === "add" ? ".beside" : c.action === "user" ? ".user" : ""}`
-                                                        : 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}`;
+                            : c.kind === "name.shown"
+                                ? `ui.sync.do.name.shown${c.action === "conflict" ? ".conflict" : ""}`
+                                : c.kind === "name.gone"
+                                    ? `ui.sync.do.name.${c.action === "remove" ? "gone" : "kept"}`
+                                    : c.kind === "name.title" && (c.action === "add" || c.action === "user")
+                                        ? `ui.sync.do.title${c.action === "user" ? ".user" : ""}`
+                                        : c.kind === "note.changed" && c.action !== "pick"
+                                            ? "ui.sync.do.note.changed"
+                                            : c.kind === "family.union" && c.action !== "report"
+                                                ? "ui.sync.do.family.union"
+                                                : c.kind === "fact.detail" && c.action === "add"
+                                                    ? "ui.sync.do.detail"
+                                                    : c.kind === "fact.part" && (c.action === "add" || c.action === "user")
+                                                        ? `ui.sync.do.part${c.action === "user" ? ".user" : ""}`
+                                                        : c.kind === "source.title"
+                                                            ? `ui.sync.do.source.title${c.action === "add" ? ".beside" : c.action === "user" ? ".user" : ""}`
+                                                            : 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)}`;

package/dist/core/actions.js

@@ -5,7 +5,7 @@ import { normalizeDate, reversedRange } from "./gdate.js";
 import { normalizeAge } from "./age.js";
 import { checkStatus, defaultStatus } from "./evidence.js";
 import { eventKind, FAMILY_EVENT_KINDS, NOTE_MAX, STATUSES, PARTICIPANT_ROLES, NAME_KINDS, RECORD_TYPES, } from "./model.js";
-import { cleanTitle, displayName, familiesAsChild, familiesAsPartner, gedcomName, gedcomTitledName, closesCircle, isAncestorOf, isBirthFamily, keepSides, notAName, parseName, primaryName, sameName, slashInName } from "./people.js";
+import { cleanTitle, displayName, familiesAsChild, familiesAsPartner, gedcomName, gedcomTitledName, closesCircle, isAncestorOf, isBirthFamily, keepSides, notAName, parseName, primaryName, sameName, slashInName, withoutMark } from "./people.js";
 import { foldText } from "./text.js";
 import { roleWord } from "./roles.js";
 import { checkParticipant, trailingNote } from "./participants.js";
@@ -651,8 +651,8 @@ export function addName(tree, id, input) {
             throw new UsageError(`invalid --kind "${input.kind}"`, { hint: NAME_KINDS.join(", ") });
         name.kind = input.kind;
     }
-    if (input.primary && name.kind && name.kind !== "birth")
-        throw new UsageError(`a person is shown by a birth name, not a ${name.kind} one`, { hint: "drop --primary, or --kind birth" });
+    if (input.first && name.kind && name.kind !== "birth")
+        throw new UsageError(`a person's identity is a birth name, not a ${name.kind} one`);
     if (input.citation)
         checkCitation(tree, input.citation);
     return tree.withTreeLock(() => {
@@ -667,11 +667,12 @@ export function addName(tree, id, input) {
             const rekind = name.kind !== undefined && name.kind !== cur.kind;
             const retitled = withTitles(cur, input.prefix, input.suffix);
             const titles = retitled.prefix !== cur.prefix || retitled.suffix !== cur.suffix;
-            if (!input.citation && !input.primary && !rekind && !titles)
-                throw new UsageError(`${id} already has the name ${gedcomName(name)}`, { hint: `cite it: strom name add ${id} "${gedcomName(name)}" --cite S…` });
-            added = { ...retitled, ...(rekind ? { kind: name.kind } : {}), ...(input.citation ? { citations: withCitation(cur.citations, input.citation, `${id} ${gedcomName(name)}`) } : {}) };
+            const marks = !!input.primary && !cur.primary;
+            if (!input.citation && !marks && !input.first && !rekind && !titles)
+                throw new UsageError(input.primary ? `${id} is shown by ${gedcomName(cur)} already` : `${id} already has the name ${gedcomName(name)}`, { hint: `cite it: strom name add ${id} "${gedcomName(name)}" --cite S…` });
+            added = { ...retitled, ...(rekind ? { kind: name.kind } : {}), ...(input.primary ? { primary: true } : {}), ...(input.citation ? { citations: withCitation(cur.citations, input.citation, `${id} ${gedcomName(name)}`) } : {}) };
             names = p.names.map((n, j) => (j === i ? added : n));
-            if (input.primary)
+            if (input.first)
                 names = [added, ...names.filter((n) => n !== added)];
         }
         else {
@@ -681,19 +682,62 @@ export function addName(tree, id, input) {
             const plain = !name.kind || name.kind === "birth";
             // "Markéta" of the family memory is "Markéta /Růžičková/" of the register: one name, now complete.
             completes = Boolean(!input.other && plain && !primary.surname && name.surname && foldText(primary.given) === foldText(name.given) && !primary.citations?.length);
+            // the name completed was the one the person is shown by: the full one is
+            if (input.primary || (completes && primary.primary))
+                added = { ...added, primary: true };
             const rest = completes ? p.names.filter((n) => n !== primary) : p.names;
-            names = !input.other && (input.primary || (plain && !primary.surname && name.surname)) ? [added, ...rest] : [...rest, added];
+            names = !input.other && (input.first || (plain && !primary.surname && name.surname)) ? [added, ...rest] : [...rest, added];
         }
+        // one name the person is shown by: the one marked now
+        if (added.primary)
+            names = names.map((n) => (n === added || !n.primary ? n : withoutMark(n)));
         const updated = { ...p, names, updated: now() };
         tree.put(updated, {
             op: "person.name",
             targets: [id],
-            summary: `${id} name ${gedcomTitledName(added)}${added.kind ? ` (${added.kind})` : ""}${input.citation ? ` ← ${input.citation.source}` : ""}`,
+            summary: `${id} name ${gedcomTitledName(added)}${added.kind ? ` (${added.kind})` : ""}${input.citation ? ` ← ${input.citation.source}` : ""}${input.primary ? "; shown by it" : ""}`,
             ...(completes ? { reason: `the name without a surname is completed: ${gedcomName(added)}` } : {}),
         });
         return { person: updated, name: added };
     });
 }
+/**
+ * Show a person by one of their names (the mark Name.primary: a divorced woman back at her birth surname, spec 024),
+ * without adding it again — or, with no name, by the name of their identity again (the mark taken off). The user's
+ * choice: never told from a record, never needs one.
+ */
+export function markPrimaryName(tree, id, text, reason) {
+    const wanted = text === undefined ? undefined : parseName(text);
+    if (wanted && !wanted.given && !wanted.surname)
+        throw new UsageError("the name is empty");
+    return tree.withTreeLock(() => {
+        const p = requirePerson(tree, id);
+        const was = p.names.find((n) => n.primary);
+        let name;
+        if (wanted) {
+            const found = p.names.find((n) => sameName(n, wanted));
+            if (!found) {
+                const gone = p.retractedNames?.find((n) => sameName(n, wanted));
+                if (gone)
+                    throw new UsageError(`the name ${gedcomName(gone)} of ${id} was retracted: ${gone.retracted.reason}`, { hint: `right after all: strom name restore ${id} "${gedcomName(gone)}" --reason "…"`, code: "name.retracted", params: { name: gedcomName(gone), id, reason: gone.retracted.reason } });
+                throw new UsageError(`${id} has no name ${gedcomName(wanted)}`, { hint: `its names: ${p.names.map((n) => `"${gedcomName(n)}"`).join(", ")} · a new one: strom name add ${id} "${gedcomName(wanted)}" --primary`, code: "name.none" });
+            }
+            if (found.primary)
+                throw new UsageError(`${id} is shown by ${gedcomName(found)} already`, { hint: `back to the name of their identity: strom name primary ${id} --clear` });
+            name = { ...found, primary: true };
+            const names = p.names.map((n) => (n === found ? name : n.primary ? withoutMark(n) : n));
+            const updated = { ...p, names, updated: now() };
+            tree.put(updated, { op: "name.primary", targets: [id], summary: `${id} shown by ${gedcomName(name)}${was ? ` (was ${gedcomName(was)})` : ""}`, ...(reason?.trim() ? { reason: reason.trim() } : {}) });
+            return { person: updated, name, ...(was ? { was } : {}) };
+        }
+        if (!was)
+            throw new UsageError(`no name of ${id} is marked: shown by ${gedcomName(primaryName(p))}`, { hint: `strom name primary ${id} "<Given /Surname/>"` });
+        const updated = { ...p, names: p.names.map((n) => (n === was ? withoutMark(n) : n)), updated: now() };
+        name = primaryName(updated);
+        tree.put(updated, { op: "name.primary", targets: [id], summary: `${id} shown by ${gedcomName(name)} again (the mark of ${gedcomName(was)} taken off)`, ...(reason?.trim() ? { reason: reason.trim() } : {}) });
+        return { person: updated, name, was };
+    });
+}
 /** Change a person's sex or correct the spelling of their name — with a reason, unless an unknown sex is filled in. */
 export function editPerson(tree, id, edit, reason) {
     const sex = edit.sex === undefined ? undefined : parseSex(edit.sex);
@@ -925,13 +969,20 @@ export function mergePersons(tree, keepId, otherId, reason) {
         const names = keep.names.map((n) => {
             const same = other.names.find((o) => sameName(o, n));
             const cites = [...(n.citations ?? []), ...(same?.citations ?? []).filter((c) => !(n.citations ?? []).some((x) => x.source === c.source && x.locator === c.locator))];
-            return cites.length ? { ...n, citations: cites } : n;
+            // the other shown by this same name, the kept one by none marked: shown by it
+            const mark = same?.primary && !keep.names.some((k) => k.primary) ? { primary: true } : {};
+            return cites.length ? { ...n, ...mark, citations: cites } : { ...n, ...mark };
         });
         // a name the person's research took back stays taken back (the other's retracted come along, for the history)
         const retractedNames = [...(keep.retractedNames ?? []), ...(other.retractedNames ?? [])];
         for (const o of other.names)
             if (!names.some((n) => sameName(n, o)) && !retractedNames.some((n) => sameName(n, o)))
                 names.push(o);
+        // the name they are shown by: the kept person's, else the other's — one
+        const marked = names.find((n) => n.primary);
+        for (let i = 0; i < names.length; i++)
+            if (names[i].primary && names[i] !== marked)
+                names[i] = withoutMark(names[i]);
         const retractedNotes = [...(keep.retractedNotes ?? []), ...(other.retractedNotes ?? [])];
         const refs = [...(keep.refs ?? []), ...(other.refs ?? []).filter((r) => !(keep.refs ?? []).some((k) => k.system === r.system && k.id === r.id))];
         const why = reason.trim();

package/dist/core/changelog.js

@@ -365,6 +365,11 @@ export function changeLines(tree, ops, subject, lang, was, tasks) {
             say(m ? phrase(lang, o.op === "name.retract" ? "log.name.retract" : "log.name.restore", { name: m[1].replace(/\//g, " ").replace(/\s+/g, " ").trim(), who: who(first) }) : changed(o));
             continue;
         }
+        if (o.op === "name.primary") {
+            const m = /^\S+ shown by (.+?)( again \(|(?: \(was |$))/.exec(o.summary);
+            say(m ? phrase(lang, m[2] === " again (" ? "log.name.primary.clear" : "log.name.primary", { name: m[1].replace(/\//g, " ").replace(/\s+/g, " ").trim(), who: who(first) }) : changed(o));
+            continue;
+        }
         if (o.op === "note.remove") {
             const m = /^\S+ note "(.*)" removed:/.exec(o.summary);
             say(m ? phrase(lang, "log.note.remove", { note: m[1], name: name(first) }) : changed(o));

package/dist/core/import.js

@@ -12,7 +12,7 @@ import { roleWord } from "./roles.js";
 import { validateRecord } from "./validate.js";
 import { normalizeDate } from "./gdate.js";
 import { isRetractedName } from "./retractions.js";
-import { appNoSurname, cleanTitle, gedcomName, noName, notAName, parseName, sameName, surnameAfterGiven, withoutTitles } from "./people.js";
+import { appNoSurname, cleanTitle, gedcomName, noName, notAName, parseName, sameName, surnameAfterGiven, withoutMark, withoutTitles } from "./people.js";
 import { update } from "./records.js";
 import { now } from "./tree.js";
 import { appUnknownIsNoSurname, appWritesSexUnknown } from "./stromapp.js";
@@ -373,9 +373,14 @@ export function importGedcom(tree, text, opts) {
                 if (notAName(found.given))
                     found.given = "?";
                 // a slash inside a name ("/⟨K/Č⟩emenská/") is kept as "|": the name stays one GEDCOM can write
-                return { ...found, given: found.given.replace(/\//g, "|"), surname: found.surname.replace(/\//g, "|") };
+                const name = { ...found, given: found.given.replace(/\//g, "|"), surname: found.surname.replace(/\//g, "|") };
+                // the name the person is shown by now (the Strom file's mark, the user's choice): the first one marked
+                if (/^y(es)?$/i.test(val(n, "_STROM_PRIMARY")?.trim() ?? ""))
+                    name.primary = true;
+                return name;
             })
-                .map((n) => (n.given || n.surname ? n : { ...n, given: "?", surname: "" }));
+                .map((n) => (n.given || n.surname ? n : { ...n, given: "?", surname: "" }))
+                .map((n, i, all) => (n.primary && all.findIndex((m) => m.primary) !== i ? withoutMark(n) : n));
             // a married name other programs give apart (_MARNM): a name of the married kind, unless the person has it already
             return [...names, ...importedMarnm(r, fromApp).filter((m) => !names.some((n) => sameName(n, m)))];
         };
@@ -407,7 +412,8 @@ export function importGedcom(tree, text, opts) {
                 const facts = incoming.filter((e) => !knownFact(cur.events, e));
                 result.events -= incoming.length - facts.length;
                 // a name the research took back is not taken again from a file that still has it
-                const names = namesOf(r).filter((n) => n.given !== "?" && !cur.names.some((x) => sameName(x, n)) && !isRetractedName(cur, n));
+                // the names another file adds: never the one the person is shown by (theirs stands)
+                const names = namesOf(r).filter((n) => n.given !== "?" && !cur.names.some((x) => sameName(x, n)) && !isRetractedName(cur, n)).map(withoutMark);
                 if (!facts.length && !names.length)
                     continue;
                 const next = { ...cur, names: [...cur.names, ...names], events: [...cur.events, ...facts], refs: [...(cur.refs ?? []), { system, id: r.xref }], updated: now() };

package/dist/core/live.js

@@ -917,7 +917,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", "read.sync", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "duplicates.judge", "quality.dismiss", "quality.read"];
+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", "excerpt.get", "log.sources", "material.assign", "material.thumb", "seal.foreign", "tree.state", "disk.full", "tree.notDownloaded", "sync.removed", "tree.kind", "experiments", "experiments.off", "experiments.link", "experiments.split", "history.events", "history.hide", "experiments.pace", "history.first", "history.regions", "history.hide.all", "history.skip", "history.map", "history.delete", "history.delete.restore", "stories.history", "history.place", "surnames.suggest", "surnames.read", "duplicates.judge", "quality.dismiss", "quality.read", "person.primary"];
 /** /status recent, when it is ready. */
 function recentOf(root, env, head) {
     const recent = head ? recentNow(root, env, head) : undefined;

package/dist/core/overview.js

@@ -2,7 +2,7 @@
 // ancestors of one person (pedigree), one person's life (card), and what came
 // in lately (recent). Read only, from the records and the operation logs; the
 // commands in commands/browse.ts show them in the research language.
-import { ancestorGenerations, birthEvent, displayName, familiesAsPartner, formatName, lifespan, parentsOf, primaryName, sameName, titledName } from "./people.js";
+import { ancestorGenerations, birthEvent, currentName, displayName, familiesAsPartner, formatName, lifespan, parentsOf, sameName, titledName } from "./people.js";
 import { dateYears } from "./gdate.js";
 import { informationOf } from "./evidence.js";
 import { imagesIndex } from "./mediaindex.js";
@@ -159,7 +159,8 @@ export function cardFact(tree, e) {
     };
 }
 export function personCard(tree, p) {
-    const main = primaryName(p);
+    // the name they are shown by (the one the user chose, else their birth name): the others beside it
+    const main = currentName(p);
     const families = familiesAsPartner(tree, p.id).map((f) => {
         const other = f.partners.filter((x) => x !== p.id).map((x) => tree.get(x)).find((x) => x && !x.retracted);
         return {

package/dist/core/people.js

@@ -179,8 +179,21 @@ export function slashInName(n) {
 export function primaryName(p) {
     return p.names.find((n) => !n.kind || n.kind === "birth") ?? p.names[0] ?? { given: "", surname: "" };
 }
+/**
+ * The name the person is shown by now: the one marked (Name.primary, the user's choice — a divorced woman back at her
+ * birth surname), else the name of their identity (primaryName). Only for showing them: the identity a correction, a
+ * citation, pairing and a sync go by stays primaryName.
+ */
+export function currentName(p) {
+    return p.names.find((n) => n.primary) ?? primaryName(p);
+}
+/** A name without the mark of the one the person is shown by (Name.primary). */
+export function withoutMark(n) {
+    const { primary: _p, ...rest } = n;
+    return rest;
+}
 export function displayName(p) {
-    return formatName(primaryName(p));
+    return formatName(currentName(p));
 }
 const STATUS_RANK = { proven: 0, probable: 1, possible: 2, lead: 3 };
 /** Best-supported first: status, then the number of citations, then the order they were added. */

package/dist/core/phrases.js

@@ -271,6 +271,8 @@ export const PHRASES = {
     "log.note.edit": "Note corrected: {name}",
     "log.name.retract": "Name retracted: {name} – {who}",
     "log.name.restore": "Name put back: {name} – {who}",
+    "log.name.primary": "Shown by the name: {name} – {who}",
+    "log.name.primary.clear": "Shown by the birth name again: {name} – {who}",
     "log.note.retract": "Note retracted: {name}",
     "log.note.restore": "Note put back: {name}",
     "log.event.status": "How sure a fact is, changed: {who} – {fact}",

package/dist/core/placehistory.js

@@ -218,6 +218,39 @@ export function regionEventsAt(tree, shared, id, at = factsByRecord(tree).get(id
     }
     return [...out.values()].sort((a, b) => a.event.from - b.event.from || a.event.id.localeCompare(b.event.id));
 }
+/**
+ * The own events of the tree's places that belong to a region in the years of an event (their facts' places mapped to
+ * it): the mirror of regionEventsAt, for a place looked for before its region (spec 020 K7.1a). Not taken back.
+ */
+export function placeEventsIn(tree, shared, region, e) {
+    if (!shared)
+        return [];
+    const maps = readPlaces(tree);
+    const folded = new Map(Object.entries(maps).map(([k, v]) => [foldText(k), v]));
+    const out = [];
+    for (const [id, at] of factsByRecord(tree)) {
+        const inIt = at.keys.some((key) => ((maps[key] ?? folded.get(foldText(key)))?.regions ?? []).some((g) => g.id === region && inRegion(e, g)));
+        const p = inIt ? placeRecord(tree, id) : undefined;
+        if (!p)
+            continue;
+        for (const x of readPlaceCatalog(shared, placeKeyOf(tree, p))?.events ?? [])
+            if (!x.retracted)
+                out.push({ event: x, place: p });
+    }
+    return out.sort((a, b) => a.event.from - b.event.from || a.event.id.localeCompare(b.event.id));
+}
+/** An event of one of the region's places of the same kind and years: the region's history never writes it again. */
+export function refusePlaceSame(tree, shared, region, e) {
+    const same = placeEventsIn(tree, shared, region, e).filter((x) => x.event.kind === e.kind && x.event.from <= e.to && e.from <= x.event.to);
+    if (!same.length)
+        return;
+    const ids = same.map((x) => `${x.event.id} (${x.place.id})`);
+    throw new UsageError(`an event of a place of ${region} of the same kind and years is there already: ${ids.join(", ")} — nothing written`, {
+        code: "history.same.place",
+        params: { ids: same.map((x) => x.event.id).join(", ") },
+        hint: `the place's event shows there already — leave it out; an event of the whole region (it touched its other places too): --distinct "<why it is another>"`,
+    });
+}
 // ── the person's asks ──────────────────────────────────────────────────────
 export function readPlaceAsks(tree) {
     try {

package/dist/core/retractions.js

@@ -5,7 +5,7 @@
 import { UsageError } from "./errors.js";
 import { findEventOwner, makeNote } from "./actions.js";
 import { EMBEDDED_PREFIXES } from "./model.js";
-import { gedcomName, parseName, primaryName, sameName } from "./people.js";
+import { currentName, gedcomName, parseName, primaryName, sameName, withoutMark } from "./people.js";
 import { now, typeOfId } from "./tree.js";
 function needsReason(reason, what) {
     const why = reason?.trim();
@@ -48,8 +48,8 @@ export function retractName(tree, id, text, reason) {
             });
         const gone = { ...name, retracted: retraction(tree, why) };
         const updated = { ...p, names: p.names.filter((n) => n !== name), retractedNames: [...(p.retractedNames ?? []), gone], updated: now() };
-        const shown = primaryName(updated);
-        const moved = name === primaryName(p);
+        const shown = currentName(updated);
+        const moved = name === currentName(p);
         tree.put(updated, {
             op: "name.retract",
             targets: [id],
@@ -69,7 +69,9 @@ export function restoreName(tree, id, text, reason) {
             throw new UsageError(`${id} has no retracted name ${gedcomName(wanted)}`, { hint: `its retracted names: ${nameList(p.retractedNames ?? [])}`, code: "name.none" });
         if (p.names.some((n) => sameName(n, gone)))
             throw new UsageError(`${id} has the name ${gedcomName(gone)} again`, { hint: `nothing to restore: strom person show ${id}` });
-        const { retracted: _was, ...name } = gone;
+        // the name they were shown by, back as that one unless another is marked since
+        const { retracted: _was, ...back } = gone;
+        const name = back.primary && p.names.some((n) => n.primary) ? withoutMark(back) : back;
         const rest = (p.retractedNames ?? []).filter((n) => n !== gone);
         const { retractedNames: _all, ...base } = p;
         const updated = { ...base, names: [...p.names, name], ...(rest.length ? { retractedNames: rest } : {}), updated: now() };

package/dist/core/stromapp.js

@@ -537,6 +537,27 @@ export function appReadsSurnameGroups(settings, version, gate = APP_READS_SURNAM
         return compareVersions(v, APP_READS_SURNAME_MARKERS) >= 0;
     return !!gate && compareVersions(v, gate) >= 0;
 }
+/**
+ * The first Strom app that knows which name a person is shown by (spec 024, the app's ZADANI_VYZKUM_soucasne-prijmeni.md):
+ * it writes 2 _STROM_PRIMARY Y under the NAME the user chose (its Person.primaryName birth | married, the JSON's field
+ * of that name) and none where the user chose none. The research writes the mark to every app (an older one skips it in
+ * silence and loses nothing); a mark an app sends is the user's choice whatever its version — but a mark missing is
+ * the user's "none" only from an app of this version on: from an older one, or one that says no version, nothing
+ * changed. Not released yet (undefined): set to the version the app's "je venku" names; another copy of the app (its
+ * beta, its development) gets it at once from APP_PRIMARY_NAME_BETA once that is known too.
+ */
+export const APP_KNOWS_PRIMARY_NAME = undefined;
+/** The first beta of the app that writes the mark (another copy of the app gets it from it); undefined: none yet. */
+export const APP_PRIMARY_NAME_BETA = undefined;
+/** Does a file of the Strom app of this version say every choice of the name a person is shown by — a mark missing the user's "none"? */
+export function appKnowsPrimaryName(settings, version) {
+    const v = version?.trim();
+    if (!v || !isAppVersion(v))
+        return false;
+    if (anotherCopy(settings) && APP_PRIMARY_NAME_BETA)
+        return compareVersions(v, APP_PRIMARY_NAME_BETA) >= 0;
+    return !!APP_KNOWS_PRIMARY_NAME && compareVersions(v, APP_KNOWS_PRIMARY_NAME) >= 0;
+}
 /** The address that opens the Strom app to send the user's edited tree to the bridge. */
 export function sendAppUrl(bridge, settings) {
     return `${stromAppUrl(settings)}?send=${encodeURIComponent(bridge)}`;

package/dist/core/sync.js

@@ -24,7 +24,7 @@ import path from "node:path";
 import { CHILD_RELATIONS, UNIONS, eventKind } from "./model.js";
 import { isWeak } from "./evidence.js";
 import { phrase } from "./phrases.js";
-import { addChild, addEvent, addFamily, addName, addNote, editEvent, editPerson, retractEvent, retractPerson } from "./actions.js";
+import { addChild, addEvent, addFamily, addName, addNote, editEvent, editPerson, markPrimaryName, retractEvent, retractPerson } from "./actions.js";
 import { exportGedcom, REFN_TYPE } from "../gedcom/export.js";
 import { children, parseGedcomText, val } from "../gedcom/parse.js";
 import { fromFlexDate, houseOf, importDate, marnmNames, readGedName, readGedSex, stromAppFile } from "./import.js";
@@ -42,14 +42,14 @@ import * as git from "./git.js";
 import { now, Tree, typeOfId } from "./tree.js";
 import { actsAsArchive } from "./state.js";
 import { appSides } from "./conflicts.js";
-import { APP_DATA_SEX_UNKNOWN, appKeepsPeriods, appReadsSurnameGroups, isAppVersion } from "./stromapp.js";
+import { APP_DATA_SEX_UNKNOWN, appKeepsPeriods, appKnowsPrimaryName, appReadsSurnameGroups, isAppVersion } from "./stromapp.js";
 import { Settings } from "./config.js";
 import { applySurnameChange, formsSaid, planSurnames, readMarkLines, readSurnames, surnamesAt, undoSurnameChange } from "./surnames.js";
 import { SURNAME_GROUPS_MARK, SURNAME_REJECTIONS_MARK } from "../gedcom/export.js";
 import { bestGrade, checkReading, readingGrade, readingResult, readingSource, surer, takeReadingImages } from "./readsync.js";
 import { earlierNoteTexts } from "./retractions.js";
 import { mendAll } from "./damaged.js";
-import { cleanTitle, familiesAsPartner, formatName, foundTitles, gedcomTitledName, parseName, primaryName, sameName as sameWords, titledName } from "./people.js";
+import { cleanTitle, currentName, familiesAsPartner, formatName, foundTitles, gedcomTitledName, parseName, primaryName, sameName as sameWords, titledName } from "./people.js";
 /** The words of a _STAT (the Strom app's own, also Legacy's and FTM's) as a union, or nothing it names. */
 function unionOfStat(value) {
     const v = (value ?? "").trim().toLowerCase();
@@ -480,6 +480,8 @@ export function readGedcom(text) {
     const head = records.find((r) => r.tag === "HEAD");
     /** A file of the Strom app (its HEAD: 1 SOUR STROM): its own ways of writing are read as it means them. */
     const fromApp = stromAppFile(head);
+    // the research's own file (what it gave the app, the research now): it says every choice of a name shown by
+    const research = val(head, "SOUR")?.trim() === "STROM_RESEARCH";
     const notes = new Map(records.filter((r) => r.tag === "NOTE" && r.xref).map((r) => [r.xref, r.value]));
     const noteText = (n) => (/^@[^@]+@$/.test(n.value.trim()) ? (notes.get(n.value.trim()) ?? "") : n.value);
     // the sources: ours by their REFN, the file's own by their xref
@@ -567,6 +569,12 @@ export function readGedcom(text) {
         // a placeholder of the Strom app (an unknown parent drawn in the tree): nobody
         if (!ours && !names.length)
             continue;
+        // the name they are shown by (spec 024) as the app sees it: its birth name (the first), its one name after a marriage
+        // (the last TYPE married, else the last _MARNM), else none — a mark missing says it only in the research's own file
+        const mi = kept.findIndex(({ n }) => /^y(es)?$/i.test(val(n, "_STROM_PRIMARY")?.trim() ?? ""));
+        const typed = names.filter((_, i) => i > 0 && i < kept.length && kept[i].name.kind === "married");
+        const appMarried = typed.at(-1) ?? married.at(-1);
+        const primary = mi === 0 ? "birth" : mi > 0 && names[mi] === appMarried ? `married|${nameKey(names[mi])}` : mi > 0 || research ? "none" : undefined;
         const facts = gedFacts(r, undefined, read);
         // a godparent other programs give the person (1 ASSO): theirs at the baptism, else the birth
         const host = facts.find((f) => kindOf(f.kind) === "BAPM") ?? facts.find((f) => f.kind === "BIRT");
@@ -587,6 +595,7 @@ export function readGedcom(text) {
             ...(cites.length ? { cites } : {}),
             ...(titles ? { titles } : {}),
             ...(married.length ? { married } : {}),
+            ...(primary ? { primary } : {}),
         });
     }
     // how a child belongs to a family (the child's FAMC + PEDI: adopted, foster, step): none said is birth
@@ -826,8 +835,11 @@ export function readStromJson(data) {
         const marriedSurname = typeof p.marriedSurname === "string" ? p.marriedSurname.replace(/[/\s]+/g, " ").trim() : "";
         const married = marriedSurname ? `${p.firstName ?? ""} /${marriedSurname}/`.trim() : undefined;
         const names = [name, ...(married ? [married] : []), ...(p.nameVariants ?? [])].filter((n) => n.replace(/[/?\s]/g, ""));
+        // the name the user chose to show them by (spec 024): the birth one, the one after the marriage; none said: nothing
+        const primary = p.primaryName === "birth" ? "birth" : p.primaryName === "married" && married ? `married|${nameKey(married)}` : undefined;
         persons.set(key, {
             key,
+            ...(primary ? { primary } : {}),
             ...(titles ? { titles } : {}),
             names: names.filter((n, i) => n !== married || names.findIndex((m) => nameKey(m) === nameKey(n)) === i),
             ...(married && names.findIndex((n) => nameKey(n) === nameKey(married)) > 0 ? { married: [married] } : {}),
@@ -1917,6 +1929,8 @@ export function planSync(tree, incoming, edits, opts = {}) {
             });
     }
     const partial = !!base && incoming.persons.size < base.persons.size / 2;
+    // a file that says every choice of the name a person is shown by: its mark missing is the user's "none" (spec 024)
+    const knowsPrimary = appKnowsPrimaryName(new Settings(tree.env, {}), incoming.appVersion);
     const changes = [];
     const push = (c) => changes.push({ ...c, n: changes.length + 1 });
     /** What the file no longer has: an archive takes it away — unless the window that sends never had it (kept, said). */
@@ -2220,6 +2234,34 @@ export function planSync(tree, incoming, edits, opts = {}) {
             push({ kind: "name.gone", action: nameBacked(tree, mine) ? "report" : "remove", person: id, name, text: gedcomName(mine) });
         }
     };
+    /**
+     * The name the person is shown by (spec 024): the user's choice, never a record's — compared as the app sees it
+     * (SPerson.primary). Changed in the app only: taken; in the research only: the research's, given the app again; both,
+     * apart: the user's to decide (or their word: sync.edits user, an archive). A mark missing from an app before
+     * APP_KNOWS_PRIMARY_NAME (or one that says no version) changes nothing; without the state it was given only a choice
+     * where the research has none is taken.
+     */
+    const primaryDiff = (id, name, p, o, b) => {
+        const theirs = p.primary ?? (knowsPrimary ? "none" : undefined);
+        const mine = o.primary ?? "none";
+        if (theirs === undefined || theirs === mine)
+            return;
+        let action;
+        if (b) {
+            const given = b.primary ?? "none";
+            if (theirs === given)
+                return;
+            action = mine !== given ? (edits === "user" ? "user" : "conflict") : "correct";
+        }
+        else {
+            if (mine !== "none" || theirs === "none")
+                return;
+            action = "add";
+        }
+        // as the line says it: the name each side shows them by ("" none chosen)
+        const line = (x, view) => (view === "birth" ? (x.names[0] ?? "") : (x.names.find((n) => `married|${nameKey(n)}` === view) ?? ""));
+        push({ kind: "name.shown", action, person: id, name, shown: { theirs, mine }, text: line(p, theirs), wasName: line(o, mine) });
+    };
     /** The user's edits of a person: the file's (`p`) against the research's (`o`) and what the app was given (`b`). */
     const personDiff = (id, name, p, o, b) => {
         factsDiff({ person: id, name }, p.facts, o.facts, b?.facts, true);
@@ -2247,6 +2289,7 @@ export function planSync(tree, incoming, edits, opts = {}) {
             if (!theirMarried.has(n) && !((renamed || both) && n === now) && !ourNames.has(nameKey(n)) && !baseNames.has(nameKey(n)) && !goneNames.has(nameKey(n)))
                 push({ kind: "name.new", action: "add", person: id, name, text: n });
         marriedDiff(id, name, p, o, b);
+        primaryDiff(id, name, p, o, b);
         // the titles of the name they are shown by (T07), each apart and never as a change of the name itself: the user's
         // edit where the file's differs from what the app was given — one the name lacks added, a lead's corrected, a
         // record's name the user's to decide (or their word: sync.edits user, an archive); the research's changed since
@@ -3927,7 +3970,7 @@ export function applySync(tree, plan, incoming, source, only) {
                     }
                     else if (c.action === "user") {
                         // the user's word wins: shown by the new name, the record's kept beside it
-                        const { name } = addName(tree, owner, { name: c.text, citation: cite("name"), primary: true });
+                        const { name } = addName(tree, owner, { name: c.text, citation: cite("name"), first: true });
                         applied.push({ do: "name.primary", id: owner, before: JSON.stringify({ added: exact(`${name.given}|${name.surname}`), shown: exact(`${shown.given}|${shown.surname}`) }) });
                     }
                     else {
@@ -3946,6 +3989,28 @@ export function applySync(tree, plan, incoming, source, only) {
                     }
                     break;
                 }
+                case "name.shown": {
+                    // the name the user chose to show the person by (spec 024): marked, or the mark taken off
+                    if (!owner || !c.shown)
+                        break;
+                    const p = tree.get(owner);
+                    const target = nameOfView(p, c.shown.theirs);
+                    const was = p.names.find((n) => n.primary);
+                    if (target === undefined || (target === null ? !was : target.primary))
+                        break;
+                    if (c.action === "conflict") {
+                        const who = gedcomName(primaryName(p)).replace(/\//g, "").replace(/\s+/g, " ").trim();
+                        const said = (n) => (n ? formatName(n) : ui(tree.lang, "ui.conflict.primary.none"));
+                        conflictOfEdit(tree, applied, owner, "NAME", editTitle(who, ui(tree.lang, "ui.conflict.primary"), said(was), said(target)), [
+                            { value: was ? gedcomName(was) : "", note: "the research: the name it shows the person by", text: said(was) },
+                            { source: source.id, value: target ? gedcomName(target) : "", note: "the user's edit", text: said(target) },
+                        ], undefined, undefined, true);
+                        break;
+                    }
+                    markPrimaryName(tree, owner, target ? gedcomName(target) : undefined, `the user's edit: ${reason}`);
+                    applied.push({ do: "name.mark", id: owner, before: was ? gedcomName(was) : "" });
+                    break;
+                }
                 case "name.title": {
                     if (!owner || !c.title)
                         break;
@@ -4274,6 +4339,20 @@ function claimValue(f) {
  * The title of a conflict of the user's edit, in the research's language — the Strom app shows it in what the research
  * knows (found on Mac: "Petr Svoboda: SEX — U × F" in a Czech research): "Petr Svoboda: Pohlaví — neznámé × žena".
  */
+/**
+ * The research's name of a person the app's view of the name they are shown by names (SPerson.primary): "birth" the
+ * name of their identity, "married|<key>" their name of that key (not the identity's), "none" null; undefined where the
+ * research has no such name.
+ */
+function nameOfView(p, view) {
+    if (view === "none")
+        return null;
+    const first = primaryName(p);
+    if (view === "birth")
+        return first;
+    const key = view.startsWith("married|") ? view.slice("married|".length) : undefined;
+    return key === undefined ? undefined : p.names.find((n) => n !== first && nameKey(gedcomName(n)) === key);
+}
 function editTitle(who, what, ours, theirs) {
     return `${who.replace(/\//g, "").replace(/\s+/g, " ").trim()}: ${what.charAt(0).toUpperCase()}${what.slice(1)} — ${ours} × ${theirs}`;
 }
@@ -4363,6 +4442,19 @@ export function takeSide(tree, x, side, reason) {
         setTitle(tree, p.id, part, user.value, from, `the user's edit (${x.id}): ${reason}`);
         return `${p.id}: ${titledName(primaryName(tree.get(p.id)))}`;
     }
+    // the name the user chose in the Strom app to show the person by (spec 024): marked, or none marked
+    if (x.primary) {
+        const user = x.claims.find((c) => c.note === "the user's edit");
+        const p = x.subject[0] ? tree.get(x.subject[0]) : undefined;
+        if (!p || p.retracted || !user)
+            throw new UsageError(`the person of ${x.id} is no longer in the research`, { hint: `strom conflict show ${x.id}` });
+        const target = user.value ? p.names.find((n) => sameWords(n, parseName(user.value))) : null;
+        if (target === undefined)
+            throw new UsageError(`${p.id} has no name ${user.value} any more`, { hint: `strom person show ${p.id}` });
+        if (target ? !target.primary : p.names.some((n) => n.primary))
+            markPrimaryName(tree, p.id, target ? gedcomName(target) : undefined, `the user's edit (${x.id}): ${reason}`);
+        return `${p.id} shown as ${gedcomName(currentName(tree.get(p.id)))}`;
+    }
     // a name or a sex the user gave in the Strom app (found on Mac: --take refused for them, only for facts and parents)
     if (!x.edit && (x.fact === "NAME" || x.fact === "SEX")) {
         const owner = x.subject[0];
@@ -4378,7 +4470,7 @@ export function takeSide(tree, x, side, reason) {
         const words = (v) => foldText(v.replace(/\//g, " ")).replace(/\s+/g, " ").trim();
         const kept = p.names.find((n) => words(`${n.given} ${n.surname}`) === words(user.value));
         const from = user.source && tree.get(user.source)?.type === "source" && !kept?.citations?.some((c) => c.source === user.source) ? { source: user.source, locator: "name" } : undefined;
-        const { name } = addName(tree, p.id, { name: user.value, primary: true, ...(from ? { citation: from } : {}) });
+        const { name } = addName(tree, p.id, { name: user.value, first: true, ...(from ? { citation: from } : {}) });
         return `${p.id} shown as ${gedcomName(name)}`;
     }
     if (!x.edit)
@@ -4415,11 +4507,11 @@ function parentsText(tree, incoming, keys) {
     };
     return keys.map(shown).join(" & ") || "?";
 }
-function conflictOfEdit(tree, applied, owner, fact, title, claims, edit, parents) {
+function conflictOfEdit(tree, applied, owner, fact, title, claims, edit, parents, primary) {
     const [ours, theirs] = claims;
     const open = tree
         .list("conflict")
-        .find((x) => x.state === "open" && x.fact === fact && x.subject[0] === owner && x.claims.length === 2 && x.claims[0].note === ours.note && x.claims[0].value === ours.value && x.claims[1].note === theirs.note);
+        .find((x) => x.state === "open" && x.fact === fact && !!x.primary === !!primary && x.subject[0] === owner && x.claims.length === 2 && x.claims[0].note === ours.note && x.claims[0].value === ours.value && x.claims[1].note === theirs.note);
     if (open) {
         if (open.claims[1].value === theirs.value)
             return { open: open.id };
@@ -4430,7 +4522,7 @@ function conflictOfEdit(tree, applied, owner, fact, title, claims, edit, parents
         applied.push({ do: "conflict.edit", id: open.id, before: JSON.stringify({ title: open.title, claims: open.claims }) });
         return { was: open.claims[1].value };
     }
-    const x = create(tree, "conflict", { title: title.slice(0, 200), fact, subject: [owner], claims, ...(edit ? { edit } : {}), ...(parents ? { parents } : {}), state: "open" }, (id) => `+${id} conflict "${title.slice(0, 60)}"`, [owner]);
+    const x = create(tree, "conflict", { title: title.slice(0, 200), fact, subject: [owner], claims, ...(edit ? { edit } : {}), ...(parents ? { parents } : {}), ...(primary ? { primary } : {}), state: "open" }, (id) => `+${id} conflict "${title.slice(0, 60)}"`, [owner]);
     applied.push({ do: "conflict.add", id: x.id });
     return {};
 }
@@ -4643,6 +4735,16 @@ export function undoSync(tree, input) {
                     });
                 break;
             }
+            case "name.mark": {
+                // the name the person was shown by before the user's choice (none: no mark)
+                const p = tree.get(a.id);
+                const was = String(a.before ?? "");
+                const back = was ? p?.names.find((n) => sameWords(n, parseName(was))) : null;
+                if (!p || back === undefined || (back === null ? !p.names.some((n) => n.primary) : back.primary))
+                    break;
+                markPrimaryName(tree, a.id, back ? gedcomName(back) : undefined, reason);
+                break;
+            }
             case "name.title": {
                 // the title as it was, and the citation of the sync it added taken off
                 const b = JSON.parse(String(a.before ?? "{}"));

package/dist/core/tree.js

@@ -29,7 +29,7 @@ export const TREE_FILE = "strom.json";
 export const SEAL_FOREIGN = "seal.foreign";
 // between releases the candidate being made (a bridge run from the sources says what it is: the Strom app goes by it);
 // at a release the release's own (package.json)
-export const VERSION = "1.22.0";
+export const VERSION = "1.23.0-beta.1";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/validate.js

@@ -200,8 +200,12 @@ function checkPerson(p, out) {
                     out.push({ path: `names[${i}].${t}`, message: "must be a title (a string, not empty)" });
             if (n.kind !== undefined && !NAME_KINDS.includes(n.kind))
                 out.push({ path: `names[${i}].kind`, message: `must be one of ${NAME_KINDS.join(", ")}` });
+            if (n.primary !== undefined && n.primary !== true)
+                out.push({ path: `names[${i}].primary`, message: "must be true, or left out" });
             checkCitations(n.citations, `names[${i}].citations`, out);
         });
+    if (Array.isArray(p.names) && p.names.filter((n) => isObj(n) && n.primary).length > 1)
+        out.push({ path: "names", message: "at most one name is the one the person is shown by (primary)" });
     if (p.retractedNames !== undefined) {
         if (!Array.isArray(p.retractedNames))
             out.push({ path: "retractedNames", message: "must be an array" });

package/dist/gedcom/export.js

@@ -27,7 +27,7 @@
 import { GedWriter, clipChars, lineValue } from "./lines.js";
 import { labels, RELA } from "./labels.js";
 import { linkInTree, recordedLinks } from "../core/hypolinks.js";
-import { birthEvent, claimText, conflictTitle, coupleSides, displayName, familySides, formatName, gedcomTitledName, noName, preferredOrder, primaryName, relationTo } from "../core/people.js";
+import { birthEvent, claimText, conflictTitle, coupleSides, currentName, displayName, familySides, formatName, gedcomTitledName, noName, preferredOrder, primaryName, relationTo } from "../core/people.js";
 import { foldText } from "../core/text.js";
 import { dateYears } from "../core/gdate.js";
 import { humanAge, isGedcomAge, normalizeAge } from "../core/age.js";
@@ -258,7 +258,17 @@ export function exportGedcom(tree, opts = {}) {
         w.record(x(p.id), "INDI");
         const primary = primaryName(p);
         const nameQuotes = [];
-        for (const n of [primary, ...p.names.filter((n) => n !== primary)]) {
+        // the name the person is shown by now (Name.primary): first for any program (GEDCOM 7: the preferred name first);
+        // the Strom file keeps the name of their identity first (the app's birth surname) and says the mark — a married
+        // name marked last of them (the app keeps one name after a marriage: the last), so even an app that reads no mark
+        // shows it
+        const current = currentName(p);
+        const rest = p.names.filter((n) => n !== primary && n !== current);
+        const order = current === primary ? [primary, ...rest]
+            : strict ? [current, primary, ...rest]
+                : current.kind === "married" ? [primary, ...rest, current]
+                    : [primary, ...p.names.filter((n) => n !== primary)];
+        for (const n of order) {
             // a name with a title says it in the line (any program shows it) and spells its parts out below: NPFX, GIVN, SURN,
             // NSFX — for any program (GEDCOM 5.5.1's own tags), for the Strom app from its 3.10 (titles; an older one reads
             // the line). A part holding a comma gets no GIVN / SURN (GEDCOM reads commas there as a list); the line has it.
@@ -280,6 +290,8 @@ export function exportGedcom(tree, opts = {}) {
             // "birth" says something only next to another name
             if (n.kind && (n.kind !== "birth" || p.names.length > 1))
                 w.line(2, "TYPE", NAME_TYPE[n.kind]);
+            if (!strict && n.primary)
+                w.line(2, "_STROM_PRIMARY", "Y");
             for (const c of n.citations ?? []) {
                 const q = citation(2, c);
                 if (q)

package/dist/gedcom/validate.js

@@ -5,7 +5,7 @@ import { normalizeDate } from "../core/gdate.js";
 import { isGedcomAge } from "../core/age.js";
 import { MAX_LINE_BYTES } from "./lines.js";
 const LINE = /^(\d{1,2}) (?:(@[^@ ]+@) )?([A-Za-z0-9_]+)(?: (.*))?$/;
-const EVENT_DETAIL = ["TYPE", "DATE", "PLAC", "AGE", "SOUR", "NOTE", "ASSO", "_WITN", "CAUS", "ADDR", "AGNC", "RELI", "OBJE", "HUSB", "WIFE"];
+const EVENT_DETAIL = ["TYPE", "DATE", "PLAC", "AGE", "SOUR", "NOTE", "ASSO", "_WITN", "CAUS", "ADDR", "AGNC", "RELI", "OBJE", "HUSB", "WIFE", "_STROM_STATUS"];
 const INDI_EVENTS = [
     "BIRT", "DEAT", "BAPM", "CHR", "CHRA", "CONF", "FCOM", "BARM", "BASM", "ORDN", "EDUC", "GRAD", "OCCU", "RESI", "EMIG", "IMMI",
     "NATU", "RELI", "TITL", "NATI", "ADOP", "WILL", "PROB", "BURI", "CREM", "CENS", "EVEN", "RETI", "BLES", "CAST", "DSCR", "IDNO",
@@ -14,7 +14,7 @@ const INDI_EVENTS = [
 const FAM_EVENTS = ["MARR", "DIV", "MARB", "MARC", "MARL", "MARS", "ANUL", "DIVF", "ENGA", "CENS", "RESI", "EVEN", "NCHI"];
 /** Allowed child tags by parent context ("INDI", "INDI.BIRT", …). CONC/CONT are allowed under anything with text. */
 const CHILDREN = {
-    HEAD: ["SOUR", "DEST", "DATE", "SUBM", "SUBN", "FILE", "COPR", "GEDC", "CHAR", "LANG", "PLAC", "NOTE", "_STROM_TREE", "_STROM_HEAD", "_STROM_LINKS", "_STROM_ASOF"],
+    HEAD: ["SOUR", "DEST", "DATE", "SUBM", "SUBN", "FILE", "COPR", "GEDC", "CHAR", "LANG", "PLAC", "NOTE", "_STROM_TREE", "_STROM_HEAD", "_STROM_LINKS", "_STROM_ASOF", "_STROM_MODE"],
     "HEAD.SOUR": ["VERS", "NAME", "CORP", "DATA"],
     "HEAD._STROM_LINKS": ["_SCHEME"],
     "HEAD.GEDC": ["VERS", "FORM"],
@@ -33,14 +33,16 @@ const CHILDREN = {
     "_STROM_EDGE._JOIN": ["_VAR", "_ISLAND", "_HELD"],
     // a value of a conflict the app decides by side: its side, a sex as M, F or U
     _STROM_VALUE: ["SOUR", "_STROM_SIDE", "_STROM_RAW"],
-    "INDI.NAME": ["TYPE", "GIVN", "SURN", "NPFX", "NSFX", "NICK", "SPFX", "SOUR", "NOTE"],
+    "INDI.NAME": ["TYPE", "GIVN", "SURN", "NPFX", "NSFX", "NICK", "SPFX", "SOUR", "NOTE", "_STROM_PRIMARY"],
     "INDI.FAMC": ["PEDI", "NOTE"],
     "INDI.FAMS": ["NOTE"],
     "FAM.CHIL": ["_FREL", "_MREL"],
     "INDI.ASSO": ["RELA", "SOUR", "NOTE"],
-    FAM: ["HUSB", "WIFE", "CHIL", "NOTE", "SOUR", "REFN", "OBJE", "RIN", "CHAN", "_STORY", ...FAM_EVENTS],
+    FAM: ["HUSB", "WIFE", "CHIL", "NOTE", "SOUR", "REFN", "OBJE", "RIN", "CHAN", "_STORY", "_STAT", "_STROM_NO_COUPLE", ...FAM_EVENTS],
     // the Strom profile also writes PAGE on the record: where in the book the source is (the Strom app's reference)
-    SOUR: ["TITL", "AUTH", "ABBR", "PUBL", "TEXT", "REPO", "NOTE", "REFN", "DATA", "OBJE", "RIN", "CHAN"],
+    SOUR: ["TITL", "AUTH", "ABBR", "PUBL", "TEXT", "REPO", "NOTE", "REFN", "DATA", "OBJE", "RIN", "CHAN", "_STROM_READ", "_STROM_VERIFIED", "_STROM_READING", "_STROM_IMG_OMITTED"],
+    "SOUR._STROM_READING": ["_STROM_ENTRY"],
+    "SOUR._STROM_IMG_OMITTED": ["_STROM_CLIP"],
     "SOUR.REPO": ["CALN", "NOTE"],
     REPO: ["NAME", "ADDR", "NOTE", "REFN", "RIN", "CHAN"],
     SUBM: ["NAME", "ADDR", "LANG", "NOTE", "RIN", "CHAN"],
@@ -73,6 +75,12 @@ const EXTENSIONS = new Set([
     "_VAR", "_LINK", "_PERS", "_FAM", "_PAR", "_CHOSEN", "_INTREE",
     // a source's excerpts the file leaves out, and why
     "_STROM_IMG_OMITTED",
+    // the name a person is shown by; a couple's state; parents who are no couple; an archive
+    "_STROM_PRIMARY", "_STAT", "_STROM_NO_COUPLE", "_STROM_MODE",
+    // who read a source, the user's verification, the reading it is an entry of; how sure a fact is
+    "_STROM_READ", "_STROM_VERIFIED", "_STROM_READING", "_STROM_ENTRY", "_STROM_STATUS",
+    // an excerpt's original by its content, and how its picture lies
+    "_STROM_SHA", "_STROM_ORIENT",
 ]);
 /** Context of the children of the last tag in `anc` (the ancestors of a line). */
 function contextOf(anc) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.22.0",
+  "version": "1.23.0-beta.1",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {
@@ -57,5 +57,8 @@
   "devDependencies": {
     "@types/node": "^22.20.4",
     "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "tag": "beta"
   }
 }