strom-research 1.22.2 → 1.23.0-beta.2

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/integrity.js

@@ -64,6 +64,26 @@ function parseOps(text, file, findings, startLine = 0) {
  */
 export const OTHER_KEY = "other-key";
 const OTHER_KEY_HINT = "the user runs in their terminal: strom seal adopt   (unites the keys — never strom repair, which would undo that work)";
+/**
+ * Two keys of this computer and changes outside strom at once (a commit made with git on top of the other key's work):
+ * one way, never two that contradict each other — strom repair first (it undoes only what was done outside strom, the
+ * work of both keys stays: it restores to the newest commit any key of this computer sealed), then strom seal adopt.
+ * Never the other way round: uniting commits what is there, a record changed outside strom with it. `hidden`: started
+ * by an app packaged for Windows, the terminal's key out of its sight — strom repair there too, in the terminal.
+ */
+export function oneWay(findings, hidden) {
+    const repairs = findings.filter((f) => f.level === "error" && f.code !== OTHER_KEY && f.hint?.startsWith("strom repair"));
+    if (!repairs.length)
+        return findings;
+    const where = hidden() ? "the user runs in their terminal: " : "";
+    for (const f of repairs)
+        f.hint = `${where}strom repair   (undoes only what was done outside strom — the work of both keys of this computer stays), then strom seal adopt`;
+    for (const f of findings)
+        if (f.code === OTHER_KEY)
+            f.hint = AFTER_REPAIR_HINT;
+    return findings;
+}
+export const AFTER_REPAIR_HINT = "after strom repair, the user runs in their terminal: strom seal adopt   (unites the keys)";
 function keysOf(tree, trust = [], united = new Map()) {
     let others;
     let hidden;
@@ -279,10 +299,11 @@ export function verifyFast(tree, snap = snapshot(tree)) {
     const tampered = new Set();
     if (!git.hasHead(tree.root))
         return { findings, tampered: [] };
-    headSeal(tree, findings);
+    const keys = keysOf(tree);
+    headSeal(tree, findings, keys);
     const { changes, head: committed } = snap;
     if (changes.length === 0)
-        return { findings, tampered: [] };
+        return { findings: united(findings, keys), tampered: [] };
     const opsChanged = changes.filter((c) => c.path.startsWith("data/ops/") && c.path.endsWith(".jsonl"));
     const latest = new Map();
     const cloud = new Set();
@@ -304,7 +325,7 @@ export function verifyFast(tree, snap = snapshot(tree)) {
         }
         const prior = parseOps(before, c.path, findings);
         const added = parseOps(now.slice(before.length), c.path, findings, prior.length);
-        checkOps(tree, added, prior.at(-1)?.sig ?? "", c.path, findings);
+        checkOps(tree, added, prior.at(-1)?.sig ?? "", c.path, findings, keys);
         for (const op of added)
             for (const f of op.files ?? [])
                 latest.set(f.path, f.sha);
@@ -346,7 +367,11 @@ export function verifyFast(tree, snap = snapshot(tree)) {
     }
     if (cloud.size)
         findings.unshift(notDownloadedFinding([...cloud].sort()));
-    return { findings, tampered: [...tampered] };
+    return { findings: united(findings, keys), tampered: [...tampered] };
+}
+/** Another key of this computer among the findings: one way with what strom repair undoes (oneWay). */
+function united(findings, keys) {
+    return findings.some((f) => f.code === OTHER_KEY) ? oneWay(findings, keys.hidden) : findings;
 }
 /**
  * The other keys of this computer a seal.unite of the tree's own key took, each with when (its operations until then
@@ -442,7 +467,7 @@ export function verifyFull(tree, o = {}) {
         tampered.add("strom.json");
         findings.push({ level: "error", code: "config-edited", file: "strom.json", message: "strom.json was changed outside strom", hint: "strom repair" });
     }
-    return { findings, tampered: [...tampered] };
+    return { findings: united(findings, keys), tampered: [...tampered] };
 }
 /**
  * Whether strom may write here unasked (a settle: nobody asked, nobody to ask): the tree sealed on this computer (not

package/dist/core/live.js

@@ -918,7 +918,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/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 ?? "{}"));