strom-research 1.10.0 → 1.11.0

package/dist/commands/output.js

@@ -13,7 +13,7 @@ import { UsageError } from "../core/errors.js";
 import { excerptSettings, planExcerpts } from "../core/excerpt.js";
 import { runGit, tracked } from "../core/git.js";
 import { Settings } from "../core/config.js";
-import { appOpensLinks, appShowsEdges, appShowsStoryDrafts } from "../core/stromapp.js";
+import { appOpensLinks, appShowsCoupleEvents, appShowsEdges, appShowsStoryDrafts } from "../core/stromapp.js";
 import { EXCERPT_QUALITIES, EXCERPT_SCOPES } from "../core/model.js";
 function findingRows(f) {
     return table(f.slice(0, 30).map((x) => [x.level === "error" ? "ERROR" : "warn", `line ${x.line}`, x.message]));
@@ -77,7 +77,8 @@ export function writeTreeGed(tree, opts) {
     const edges = opts.for === "strom" && appShowsEdges(new Settings(tree.env, {}), opts.stromVersion);
     // …and the new versions of stories the user approved, for an app that shows them
     const storyDrafts = opts.for === "strom" && appShowsStoryDrafts(new Settings(tree.env, {}), opts.stromVersion);
-    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}) });
+    const coupleResi = opts.for === "strom" && appShowsCoupleEvents(new Settings(tree.env, {}), opts.stromVersion);
+    const result = exportGedcom(tree, { for: opts.for, stromVersion: opts.stromVersion, ...(persons ? { persons } : {}), ...(images ? { excerpts: images.of } : {}), ...(clips ? { clips } : {}), ...(research ? { research } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}) });
     const findings = validateGedcom(result.text, opts.for === "standard" ? { strict: true } : {});
     const file = opts.out ?? gedFile(tree, opts.for, opts.research);
     if (!hasGedErrors(findings) && !tree.dryRun) {

package/dist/commands/sync.js

@@ -17,16 +17,17 @@ import { applySync, nothingSince, planSync, readTreeFile, receivedSince, undoSyn
 import { startLive } from "../core/live.js";
 import { appSendsChanges, installedStromApp, sendAppUrl, stromAppUrl } from "../core/stromapp.js";
 import { chromiumBrowser, openInBrowser, openWebApp } from "../core/chromium.js";
-function factText(f, lang) {
+function factText(f, lang, name = (k) => k) {
     if (!f)
         return "—";
-    return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang), detailText(f, lang)].filter(Boolean).join(", ") || "—";
+    return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang), detailText(f, lang, name)].filter(Boolean).join(", ") || "—";
 }
-/** What a fact says besides: its house, age and cause. */
-function detailText(f, lang) {
+/** What a fact says besides: its house, age (a couple's: each partner's) and cause. */
+function detailText(f, lang, name = (k) => k) {
     if (!f)
         return "";
-    return [f.house && ui(lang, "ui.sync.house", { x: f.house }), f.age && humanAge(f.age, lang), f.cause && ui(lang, "ui.sync.cause", { x: f.cause })].filter(Boolean).join(", ");
+    const ages = Object.entries(f.ages ?? {}).map(([who, a]) => `${name(who)} ${humanAge(a, lang)}`);
+    return [f.house && ui(lang, "ui.sync.house", { x: f.house }), f.age && humanAge(f.age, lang), ...ages, f.cause && ui(lang, "ui.sync.cause", { x: f.cause })].filter(Boolean).join(", ");
 }
 /** A position on the map as a map shows it: degrees, six decimals at most. */
 const point = (p) => `${+p.lat.toFixed(6)}, ${+p.lon.toFixed(6)}`;
@@ -41,15 +42,17 @@ function changeLine(tree, c, incoming, lang) {
         return p ? `${(p.names[0] ? `${p.names[0].given} ${p.names[0].surname}` : key).trim()} [${key}]` : key;
     };
     const who = c.partners ? c.partners.map(name).join(" & ") || c.family || "?" : name(c.person);
+    // a partner in their age: the given name
+    const short = (key) => (key.startsWith("x:") ? name(key) : (tree.get(key)?.names[0]?.given ?? key));
     const kind = (f) => (f ? eventName(f.kind, lang, f.label) : "");
     const v = {
         n: c.n,
         who,
         name: name(c.person),
         kind: kind(c.fact ?? c.was),
-        fact: `${kind(c.fact ?? c.was)} ${factText(c.fact ?? c.was, lang)}`,
-        was: c.kind === "fact.detail" ? detailText(c.was, lang) || "—" : factText(c.was, lang),
-        now: c.kind === "fact.detail" ? detailText(c.fact, lang) : factText(c.fact, lang),
+        fact: `${kind(c.fact ?? c.was)} ${factText(c.fact ?? c.was, lang, short)}`,
+        was: c.kind === "fact.detail" ? detailText(c.was, lang, short) || "—" : factText(c.was, lang, short),
+        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),
         child: name(c.child),

package/dist/core/actions.js

@@ -591,7 +591,8 @@ export function editEvent(tree, eventId, edit, reason) {
     const date = edit.date === undefined ? undefined : parseDate(edit.date);
     // an empty age takes it away
     const age = edit.age === undefined ? undefined : edit.age.trim() ? parseAge(edit.age) : "";
-    const ages = edit.ages ? Object.fromEntries(Object.entries(edit.ages).map(([who, a]) => [who, parseAge(a, who)])) : undefined;
+    // an empty age of a partner takes it away
+    const ages = edit.ages ? Object.fromEntries(Object.entries(edit.ages).map(([who, a]) => [who, a.trim() ? parseAge(a, who) : ""])) : undefined;
     return replaceEvent(tree, eventId, (e) => {
         const changed = [];
         const set = (k, v) => {
@@ -621,7 +622,11 @@ export function editEvent(tree, eventId, edit, reason) {
             for (const [who, a] of Object.entries(ages))
                 if (e.ages?.[who] !== undefined && e.ages[who] !== a)
                     changed.push(`age of ${who}`);
-            next.ages = { ...e.ages, ...ages };
+            const merged = Object.fromEntries(Object.entries({ ...e.ages, ...ages }).filter(([, a]) => a));
+            if (Object.keys(merged).length)
+                next.ages = merged;
+            else
+                delete next.ages;
         }
         const key = (p) => `${p.role}|${p.person ?? foldText(p.name ?? "")}`;
         if (edit.drop?.length) {

package/dist/core/live.js

@@ -49,7 +49,7 @@ import { rankTasks } from "./queue.js";
 import { humanTask } from "../cli/human.js";
 import { knownNewerVersion } from "./update.js";
 import { gitProgram, runGit } from "./git.js";
-import { appOpensLinks, appShowsEdges, appShowsStoryDrafts, isStromAppOrigin } from "./stromapp.js";
+import { appOpensLinks, appShowsCoupleEvents, appShowsEdges, appShowsStoryDrafts, isStromAppOrigin } from "./stromapp.js";
 import { Settings } from "./config.js";
 import { linkActions, linkHandlerState } from "./links.js";
 import { stromLauncher } from "./self.js";
@@ -596,11 +596,12 @@ export function serveLive(root, env) {
                     // …and where the tree ends, for an app that shows it
                     const edges = appShowsEdges(new Settings(env, {}));
                     const storyDrafts = appShowsStoryDrafts(new Settings(env, {}));
+                    const coupleResi = appShowsCoupleEvents(new Settings(env, {}));
                     const offered = opens ? links(env) : [];
                     ged = {
                         head: h,
                         links: offered.join(" "),
-                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(offered.length ? { links: offered } : {}) }).text,
+                        text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}), ...(opens ? { clips: true, research: true } : {}), ...(edges ? { edges } : {}), ...(storyDrafts ? { storyDrafts } : {}), ...(coupleResi ? { coupleResi } : {}), ...(offered.length ? { links: offered } : {}) }).text,
                     };
                 }
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Strom-Head": h }).end(ged.text);

package/dist/core/stromapp.js

@@ -82,6 +82,27 @@ export function appShowsEdges(settings, version) {
             return (a[i] ?? 0) > (b[i] ?? 0);
     return true;
 }
+/**
+ * The Strom app keeps a couple's events as events (the app's spec docs/ZADANI_VYZKUM_udalosti-paru.md, its 3.8.0):
+ * their residence goes to it as 1 RESI under FAM (before: an EVEN named so — an older app keeps either in the couple's
+ * note). stromapp.info from 3.8.0 (2026-10-02); another copy of the app (its beta, its development) is taken as current.
+ * An app of unknown version: today's.
+ */
+export const APP_SHOWS_COUPLE_EVENTS = "3.8.0";
+export function appShowsCoupleEvents(settings, version) {
+    if (stromAppUrl(settings) !== STROM_APP_URL)
+        return true;
+    if (!APP_SHOWS_COUPLE_EVENTS)
+        return false;
+    if (!version)
+        return true;
+    const n = (v) => v.split(".").map((x) => Number.parseInt(x, 10) || 0);
+    const [a, b] = [n(version), n(APP_SHOWS_COUPLE_EVENTS)];
+    for (let i = 0; i < 3; i++)
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    return true;
+}
 /**
  * The Strom app shows the new version of a story the user approved, waiting beside it (the app's spec
  * docs/ZADANI_VYZKUM_vypraveni-zamek.md): 2 _DRAFT under _STORY, and in the bridge's waiting (kind story). stromapp.info

package/dist/core/sync.js

@@ -28,6 +28,7 @@ import { fromFlexDate, houseOf, importDate } from "./import.js";
 import { normalizeAge } from "./age.js";
 import { create, update } from "./records.js";
 import { foldText } from "./text.js";
+import { labels } from "../gedcom/labels.js";
 import { UsageError } from "./errors.js";
 import * as git from "./git.js";
 import { now, Tree } from "./tree.js";
@@ -88,8 +89,8 @@ const ALTERNATIVE = {
 };
 /** Facts there is one of: an edit of one is a change, not a second fact. */
 const ONE = new Set(["BIRT", "BAPM", "DEAT", "BURI", "CREM", "MARR", "DIV"]);
-function gedFacts(node) {
-    return cleanFacts(rawFacts(node));
+function gedFacts(node, couple) {
+    return cleanFacts(rawFacts(node, couple));
 }
 /** What the Strom app adds of its own: an alternative birth or death as an event, a "Birth record" beside a birth, every couple married. */
 function cleanFacts(facts) {
@@ -109,7 +110,7 @@ function cleanFacts(facts) {
         // a marriage with nothing known of it: every couple of the Strom app is "married"
         !(f.kind === "MARR" && !f.date && !f.place && !f.value));
 }
-function rawFacts(node) {
+function rawFacts(node, couple) {
     const out = [];
     for (const c of node.children) {
         if (["NAME", "SEX", "REFN", "NOTE", "FAMC", "FAMS", "HUSB", "WIFE", "CHIL", "SOUR", "OBJE", "ASSO", "_STORY"].includes(c.tag))
@@ -129,7 +130,20 @@ function rawFacts(node) {
             f.value = value.replace(/\s+/g, " ");
         if (kind === "EVEN")
             f.label = val(c, "TYPE") ?? f.value ?? "EVEN";
-        details(f, val(c, "CAUS"), val(c, "AGE"), val(c, "ADDR"));
+        // a couple's residence written as an event named so (for a Strom app before its couple's events): their residence
+        if (couple && kind === "EVEN" && COUPLE_RESIDENCE.has(fold(f.label))) {
+            f.kind = "RESI";
+            delete f.label;
+        }
+        details(f, val(c, "CAUS"), couple ? undefined : val(c, "AGE"), val(c, "ADDR"));
+        if (couple)
+            for (const role of ["HUSB", "WIFE"]) {
+                const who = couple[role];
+                const age = val(c.children.find((x) => x.tag === role), "AGE");
+                const a = who && age?.trim() ? normalizeAge(age) : undefined;
+                if (a)
+                    f.ages = { ...f.ages, [who]: a };
+            }
         const id = val(c, "_EID");
         if (id)
             f.id = id;
@@ -149,8 +163,21 @@ function details(f, cause, age, house) {
     if (h)
         f.house = h;
 }
-/** The details of a fact the research compares (DETAILS of SFact). */
+/** The details of a fact the research compares, besides the partners' ages. */
 const DETAILS = ["cause", "age", "house"];
+/** A couple's residence as an event of that name (the export's label in any language). */
+const COUPLE_RESIDENCE = new Set(["en", "cs", "de", "pl", "sk"].map((l) => fold(labels(l)("RESI"))));
+/** What a fact says besides, one entry each: cause, age, house, and "ages:<key>" for a partner's age. */
+function detailsOf(f) {
+    const out = {};
+    for (const d of DETAILS)
+        if (f[d])
+            out[d] = f[d];
+    for (const [who, a] of Object.entries(f.ages ?? {}))
+        if (a)
+            out[`ages:${who}`] = a;
+    return out;
+}
 /** Every note under a record, its facts' and citations' too, as one text. */
 function allNotes(n, noteText) {
     const out = [];
@@ -206,7 +233,7 @@ export function readGedcom(text) {
     const families = [];
     for (const r of records.filter((x) => x.tag === "FAM")) {
         const who = (tag) => children(r, tag).map((c) => keys.get(c.value.trim())).filter((k) => !!k && persons.has(k));
-        families.push({ partners: [...who("HUSB"), ...who("WIFE")], children: who("CHIL"), facts: gedFacts(r) });
+        families.push({ partners: [...who("HUSB"), ...who("WIFE")], children: who("CHIL"), facts: gedFacts(r, { HUSB: who("HUSB")[0], WIFE: who("WIFE")[0] }) });
     }
     const treeId = val(head, "_STROM_TREE");
     const at = val(head, "_STROM_HEAD");
@@ -219,6 +246,11 @@ const APP_EVENTS = {
     firstCommunion: "FCOM", barMitzvah: "BARM", batMitzvah: "BASM", ordination: "ORDN", adoption: "ADOP", naturalization: "NATU",
     will: "WILL", probate: "PROB", title: "TITL", nationality: "NATI", cremation: "CREM",
 };
+/** The Strom app's events of a couple (its 3.8) → GEDCOM tags. */
+const APP_COUPLE_EVENTS = {
+    engagement: "ENGA", banns: "MARB", marriageLicence: "MARL", marriageContract: "MARC", marriageSettlement: "MARS",
+    residence: "RESI", census: "CENS", divorceFiled: "DIVF", annulment: "ANUL", custom: "EVEN",
+};
 /** Facts whose value is what they are (the GEDCOM tag's value). */
 const VALUE_KINDS = new Set(["OCCU", "RELI", "TITL", "NATI"]);
 /** A tree of the Strom app (its JSON) as a snapshot. */
@@ -277,6 +309,17 @@ export function readStromJson(data) {
             said: p.notes ?? "",
         });
     }
+    // a partner's age by the app's person id → by the person's key
+    const partnersAges = (ages) => {
+        const out = {};
+        for (const [id, raw] of Object.entries(ages ?? {})) {
+            const key = keys.get(id);
+            const a = key && typeof raw === "string" && raw.trim() ? normalizeAge(raw) : undefined;
+            if (key && a)
+                out[key] = a;
+        }
+        return Object.keys(out).length ? out : undefined;
+    };
     const families = [];
     for (const u of Object.values(d.partnerships ?? {})) {
         const partners = [u.person1Id, u.person2Id].map((x) => (x ? keys.get(x) : undefined)).filter((k) => !!k);
@@ -289,8 +332,31 @@ export function readStromJson(data) {
             if (u.startPlace?.trim())
                 f.place = u.startPlace.trim();
             details(f, undefined, undefined, u.address);
+            const ages = partnersAges(u.ages);
+            if (ages)
+                f.ages = ages;
             facts.push(f);
         }
+        // the couple's other events (the app's 3.8)
+        for (const e of u.events ?? []) {
+            const kind = APP_COUPLE_EVENTS[e.type];
+            if (!kind)
+                continue;
+            const f = { kind };
+            const g = fromFlexDate(e.date);
+            if (g)
+                f.date = g;
+            if (e.place?.trim())
+                f.place = e.place.trim().replace(/\s+/g, " ");
+            if (kind === "EVEN")
+                f.label = e.customLabel || "EVEN";
+            details(f, e.cause, undefined, e.address);
+            const ages = partnersAges(e.ages);
+            if (ages)
+                f.ages = ages;
+            if (f.date || f.place || f.label || kind !== "EVEN")
+                facts.push(f);
+        }
         // the divorce (the app's 3.7 keeps its place too)
         if (u.status === "divorced" && (u.endDate || u.endPlace)) {
             const f = { kind: "DIV" };
@@ -612,15 +678,19 @@ export function planSync(tree, incoming, edits, opts = {}) {
             if (ourKeys.has(k)) {
                 // the research has it: what the file says of it besides (its cause, age, house) may be the user's — paired
                 // with the same details first (one lived in several houses of a place: each its own fact)
-                const sameDetails = (a, b) => DETAILS.every((d) => !a[d] || exact(a[d]) === exact(b[d]));
+                const sameDetails = (a, b) => {
+                    const [x, y] = [detailsOf(a), detailsOf(b)];
+                    return Object.keys(x).every((d) => exact(x[d]) === exact(y[d]));
+                };
                 const mates = our.filter((x) => factKey(x) === k);
                 if (mates.some((x) => sameDetails(f, x)) || was?.some((x) => factKey(x) === k && sameDetails(f, x)))
                     continue;
                 const o = mates.find((x) => !inc.some((i) => factKey(i) === k && sameDetails(i, x))) ?? mates[0];
                 const b = was?.find((x) => factKey(x) === k && (!x.id || x.id === o.id));
-                const changed = DETAILS.filter((d) => f[d] && exact(f[d]) !== exact(o[d]) && !(b && exact(f[d]) === exact(b[d])));
+                const [fd, od, bd] = [detailsOf(f), detailsOf(o), b ? detailsOf(b) : undefined];
+                const changed = Object.keys(fd).filter((d) => exact(fd[d]) !== exact(od[d]) && !(bd && exact(fd[d]) === exact(bd[d])));
                 if (changed.length) {
-                    const added = changed.every((d) => !o[d]);
+                    const added = changed.every((d) => !od[d]);
                     const action = added ? "add" : !was ? "pick" : recordBacked(tree, eventById(tree, o.id)) ? "conflict" : "correct";
                     if (action !== "conflict" || !openConflict(tree, owner.person ?? owner.family, f))
                         push({ kind: "fact.detail", action, ...owner, fact: f, was: o });
@@ -896,13 +966,17 @@ export function applySync(tree, plan, incoming, source, only) {
                     applied.push({ do: "conflict.add", id: x.id });
                     break;
                 }
-                const set = Object.fromEntries(DETAILS.filter((d) => c.fact[d] && c.fact[d] !== mine[d]).map((d) => [d, c.fact[d]]));
-                editEvent(tree, mine.id, set, `${c.action === "add" ? "added from" : "corrected in"} ${reason}`);
+                const [fd, md] = [detailsOf(c.fact), detailsOf(mine)];
+                const changed = Object.keys(fd).filter((d) => fd[d] !== md[d] && (!d.startsWith("ages:") || !!who(d.slice(5))));
+                if (!changed.length)
+                    break;
+                editEvent(tree, mine.id, detailEdit(Object.fromEntries(changed.map((d) => [d.startsWith("ages:") ? `ages:${who(d.slice(5))}` : d, fd[d]]))), `${c.action === "add" ? "added from" : "corrected in"} ${reason}`);
+                const set = Object.fromEntries(changed.map((d) => [d, fd[d]]));
                 update(tree, owner, owner.startsWith("F") ? "family" : "person", (o) => ({ ...o, events: o.events.map((e) => (e.id === mine.id && !e.citations.some((x) => x.source === source.id) ? { ...e, citations: [...e.citations, cite(`${c.fact.kind} ${Object.keys(set).join(" ")}`)] } : e)) }), {
                     op: "event.cite",
                     summary: `${mine.id} cites ${source.id}`,
                 });
-                applied.push({ do: "event.detail", id: mine.id, before: JSON.stringify(Object.fromEntries(DETAILS.map((d) => [d, mine[d] ?? ""]))) });
+                applied.push({ do: "event.detail", id: mine.id, before: JSON.stringify(Object.fromEntries(changed.map((d) => [d.startsWith("ages:") ? `ages:${who(d.slice(5))}` : d, md[d] ?? ""]))) });
                 break;
             }
             case "name.new": {
@@ -975,8 +1049,20 @@ function nameOf(gedName) {
         return { given: gedName.trim(), surname: "" };
     return { given: `${m[1].trim()} ${m[3].trim()}`.trim(), surname: m[2].trim() };
 }
+/** Details ("ages:P0001" among them) as an edit of the fact; an empty one takes it away. */
+function detailEdit(d) {
+    const out = {};
+    for (const [k, v] of Object.entries(d)) {
+        if (k.startsWith("ages:"))
+            out.ages = { ...out.ages, [k.slice(5)]: v };
+        else if (k === "cause" || k === "age" || k === "house")
+            out[k] = v;
+    }
+    return out;
+}
 function describe(f) {
-    return [f.value, f.date, f.place, f.house && `house ${f.house}`, f.age && `aged ${f.age}`, f.cause && `cause ${f.cause}`].filter(Boolean).join(", ") || "—";
+    const ages = Object.entries(f.ages ?? {}).map(([who, a]) => `${who} aged ${a}`);
+    return [f.value, f.date, f.place, f.house && `house ${f.house}`, f.age && `aged ${f.age}`, ...ages, f.cause && `cause ${f.cause}`].filter(Boolean).join(", ") || "—";
 }
 /** Undo one sync: what it added withdrawn, what it corrected put back, its conflicts closed — each with the reason. */
 export function undoSync(tree, input) {
@@ -998,9 +1084,10 @@ export function undoSync(tree, input) {
                 // what it was put back: a detail it had, and none where it had none
                 const e = eventById(tree, a.id);
                 const before = JSON.parse(String(a.before ?? "{}"));
-                const edit = Object.fromEntries(DETAILS.filter((d) => (before[d] ?? "") !== (e?.[d] ?? "")).map((d) => [d, before[d] ?? ""]));
-                if (e && Object.keys(edit).length)
-                    editEvent(tree, a.id, edit, reason);
+                const now = e ? detailsOf(e) : {};
+                const back = Object.fromEntries(Object.entries(before).filter(([d, v]) => v !== (now[d] ?? "")));
+                if (e && Object.keys(back).length)
+                    editEvent(tree, a.id, detailEdit(back), reason);
                 break;
             }
             case "event.retract":

package/dist/core/tree.js

@@ -23,7 +23,7 @@ import * as git from "./git.js";
 import { commitSeal, createKey, fingerprint, loadKey, sha256, signOp } from "./seal.js";
 import { stringifyCanonical } from "./json.js";
 export const TREE_FILE = "strom.json";
-export const VERSION = "1.10.0";
+export const VERSION = "1.11.0";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/gedcom/export.js

@@ -360,8 +360,8 @@ export function exportGedcom(tree, opts = {}) {
         const allowed = on === "INDI" ? INDI_TAGS : FAM_TAGS;
         let tag = e.kind;
         let typeLabel = e.label;
-        if (on === "FAM" && tag === "RESI" && strict) {
-            // standard on FAM; Strom does not read it yet, so only in strict
+        if (on === "FAM" && tag === "RESI" && (strict || opts.coupleResi)) {
+            // standard on FAM; for a Strom app before its couple's events an EVEN named so
         }
         else if (AS_EVEN[tag] || !allowed.has(tag)) {
             typeLabel = e.label ?? (AS_EVEN[tag] ? L(AS_EVEN[tag]) : L(tag) ?? tag);

package/dist/gedcom/validate.js

@@ -11,7 +11,7 @@ const INDI_EVENTS = [
     "NATU", "RELI", "TITL", "NATI", "ADOP", "WILL", "PROB", "BURI", "CREM", "CENS", "EVEN", "RETI", "BLES", "CAST", "DSCR", "IDNO",
     "NCHI", "NMR", "PROP", "SSN", "FACT",
 ];
-const FAM_EVENTS = ["MARR", "DIV", "MARB", "MARC", "MARL", "MARS", "ANUL", "DIVF", "ENGA", "CENS", "EVEN", "NCHI"];
+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"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {