strom-research 1.18.0-beta.12 → 1.18.0-beta.14

package/CHANGELOG.cs.md

@@ -7,7 +7,7 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
 
 ## 1.18.0
 
-*Připravuje se: bety do 1.18.0-beta.12. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.18.0-beta.14. Oddíl bude úplný s vydáním.*
 
 - **Fotky z telefonu nastojato.** Fotka otočená podle údaje EXIF se čte tak, jak se má dívat, nastojato; místa na ní
   vyznačená (výřezy, poloviny dvoustrany, uložená část) jsou místa obrázku, jak se ukazuje. Fotka sama zůstává, jak
@@ -20,8 +20,9 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   matriky, dopis, listinu, náhrobek, rub fotky: přepis slovo od slova, překlad, význam starých slov a zkratek a osoby,
   které jmenuje, i s tím, kdo ze stromu to může být. Nic se nedomýšlí: jméno, které v dokumentu není, vypadne — i
   příjmení, nikdy se nebere od otce ani z jiné rodiny —, co nejde přečíst, je označené; druhý čtenář může číst naslepo.
-  Dokument na úředním formuláři, jako rodný list, si své osoby ponechá — dítě i oba rodiče s jejich podílem —, a dokument
-  přečtený dřív je po aktualizaci ukáže, aniž by se četl znovu.
+  Dokument na úředním formuláři, jako rodný list, si své osoby ponechá — dítě i oba rodiče s jejich podílem, i jméno a
+  příjmení psané proloženě a rodné příjmení po „roz.“ —, a dokument přečtený dřív je po aktualizaci ukáže, aniž by se
+  četl znovu. U každé osoby a události je i místo na stránce, kde stojí, takže aplikace Strom ukáže výřez každé z nich.
   Do stromu se z toho nic nezapíše samo. Dokument už přečtený to o sobě řekne, takže se omylem nečte podruhé. Dokument
   čtený znovu se ukazuje pod názvem svého souboru, nikdy pod kódem. Dokument poslaný z aplikace Strom najde agenta
   stejně jako terminál — i nainstalovaného do vlastní složky, přes npm nebo Homebrew — místo hlášení, že agent není

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.18.0
 
-*In Vorbereitung: die Betas bis 1.18.0-beta.12. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.18.0-beta.14. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Handyfotos aufrecht.** Ein Foto, das nach seiner EXIF-Ausrichtung gedreht ist, wird gelesen, wie es gesehen
   werden soll, aufrecht; die darauf markierten Stellen (Ausschnitte, die Hälften einer Doppelseite, ein gespeicherter
@@ -21,8 +21,11 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   Wort, ihre Übersetzung, was alte Wörter und Abkürzungen bedeuten, und die genannten Personen, samt wem im Stammbaum
   sie entsprechen können. Nichts wird ergänzt: ein Name, der nicht im Dokument steht, fällt weg — auch ein Nachname, nie
   vom Vater oder aus einer anderen Familie genommen —, Unleserliches wird markiert; ein zweiter Leser kann blind lesen.
-  Ein Dokument auf einem amtlichen Formular, etwa eine Geburtsurkunde, behält seine Personen — das Kind und beide
-  Eltern mit ihrem Anteil —, und ein früher gelesenes Dokument zeigt sie nach dem Update, ohne erneut gelesen zu werden.
+  Ein Dokument auf einem amtlichen Formular, etwa eine Geburtsurkunde, behält seine Personen — das Kind und beide Eltern
+  mit ihrem Anteil, auch ein gesperrt getippter Name und ein Geburtsname nach „geb.“ —, und ein früher gelesenes
+  Dokument zeigt sie nach dem Update, ohne erneut gelesen zu werden. Jede Person und jedes Ereignis kommt mit der Stelle
+  auf der Seite, an der es steht, so zeigt die Strom-App von jedem
+  einen eigenen Ausschnitt.
   In den Stammbaum gelangt nichts von selbst. Ein schon gelesenes Dokument sagt es, so wird es nicht versehentlich ein
   zweites Mal gelesen. Ein erneut gelesenes Dokument wird unter dem Namen seiner Datei gezeigt, nie unter einem Code.
   Ein aus der Strom-App gesendetes Dokument findet den Agenten wie das Terminal — auch einen in einem eigenen Ordner,

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.18.0
 
-*In preparation: the betas up to 1.18.0-beta.12. The section is complete with the release.*
+*In preparation: the betas up to 1.18.0-beta.14. The section is complete with the release.*
 
 - **Phone photos upright.** A photo turned by its EXIF orientation is read as it is meant to be seen, upright; the
   places marked on it (excerpts, the halves of a spread, a cut-out part) are of the picture as it is shown. The
@@ -22,7 +22,9 @@ The changes of each version in short. The full notes and the install lines are o
   name the document does not have is left out — a surname too, never taken from a father or another family —, what
   cannot be read is marked; a second reader can read it blind. A
   document on a printed form, as a birth certificate, keeps its people — the child and both parents with their part in
-  it —, and a document read before shows them after the update with nothing read again. Nothing of it enters the tree by itself. A document read
+  it, their names typed letter-spaced and a mother's birth name after "née" or "roz." too —, and a document read before
+  shows them after the update with nothing read again. Each person and event it names comes with the place on the page
+  where it stands, so the Strom app shows each its own excerpt. Nothing of it enters the tree by itself. A document read
   already says so, so it is not read a second time by mistake. A document read again is shown under the name of its
   file, never a code. A document sent from the Strom app finds the agent as the terminal does — one installed in a
   folder of its own, by npm or Homebrew too — instead of saying no agent is set up. Every agent the research works with

package/dist/core/document.js

@@ -110,13 +110,17 @@ term: <a word or abbreviation as written> = <what it means, in ${into}> (term |
   — one line each, for the old words, formulas, abbreviations, occupations, and on a gravestone its symbols
 `}person: <ref> | <role> | ${blind ? "" : `<the role in ${into}> | `}written=<the name exactly as it stands in the transcript> | given=<the given
   name in today's form> | surname=<the surname in today's form> | sex=M|F|U | age=<as written> | occupation=<…> |
-  residence=<…> — one line each person named; ref p1, p2, … in this entry; role: ${ROLES.join(", ")};
+  residence=<…> | region=x,y,w,h — one line each person named; ref p1, p2, … in this entry; role: ${ROLES.join(", ")};
   given and surname only turn the written name into today's form ("Joannes" → "Jan"): never a name the transcript
   does not have — no surname the entry does not write by the person (a child's is not taken from its father's);
   on a form (a certificate) whose fields hold a name apart, written= the words of its fields as written there;
-  a name you could not read stays out; leave out what the entry does not say
+  a name in letter-spaced type ("N o v á k") is one word: surname=Novák; a woman written with her birth name
+  ("Marie Nováková roz. Dvořáková", geb., née, z domu): surname= the birth name;
+  a name you could not read stays out; leave out what the entry does not say; region: where the person's name
+  stands — its line, or its field on a form — as the entry's region, of the page's whole view (tight, not the entry)
 event: <BIRT | BAPM | MARR | DEAT | BURI | RESI | EVEN> | date=<as on the record, in numbers: 3.4.1846, or a year> |
-  place=<the place as written> | persons=<ref>:<principal|father|mother|godparent|witness|groom|bride|deceased|other>,…
+  place=<the place as written> | persons=<ref>:<principal|father|mother|godparent|witness|groom|bride|deceased|other>,… |
+  region=x,y,w,h — where its date (and place) stand, as a person's region
 relation: parent <ref of the parent> <ref of the child>  — or —  spouse <ref> <ref>
 ${blind
         ? ""
@@ -260,12 +264,18 @@ export function parseDocReport(text) {
             const ref = /^p\d+$/iu.test(parts[0].trim()) ? parts.shift().trim().toLowerCase() : `p${entry.persons.length + 1}`;
             const role = parts[0] && !parts[0].includes("=") ? parts.shift().trim().toLowerCase() : "other";
             const roleText = parts[0] && !parts[0].includes("=") ? parts.shift().trim() : undefined;
-            entry.persons.push({ ref, role, ...(roleText ? { roleText } : {}), fields: pairs(parts) });
+            const fields = pairs(parts);
+            const region = parseRegion(fields.region);
+            delete fields.region;
+            entry.persons.push({ ref, role, ...(roleText ? { roleText } : {}), ...(region ? { region } : {}), fields });
         }
         for (const e of fields.get("event") ?? []) {
             const parts = e.split(/\s*\|\s*/u);
             const type = parts[0] && !parts[0].includes("=") ? parts.shift().trim() : "EVEN";
-            entry.events.push({ type, fields: pairs(parts) });
+            const fields = pairs(parts);
+            const region = parseRegion(fields.region);
+            delete fields.region;
+            entry.events.push({ type, ...(region ? { region } : {}), fields });
         }
         for (const r of fields.get("relation") ?? []) {
             const w = r.split(/[\s,]+/u).filter(Boolean);
@@ -304,20 +314,113 @@ function kindOf(said) {
         return "photo.back";
     return "other";
 }
-export function words(s) {
+/** One letter alone, as a typewriter spaces out a name (V í š e k); the last of them may have a stop or a "[?]". */
+const SPACED = /^\p{L}\p{M}*$/u;
+const SPACED_LAST = /^\p{L}\p{M}*(?:\[\?\]|[^\p{L}\p{M}\p{N}\[\]])*$/u;
+const keyOf = (t) => foldText(t.replace(/\[\?\]/gu, "")).replace(/[^\p{L}\p{M}\p{N}]+/gu, "");
+/** The keys of the words of names (a reader's given name and surname, the other reader's text) that join spaced letters. */
+export function nameKeys(...names) {
+    return names.flatMap((n) => (n ? words(n).map((w) => w.key) : [])).filter((k) => k.length >= 2 && k !== "[...]");
+}
+/**
+ * The words of a text as they are compared: a word after a stop with no space ("roz.Nováková", "n.Labem") a word of
+ * its own, glued to the one before; letters standing alone (a name in letter-spaced type, "N o v á k") one word, as
+ * written — a run of them that spells one of `names` (the reader's given name or surname), the rest of a run that has
+ * one, and else three or more beginning with a capital; a gap of two spaces or more (a typewriter's between the words of
+ * a spaced name) or a line ends a run. Letters of running text ("šel a v k domu") stay words of their own.
+ */
+export function words(s, names = []) {
     const src = s
         .replace(/\s*\[\?\]/gu, "[?]")
         .replace(/\[\s*(?:\.{2,}|…)\s*\]/gu, " [...] ")
-        .replace(/\|/gu, " ");
-    return src
-        .split(/\s+/u)
-        .filter(Boolean)
-        .flatMap((t) => {
-        if (t === "[...]")
-            return [{ text: t, key: "[...]", unsure: false, illegible: true }];
-        const key = foldText(t.replace(/\[\?\]/gu, "")).replace(/[^\p{L}\p{M}\p{N}]+/gu, "");
-        return key ? [{ text: t, key, unsure: t.includes("[?]"), illegible: false }] : [];
-    });
+        .replace(/\|/gu, "  ");
+    const parts = [];
+    for (const m of src.matchAll(/(\s*)(\S+)/gu)) {
+        const wide = m[1].length > 1 || /[\n\r]/u.test(m[1]);
+        if (m[2] === "[...]")
+            parts.push({ t: m[2], glued: false, wide });
+        else
+            m[2].split(/(?<=\p{L}\p{M}*\.)(?=\p{L})/u).forEach((t, i) => parts.push({ t, glued: i > 0, wide: i === 0 && wide }));
+    }
+    const known = new Set(names);
+    const out = [];
+    const letters = (a, b) => {
+        const text = parts.slice(a, b).map((x) => x.t).join(" ");
+        out.push({ text, key: keyOf(text), unsure: text.includes("[?]"), illegible: false });
+    };
+    for (let i = 0; i < parts.length; i++) {
+        // a run of letters alone: no gap of two spaces within, the last may have a stop, the word after not glued to it
+        let j = i;
+        while (j < parts.length && !parts[j].glued && (j === i || !parts[j].wide) && SPACED.test(parts[j].t))
+            j++;
+        if (j < parts.length && j > i && !parts[j].glued && !parts[j].wide && SPACED_LAST.test(parts[j].t) && !SPACED.test(parts[j].t))
+            j++;
+        if (j - i >= 2 && (j === parts.length || !parts[j].glued)) {
+            // the names it spells, the longest first, and what stands between them
+            const named = [];
+            for (let a = i; a < j - 1;) {
+                let b = j;
+                while (b - a >= 2 && !known.has(keyOf(parts.slice(a, b).map((x) => x.t).join(""))))
+                    b--;
+                if (b - a >= 2) {
+                    named.push([a, b]);
+                    a = b;
+                }
+                else
+                    a++;
+            }
+            if (named.length) {
+                let a = i;
+                for (const [x, y] of [...named, [j, j]]) {
+                    if (x - a >= 2)
+                        letters(a, x);
+                    else
+                        for (let k = a; k < x; k++)
+                            letters(k, k + 1);
+                    if (y > x)
+                        letters(x, y);
+                    a = y;
+                }
+                i = j - 1;
+                continue;
+            }
+            if (j - i >= 3 && /^\p{Lu}/u.test(parts[i].t)) {
+                letters(i, j);
+                i = j - 1;
+                continue;
+            }
+        }
+        const { t, glued } = parts[i];
+        if (t === "[...]") {
+            out.push({ text: t, key: "[...]", unsure: false, illegible: true });
+            continue;
+        }
+        const key = keyOf(t);
+        if (key)
+            out.push({ text: t, key, unsure: t.includes("[?]"), illegible: false, ...(glued ? { glued } : {}) });
+    }
+    return out;
+}
+/** Words that stand in a row as they were written: one space between, none before a word glued to the one before. */
+function asWritten(span) {
+    return span.map((x, i) => (i && !x.glued ? ` ${x.text}` : x.text)).join("");
+}
+/**
+ * The words of a birth name's mark, folded: in full — rozená, geborene, née, nata, urodzona, урождённая, z domu — or
+ * shortened with its stop — roz., geb., urodz., ur., урожд. —: the name after one is the person's birth surname.
+ */
+const BIRTH_WORDS = new Set(["rozena", "rozeny", "geborene", "geborener", "nee", "nata", "urodzona", "урожденная", "урожденный", "szuletett"]);
+const BIRTH_SHORT = new Set(["roz", "geb", "urodz", "ur", "урожд", "szul"]);
+/** A birth name's mark at `i`; a short one only with its stop, "ur." only before the reader's surname (Ur is a name too). */
+function birthMarkAt(span, i, surnameAt) {
+    const x = span[i];
+    if (x.key === "domu")
+        return span[i - 1]?.key === "z";
+    if (BIRTH_WORDS.has(x.key))
+        return true;
+    if (!BIRTH_SHORT.has(x.key) || !/\.$/u.test(x.text.replace(/\[\?\]/gu, "")))
+        return false;
+    return x.key !== "ur" || i + 1 === surnameAt;
 }
 /** Where the words of `part` stand in `whole`, in a row (its first place), else -1. */
 function find(whole, part) {
@@ -504,17 +607,20 @@ export function checkEntry(raw, id, blind = false, form = false) {
             checks.push({ entry: id, ref: p.ref, what: [p.fields.given, p.fields.surname].filter(Boolean).join(" ") || p.role, why: "no-name" });
             continue;
         }
-        const w = words(written);
-        const at = find(text, w);
+        // letters spaced out (a name typed letter-spaced) joined as the reader's given name and surname spell them
+        const names = nameKeys(p.fields.given, p.fields.surname);
+        const own = words(raw.transcript, names);
+        const w = words(written, names);
+        const at = find(own, w);
         // a form (a certificate) holds a name in its fields apart — the surname in one, the given names in another —:
         // its words each written there are the name; elsewhere a name stands in a row as written
-        const span = at >= 0 ? text.slice(at, at + w.length) : form ? findApart(text, w) : undefined;
+        const span = at >= 0 ? own.slice(at, at + w.length) : form ? findApart(own, w) : undefined;
         if (!span) {
             checks.push({ entry: id, ref: p.ref, what: written, why: "not-in-transcript" });
             continue;
         }
         const role = (ROLES.includes(p.role) ? p.role : "other");
-        const person = { ref: p.ref, role, written: span.map((x) => x.text).join(" ") };
+        const person = { ref: p.ref, role, written: at >= 0 ? asWritten(span) : span.map((x) => x.text).join(" ") };
         if (p.roleText && !blind)
             person.roleText = p.roleText;
         const uncertain = new Set();
@@ -540,7 +646,13 @@ export function checkEntry(raw, id, blind = false, form = false) {
         }
         // the given name: the other words; a word of today's form must be one of them in its letters (Josephi → Josef,
         // Joannes → Jan), else the name is as written and the reader's form only a lead (today)
-        const givenWords = span.filter((_, i) => i !== surnameAt);
+        // (not a birth name's mark, roz. or geb., nor the birth name after it)
+        const marked = new Set();
+        span.forEach((x, i) => {
+            if (birthMarkAt(span, i, surnameAt))
+                [i, i + 1, ...(x.key === "domu" ? [i - 1] : [])].forEach((k) => marked.add(k));
+        });
+        const givenWords = span.filter((_, i) => i !== surnameAt && !marked.has(i));
         const given = p.fields.given?.replace(/\[\?\]/gu, "").trim();
         if (given) {
             const legible = givenWords.filter((x) => !x.illegible);
@@ -551,7 +663,7 @@ export function checkEntry(raw, id, blind = false, form = false) {
                 if (fits)
                     person.given = given;
                 else {
-                    person.given = legible.map((x) => x.text.replace(/\[\?\]/gu, "").replace(/^[^\p{L}\p{M}\p{N}]+|[^\p{L}\p{M}\p{N}]+$/gu, "")).join(" ");
+                    person.given = legible.map((x) => x.text.replace(/\[\?\]|\s+/gu, "").replace(/^[^\p{L}\p{M}\p{N}]+|[^\p{L}\p{M}\p{N}]+$/gu, "")).join(" ");
                     person.today = given;
                     uncertain.add("given");
                     checks.push({ entry: id, ref: p.ref, what: `given "${given}" for "${person.given}"`, why: "not-of-its-letters" });
@@ -574,6 +686,9 @@ export function checkEntry(raw, id, blind = false, form = false) {
         }
         if (uncertain.size)
             person.uncertain = [...uncertain];
+        const region = partOf(p.region, raw.region);
+        if (region)
+            person.region = region;
         persons.push(person);
     }
     const refs = new Set(persons.map((p) => p.ref));
@@ -603,6 +718,9 @@ export function checkEntry(raw, id, blind = false, form = false) {
         }
         if (uncertain.size)
             ev.uncertain = [...uncertain];
+        const region = partOf(e.region, raw.region);
+        if (region)
+            ev.region = region;
         events.push(ev);
     }
     const relations = [];
@@ -623,11 +741,30 @@ export function checkEntry(raw, id, blind = false, form = false) {
         entry.glossary = raw.terms;
     return { entry, checks };
 }
+/** A name's or a date's line is no more than a quarter of the page. */
+const PART_AREA = 0.25;
+/** How far a part may lie out of its entry's region (a reader's regions are rough). */
+const PART_SLACK = 0.05;
+/**
+ * A person's or an event's region as a reader gave it, where it can be one: a part of the page no bigger than a
+ * quarter of it, that lies (roughly) in its entry's region; else none — the app shows the entry's region then.
+ */
+function partOf(r, entry) {
+    if (!r || r[2] * r[3] > PART_AREA)
+        return undefined;
+    if (!entry)
+        return r;
+    const [x, y, w, h] = [entry[0] - PART_SLACK, entry[1] - PART_SLACK, entry[2] + 2 * PART_SLACK, entry[3] + 2 * PART_SLACK];
+    const across = Math.min(r[0] + r[2], x + w) - Math.max(r[0], x);
+    const down = Math.min(r[1] + r[3], y + h) - Math.max(r[1], y);
+    return across > 0 && down > 0 ? r : undefined;
+}
 // ── two readers ───────────────────────────────────────────────────────────────────────────────────────────────────
 /** The hunks where two transcripts differ, word by word (their keys; the marks [?] are no difference). */
 export function wordDiff(a, b) {
-    const x = words(a);
-    const y = words(b);
+    // letters one reader spaced out joined as the other wrote the word
+    const x = words(a, nameKeys(b));
+    const y = words(b, nameKeys(a));
     const n = x.length;
     const m = y.length;
     const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
@@ -667,7 +804,7 @@ const same = (a, b) => foldText(a ?? "") === foldText(b ?? "");
  * one's. Index in `mine` → index in `theirs`.
  */
 function pairByName(mine, theirs) {
-    const keys = (p) => words(p.written).filter((x) => !x.illegible).map((x) => x.key);
+    const keys = (p) => words(p.written, nameKeys(p.given, p.surname)).filter((x) => !x.illegible).map((x) => x.key);
     const surname = (p) => words(p.surname ?? "").map((x) => x.key);
     const WHOLE = 1000;
     const score = (p, q) => {
@@ -720,6 +857,7 @@ export function compareReadings(first, blind) {
         used.set(e.page, k + 1);
         const b = other.get(e.page)?.[k];
         const variants = [];
+        const regions = new Map();
         if (!b)
             variants.push({ field: "entry", at: e.id, other: "" });
         else {
@@ -737,6 +875,9 @@ export function compareReadings(first, blind) {
                 for (const f of ["given", "surname"])
                     if (!same(p[f], q[f]))
                         variants.push({ field: `${p.ref}.${f}`, at: p[f] ?? "", other: q[f] ?? "" });
+                // where the name stands: the first reader's, else the blind one's of the same person
+                if (!p.region && q.region)
+                    regions.set(p, q.region);
             };
             const alone = [];
             for (const p of e.persons) {
@@ -775,6 +916,8 @@ export function compareReadings(first, blind) {
                     variants.push({ field: ev.type, at: ev.date?.text ?? ev.type, other: "" });
                     continue;
                 }
+                if (!ev.region && q.region)
+                    regions.set(ev, q.region);
                 if ((ev.date?.gedcom ?? ev.date?.text) !== (q.date?.gedcom ?? q.date?.text) && !same(ev.date?.text, q.date?.text))
                     variants.push({ field: `${ev.type}.date`, at: ev.date?.text ?? "", other: q.date?.text ?? "" });
                 if (!same(ev.place?.text, q.place?.text))
@@ -784,7 +927,8 @@ export function compareReadings(first, blind) {
         const agree = variants.length ? "differ" : "same";
         if (variants.length)
             all = false;
-        return { ...e, agree, ...(variants.length ? { variants } : {}) };
+        const placed = (x) => (regions.has(x) ? { ...x, region: regions.get(x) } : x);
+        return { ...e, persons: e.persons.map(placed), events: e.events.map(placed), agree, ...(variants.length ? { variants } : {}) };
     });
     // entries only the blind reader has
     for (const [page, list] of other)
@@ -820,7 +964,7 @@ function bornRange(role, year, age) {
  * and a surname of the same family (Novák/Nováková) are needed; the same sex, a birth year that fits the role and the
  * record's year, and a place of theirs add to it. A suggestion, never a decision: the person chooses.
  */
-export function matchPerson(tree, p, year, place) {
+export function matchPerson(tree, p, year, place, own, child) {
     if (!p.given || !p.surname)
         return [];
     const firstOf = (s) => foldText(s).split(" ")[0];
@@ -849,8 +993,16 @@ export function matchPerson(tree, p, year, place) {
             score += 0.1;
         }
         const born = dateYears(birthEvent(o)?.date ?? "")[0];
-        const range = year !== undefined ? bornRange(p.role, year, p.age) : undefined;
-        if (range && born !== undefined) {
+        // a parent of one the document says was born then (a certificate's grandparents) as a parent of that year
+        const range = child !== undefined ? bornRange("father", child) : year !== undefined ? bornRange(p.role, year, p.age) : undefined;
+        // the year the document says the person was born (a certificate's parents): the tree's, a year apart at most
+        if (own !== undefined && born !== undefined) {
+            if (Math.abs(born - own) > 1)
+                continue;
+            why.push("years");
+            score += 0.15;
+        }
+        else if (range && born !== undefined) {
             if (born < range[0] - 2 || born > range[1] + 2)
                 continue;
             why.push("years");
@@ -884,8 +1036,14 @@ export function withTree(tree, entries) {
             const known = knownPlace(tree, x.place.text);
             return known ? { ...x, place: { ...x.place, known } } : x;
         });
+        // the year each person was born, where the document says so
+        const bornOf = (ref) => {
+            const birth = e.events.find((x) => ["BIRT", "BAPM", "CHR"].includes(x.type) && x.date?.gedcom && x.persons.some((r) => r.ref === ref && r.role === "principal"));
+            return birth?.date?.gedcom ? dateYears(birth.date.gedcom)[0] : undefined;
+        };
         const persons = e.persons.map((p) => {
-            const match = matchPerson(tree, p, year, place);
+            const child = e.relations.flatMap((r) => (r.type === "parent" && r.parent === p.ref ? [bornOf(r.child)] : [])).find((y) => y !== undefined);
+            const match = matchPerson(tree, p, year, place, bornOf(p.ref), child);
             return match.length ? { ...p, match } : p;
         });
         return { ...e, persons, events };
@@ -1045,8 +1203,14 @@ export function buildResult(tree, s) {
                     checks.push(...c.checks);
                 // a region of a part asked (--region): of the whole page
                 const page = s.pages.find((p) => p.n === e.page);
-                if (c.entry.region && page?.region)
-                    c.entry.region = within(page.region, c.entry.region);
+                if (page?.region) {
+                    const part = page.region;
+                    if (c.entry.region)
+                        c.entry.region = within(part, c.entry.region);
+                    for (const x of [...c.entry.persons, ...c.entry.events])
+                        if (x.region)
+                            x.region = within(part, x.region);
+                }
                 out.push(c.entry);
             }
         });

package/dist/core/tree.js

@@ -27,7 +27,7 @@ import { lastBackup } from "./backup.js";
 export const TREE_FILE = "strom.json";
 // 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.18.0-beta.12";
+export const VERSION = "1.18.0-beta.14";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.18.0-beta.12",
+  "version": "1.18.0-beta.14",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {