strom-research 1.4.0 → 1.5.0

package/dist/commands/sync.js

@@ -0,0 +1,229 @@
+// sync · sync undo — a family tree coming back from the Strom app (or another
+// program), compared with the research: what the user changed, taken in on
+// their yes (core/sync.ts).
+import fs from "node:fs";
+import path from "node:path";
+import { register } from "../cli/registry.js";
+import { lines, truncate } from "../cli/format.js";
+import { ui } from "../cli/ui.js";
+import { eventName, humanDate, humanDay, humanPlace } from "../cli/human.js";
+import { EXIT, StromError, UsageError } from "../core/errors.js";
+import { fileSha256, MAX_IN_TREE, mimeOf } from "../core/media.js";
+import { create, update } from "../core/records.js";
+import { safeFolderName } from "../core/text.js";
+import { now } from "../core/tree.js";
+import { applySync, nothingSince, planSync, readTreeFile, receivedSince, undoSync } from "../core/sync.js";
+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) {
+    if (!f)
+        return "—";
+    return [f.value, humanDate(f.date, lang), humanPlace(f.place, undefined, lang)].filter(Boolean).join(", ") || "—";
+}
+/** One change as the user reads it, with what strom does with it. */
+function changeLine(tree, c, incoming, lang) {
+    const name = (key) => {
+        if (!key)
+            return "?";
+        if (key.startsWith("x:"))
+            return (incoming.persons.get(key)?.names[0] ?? key).replace(/\//g, "").replace(/\s+/g, " ").trim();
+        const p = tree.get(key);
+        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);
+    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: factText(c.was, lang),
+        now: factText(c.fact, lang),
+        text: truncate(c.text ?? "", 120),
+        child: name(c.child),
+        kids: c.kind === "family.new" && c.text ? ` + ${c.text.split(" ").filter(Boolean).map(name).join(", ")}` : "",
+    };
+    return `${ui(lang, `ui.sync.${c.kind}`, v)} → ${ui(lang, `ui.sync.do.${c.action}`)}`;
+}
+function planText(tree, plan, incoming, file, lang, edits) {
+    const shown = file.includes(" ") ? `"${file}"` : file;
+    if (!plan.changes.length)
+        return ui(lang, "ui.sync.nothing", { file: path.basename(file) });
+    return lines(ui(lang, "ui.sync.title", { file: path.basename(file), n: plan.changes.length }), plan.base ? ui(lang, "ui.sync.base", { head: plan.head.slice(0, 8) }) : ui(lang, plan.head ? "ui.sync.headmissing" : "ui.sync.nobase", { head: plan.head?.slice(0, 8) ?? "" }), plan.partial ? ui(lang, "ui.sync.partial") : undefined, plan.identity.strangers.length ? ui(lang, "ui.sync.strangers", { ids: plan.identity.strangers.join(", ") }) : undefined, "", ...plan.changes.map((c) => `  ${changeLine(tree, c, incoming, lang)}`), "", ui(lang, "ui.sync.edits", { mode: ui(lang, edits === "user" ? "ui.sync.mode.user" : "ui.sync.mode.conflict") }), ui(lang, "ui.sync.next", { file: shown }));
+}
+/**
+ * The Strom app sends the tree itself: the bridge started, the app opened with ?send= (installed from a Chromium
+ * browser first, else in such a browser's tab), and the tree waited for. The file it came as, or what to do instead.
+ */
+async function fromApp(ctx, root, lang) {
+    if (!appSendsChanges(ctx.settings))
+        return { text: ui(lang, "ui.sync.nosend") };
+    const info = startLive(root, ctx.env, { current: true });
+    if (!info)
+        throw new StromError("the bridge did not start", { hint: "strom live serve shows why" });
+    const url = sendAppUrl(info.url, ctx.settings);
+    const installed = installedStromApp(ctx.env, process.platform, stromAppUrl(ctx.settings));
+    const webApp = installed?.appId && installed.browser ? { browser: installed.browser, appId: installed.appId, ...(installed.profile ? { profile: installed.profile } : {}) } : undefined;
+    const browser = chromiumBrowser(ctx.env);
+    const since = Date.now();
+    const opened = (webApp && openWebApp(webApp, url, ctx.env)) || (browser && openInBrowser(browser, url, ctx.env));
+    const minutes = Math.max(1, Math.round(Number(ctx.env.STROM_SYNC_WAIT_MS ?? 10 * 60_000) / 60_000));
+    ctx.io.stderr(`${opened ? ui(lang, "ui.sync.wait", { min: minutes }) : ui(lang, "ui.app.url", { url })}\n`);
+    const until = since + Number(ctx.env.STROM_SYNC_WAIT_MS ?? 10 * 60_000);
+    while (Date.now() < until) {
+        const file = receivedSince(root, since);
+        if (file)
+            return { file, text: "" };
+        // the app sends nothing: said at once, not after the whole wait
+        const why = nothingSince(root, since);
+        if (why)
+            return { text: ui(lang, `ui.sync.nothing.${why}`), settled: why !== "no-tree" };
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    return { text: ui(lang, "ui.sync.waited", { min: minutes }) };
+}
+function numbers(v, max) {
+    if (v === undefined)
+        return undefined;
+    const out = new Set();
+    for (const part of String(v).split(/[\s,;]+/).filter(Boolean)) {
+        const m = /^(\d+)(?:-(\d+))?$/.exec(part);
+        if (!m)
+            throw new UsageError(`--only takes numbers of the list, e.g. 1,3,5-7 — not "${part}"`);
+        for (let i = Number(m[1]); i <= Number(m[2] ?? m[1]); i++) {
+            if (i < 1 || i > max)
+                throw new UsageError(`--only: there is no change ${i} (1–${max})`);
+            out.add(i);
+        }
+    }
+    return out;
+}
+register({
+    path: ["sync"],
+    summary: "A family tree coming back (the Strom app, another program): what you changed, into the research — shown first",
+    group: "research",
+    tree: true,
+    writes: true,
+    // the Strom app may take minutes to send the tree: the tree is locked only while a sync is written
+    lock: "sections",
+    description: "Compares the file with the research and shows what it would take: people, facts, names, notes, families and\n" +
+        "children the file has and the research not; facts changed in it; what is no longer in it. A file of the Strom app\n" +
+        "names the state of the research it was given (_STROM_HEAD): only what was changed since then counts as your edit;\n" +
+        "without it (another program, an older export) only additions are taken, differences wait to be picked (--only).\n" +
+        "Nothing is deleted or overwritten: additions are leads citing one source (this sync), a lead is corrected with the\n" +
+        "reason, a change to a fact a record proves is a conflict for you to decide — or, with sync.edits user, your edit\n" +
+        "wins and the record's fact is withdrawn with the reason. A file of another research, or one where few people are\n" +
+        "the research's, is refused. Writes only with --apply; one sync is one commit: strom sync undo I… takes it back.\n" +
+        "--app: the Strom app sends the tree itself — strom opens it (the bridge), the user picks the tree and confirms\n" +
+        "there, strom waits for it and shows what it brings; then strom sync <the file it names> --apply.",
+    args: [{ name: "file", description: "the tree: GEDCOM (.ged) or the Strom app's JSON (none with --app)" }],
+    options: [
+        { name: "app", type: "boolean", description: "straight from the Strom app: it opens, the user sends the tree from it, strom waits for it" },
+        { name: "apply", type: "boolean", description: "write it (without: only show)" },
+        { name: "only", type: "string", value: "<numbers>", description: "with --apply: only these changes of the list (1,3,5-7) — a difference is taken only this way" },
+        { name: "edits", type: "string", value: "<conflict|user>", description: "this once: a change to a fact a record proves is a conflict (default) or your edit wins (setting sync.edits)" },
+        { name: "force", type: "boolean", description: "the file is the research's though few of its people match" },
+        { name: "again", type: "boolean", description: "a file taken in before, once more" },
+    ],
+    examples: ["strom sync ~/Downloads/rodina.ged", "strom sync rodina.ged --apply", "strom sync rodina.json --apply --only 1,4"],
+    async run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        const lang = tree.lang;
+        if (opts.app && args[0])
+            throw new UsageError("--app takes the tree from the Strom app — no file with it");
+        if (!opts.app && !args[0])
+            throw new UsageError("which tree? a file, or --app (straight from the Strom app)", { hint: "strom sync ~/Downloads/rodina.ged · strom sync --app" });
+        if (opts.app && opts.apply)
+            throw new UsageError("--app shows what the tree brings; write it then with the file it names", { hint: "strom sync --app, then strom sync <file> --apply" });
+        let got;
+        if (opts.app) {
+            const r = await fromApp(ctx, tree.root, lang);
+            // nothing to show: the app said so (nothing changed, cancelled) — or never answered, or has no tree of this research
+            if (!r.file)
+                return { text: r.text, data: { received: null }, exitCode: r.settled ? EXIT.ok : EXIT.needsInput };
+            got = r.file;
+        }
+        const shownAs = got ? ctx.display(got) : args[0];
+        const file = got ?? ctx.resolvePath(args[0]);
+        if (!fs.existsSync(file) || !fs.statSync(file).isFile())
+            throw new UsageError(`no such file: ${args[0]}`);
+        const edits = opts.edits === undefined ? ctx.settings.syncEdits(tree.config) : String(opts.edits);
+        if (edits !== "conflict" && edits !== "user")
+            throw new UsageError("--edits is conflict or user");
+        const sha = fileSha256(file);
+        const before = tree.list("input").find((i) => i.sha === sha && i.sync && !i.sync.undone);
+        if (before && !opts.again)
+            return { text: ui(lang, "ui.sync.again", { input: before.id }), data: { input: before.id, changes: [] } };
+        const incoming = readTreeFile(file);
+        const plan = planSync(tree, incoming, edits, { force: !!opts.force });
+        if (!opts.apply || !plan.changes.length || tree.dryRun) {
+            if (opts.only !== undefined && !opts.apply)
+                throw new UsageError("--only goes with --apply");
+            return {
+                text: lines(got ? ui(lang, "ui.sync.got") : undefined, planText(tree, plan, incoming, shownAs, lang, edits)),
+                data: { ...(got ? { received: got } : {}), base: plan.base, head: plan.head ?? null, partial: plan.partial, changes: plan.changes, strangers: plan.identity.strangers },
+            };
+        }
+        const only = numbers(opts.only, plan.changes.length);
+        let input;
+        let applied = 0;
+        tree.withTreeLock(() => {
+            // what another process wrote meanwhile counts: the changes again, now that the tree is ours
+            const fresh = planSync(tree, readTreeFile(file), edits, { force: !!opts.force });
+            if (fresh.changes.length !== plan.changes.length || fresh.changes.some((c, i) => c.kind !== plan.changes[i].kind || c.person !== plan.changes[i].person))
+                throw new UsageError("the research changed while this was shown — look again", { hint: `strom sync ${args[0] ?? file}` });
+            const id = tree.peekId("I");
+            const size = fs.statSync(file).size;
+            const stored = size <= MAX_IN_TREE ? `inputs/${id}-${safeFolderName(path.basename(file))}` : undefined;
+            if (stored) {
+                tree.remember(path.join(tree.root, stored));
+                fs.mkdirSync(path.join(tree.root, "inputs"), { recursive: true });
+                fs.copyFileSync(file, path.join(tree.root, stored));
+            }
+            input = create(tree, "input", { name: path.basename(file), ...(stored ? { file: stored } : {}), sha, size, mime: mimeOf(file), from: ctx.display(file), kind: "tree", state: "processed" }, (iid) => `+${iid} input tree "${truncate(path.basename(file), 50)}" (sync)`);
+            const day = humanDay(now(), lang);
+            const source = create(tree, "source", {
+                kind: "family-tree",
+                title: ui(lang, incoming.treeId || plan.identity.matched ? "ui.sync.source.app" : "ui.sync.source.file", { file: path.basename(file), day }),
+                input: input.id,
+                information: "secondary",
+                form: "authored",
+            }, (sid) => `+${sid} source "${path.basename(file)}" (sync)`);
+            const { applied: done, changes } = applySync(tree, plan, incoming, source, only);
+            applied = changes;
+            input = update(tree, input.id, "input", (i) => ({ ...i, source: source.id, sync: { ...(plan.head ? { head: plan.head } : {}), edits: edits, applied: done } }), {
+                op: "input.sync",
+                summary: `${input.id} synced: ${changes} change(s)${plan.head ? ` against ${plan.head.slice(0, 8)}` : ""}`,
+            });
+        });
+        return {
+            text: lines(...tree.written.map((o) => o.summary), "", ui(lang, "ui.sync.done", { n: applied, file: path.basename(file), input: input.id })),
+            data: { input: input.id, applied: input.sync?.applied ?? [], changes: plan.changes },
+        };
+    },
+}, {
+    path: ["sync", "undo"],
+    summary: "Take a sync back: what it added withdrawn, what it corrected put back, its conflicts closed",
+    group: "research",
+    tree: true,
+    writes: true,
+    args: [{ name: "input", description: "the sync's input (I…), as strom sync said", required: true }],
+    examples: ["strom sync undo I0002"],
+    run(ctx, { args }) {
+        const tree = ctx.tree();
+        const id = args[0].toUpperCase().replace(/^I?(\d+)$/, (_, n) => `I${n.padStart(4, "0")}`);
+        const input = tree.get(id);
+        if (!input || input.type !== "input" || !input.sync)
+            throw new UsageError(`${args[0]} is not a sync`, { hint: "strom input list — a sync's input says so" });
+        if (input.sync.undone)
+            return { text: ui(tree.lang, "ui.sync.wasundone", { input: id }), data: { input: id, undone: 0 } };
+        let n = 0;
+        tree.withTreeLock(() => {
+            n = undoSync(tree, input);
+            update(tree, id, "input", (i) => ({ ...i, sync: { ...i.sync, undone: now() } }), { op: "input.sync.undo", summary: `${id} sync undone: ${n} step(s)` });
+        });
+        return { text: lines(...tree.written.map((o) => o.summary), "", ui(tree.lang, "ui.sync.undone", { input: id, n })), data: { input: id, undone: n } };
+    },
+});

package/dist/core/config.js

@@ -44,6 +44,7 @@ export const SETTINGS = [
     { key: "queue.strategy", env: "STROM_QUEUE_STRATEGY", tree: true, kind: "choice", choices: STRATEGIES, description: "order of the task queue: balanced (default — nearest ancestors first, spread over the lines, nothing taken forever), depth (stay on one line), priority (strict priority)" },
     { key: "gedcom.for", env: "STROM_GEDCOM_FOR", tree: true, kind: "choice", choices: ["both", "standard", "strom"], description: "GEDCOM files written: both (default), standard (any program), strom (the Strom app)" },
     { key: "stories", env: "STROM_STORIES", tree: true, kind: "choice", choices: ["yes", "no"], description: "stories of the ancestors for the family, written from the facts: yes (default — strom proposes one once a person's life is told by records), no — the user is told when the research starts and may say no" },
+    { key: "sync.edits", env: "STROM_SYNC_EDITS", tree: true, kind: "choice", choices: ["conflict", "user"], description: "your edits in the Strom app (or another program's file) to a fact a record proves, taken by strom sync: conflict (default — the research keeps the record's, a conflict for you to decide) or user (your edit wins, the record's fact is withdrawn with the reason)" },
     { key: "main.person", env: "STROM_MAIN_PERSON", tree: true, kind: "person", description: "the main person of the tree (P…): first in the GEDCOM files — the Strom app opens on them (default: the nearest person descended from every research's focus, else the first research's focus)" },
     { key: "excerpts.quality", env: "STROM_EXCERPTS_QUALITY", tree: true, kind: "choice", choices: EXCERPT_QUALITIES, description: "the entries cut out of their scans in the file for the Strom app (output/tree-strom.ged): small (1000 px, grey — half the size), normal (default, 1200 px), sharp (1600 px)" },
     { key: "excerpts.for", env: "STROM_EXCERPTS_FOR", tree: true, kind: "choice", choices: EXCERPT_SCOPES, description: "whose entries get their image in the Strom app: none (the file without images), line (the ancestors), family (default: the ancestors and their families), connected (anyone linked to them), all" },
@@ -359,6 +360,10 @@ export class Settings {
         const v = this.resolve("stories", tree)?.value;
         return { on: v !== "no", said: v === "yes" || v === "no" };
     }
+    /** strom sync: whether the user's edit to a fact a record proves wins, or becomes a conflict. */
+    syncEdits(tree) {
+        return this.resolve("sync.edits", tree)?.value === "user" ? "user" : "conflict";
+    }
     /** The images for the Strom app: how sharp, whose, and the limit of all together (MB). */
     excerpts(tree) {
         return {

package/dist/core/frontier.js

@@ -102,7 +102,7 @@ export function taskRecordsets(tree, task) {
  * 25 years before their marriage, else about 28 before their eldest known child —
  * where that happened. An estimate widens the years a search has to cover.
  */
-function birthEstimate(tree, p, lang) {
+export function birthEstimate(tree, p, lang) {
     const own = birthEvent(p);
     const ownYear = own?.date ? dateYears(own.date)[0] : undefined;
     if (ownYear && own?.place)
@@ -132,6 +132,15 @@ export function researchPeople(tree, research) {
         return ancestorGenerations(tree, research.focus, research.limits?.generations ?? 50);
     if (research.direction !== "person")
         return new Map();
+    // a review of several people; of the people without a record of their own: each until one proves them
+    if (research.review?.people) {
+        const unproven = !!research.review.unproven;
+        const proven = (p) => p.events.some((e) => !e.retracted && (e.status === "proven" || e.status === "probable"));
+        return new Map(research.review.people
+            .map((id) => tree.get(id))
+            .filter((p) => p?.type === "person" && !p.retracted && !(unproven && proven(p)))
+            .map((p) => [p.id, 1]));
+    }
     const scope = research.review?.scope ?? "person";
     if (scope === "line")
         return ancestorGenerations(tree, research.focus, research.limits?.generations ?? 50);

package/dist/core/live.js

@@ -10,6 +10,9 @@
 //   GET <token>/tree.ged   the tree for the Strom app, as it is now, each entry with its image (the settings excerpts.*)
 //   GET <token>/images.ged the same (the address an older strom gave)
 //   GET <token>/events     server-sent events: hello, change, working
+//   POST <token>/sync      the Strom app sends the user's edited tree back (?send=): kept to be shown
+//                          and written on the user's word (strom sync) — nothing of the research changes
+//   POST <token>/cancel    …or says it sends nothing ({"reason": "unchanged" | "cancelled" | "no-tree"})
 //
 // Only pages of the Strom app may read it (CORS: https://stromapp.info, its beta, and a
 // local copy on localhost for its development), and a browser asks first
@@ -22,6 +25,8 @@ import { spawn, spawnSync } from "node:child_process";
 import { Tree, VERSION } from "./tree.js";
 import { exportGedcom } from "../gedcom/export.js";
 import { excerptSettings, planExcerpts } from "./excerpt.js";
+import { noteNothingSent, receiveTree, SYNC_MAX_BYTES } from "./sync.js";
+import { ui } from "../cli/ui.js";
 /** New images for the app, made for at most so long when the tree changed (the rest the next time). */
 const LIVE_IMAGES_MS = 20_000;
 import { liveWorkers } from "./workers.js";
@@ -153,7 +158,7 @@ export function serveLive(root, env) {
         }
         if (req.method === "OPTIONS") {
             if (origin) {
-                res.setHeader("Access-Control-Allow-Methods", "GET");
+                res.setHeader("Access-Control-Allow-Methods", "GET, POST");
                 res.setHeader("Access-Control-Allow-Headers", String(req.headers["access-control-request-headers"] ?? ""));
                 if (req.headers["access-control-request-private-network"])
                     res.setHeader("Access-Control-Allow-Private-Network", "true");
@@ -162,6 +167,14 @@ export function serveLive(root, env) {
             return;
         }
         const [, t, what] = (req.url ?? "").split("?")[0].split("/");
+        if (req.method === "POST" && t === token && what === "sync") {
+            receive(req, res, origin);
+            return;
+        }
+        if (req.method === "POST" && t === token && what === "cancel") {
+            nothing(req, res, origin);
+            return;
+        }
         if (req.method !== "GET" || t !== token) {
             res.writeHead(404).end();
             return;
@@ -177,7 +190,7 @@ export function serveLive(root, env) {
                     // the images from the cache; new ones made for a while at most (the rest the next time the tree changes)
                     const set = excerptSettings(tree);
                     const images = set ? planExcerpts(tree, set.shared, { quality: set.quality, for: set.for, maxBytes: set.mb * 1024 * 1024, budgetMs: LIVE_IMAGES_MS }) : undefined;
-                    ged = { head: h, text: exportGedcom(tree, { for: "strom", ...(images ? { excerpts: images.of } : {}) }).text };
+                    ged = { head: h, text: exportGedcom(tree, { for: "strom", ...(h ? { head: h } : {}), ...(images ? { excerpts: images.of } : {}) }).text };
                 }
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "X-Strom-Head": h }).end(ged.text);
             }
@@ -194,6 +207,70 @@ export function serveLive(root, env) {
             res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" }).end(e.message);
         }
     });
+    /** The user's tree from the app: only from its pages, only so large; the answer in the research's language. */
+    const receive = (req, res, origin) => {
+        const reply = (code, body) => res.writeHead(code, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(JSON.stringify(body));
+        const lang = () => {
+            try {
+                return Tree.open(root, env).lang;
+            }
+            catch {
+                return "en";
+            }
+        };
+        if (!origin) {
+            reply(403, { error: "only the Strom app may send a tree here" });
+            return;
+        }
+        const chunks = [];
+        let size = 0;
+        let over = false;
+        req.on("data", (c) => {
+            size += c.length;
+            if (size > SYNC_MAX_BYTES)
+                over = true;
+            else
+                chunks.push(c);
+        });
+        req.on("end", () => {
+            if (over) {
+                reply(413, { error: ui(lang(), "ui.sync.bridge.large") });
+                return;
+            }
+            try {
+                const got = receiveTree(root, env, Buffer.concat(chunks).toString("utf8"));
+                reply(200, { ok: true, changes: got.changes, file: path.basename(got.file) });
+            }
+            catch (e) {
+                const m = e.message;
+                const key = /another research/.test(m) ? "ui.sync.bridge.other" : /does not look like/.test(m) ? "ui.sync.bridge.foreign" : /empty|no people|not a GEDCOM/.test(m) ? "ui.sync.bridge.empty" : undefined;
+                reply(400, { error: key ? ui(lang(), key) : m });
+            }
+        });
+    };
+    /** The app sends nothing (unchanged, the user said no, no tree of this research): strom sync --app stops waiting. */
+    const nothing = (req, res, origin) => {
+        const reply = (code, body) => res.writeHead(code, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }).end(JSON.stringify(body));
+        if (!origin) {
+            reply(403, { error: "only the Strom app may say so" });
+            return;
+        }
+        let body = "";
+        req.on("data", (c) => {
+            if (body.length < 4096)
+                body += c.toString("utf8");
+        });
+        req.on("end", () => {
+            let reason = "cancelled";
+            try {
+                reason = String(JSON.parse(body).reason ?? reason);
+            }
+            catch {
+                reason = body.trim() || reason;
+            }
+            reply(200, { ok: true, reason: noteNothingSent(root, reason) });
+        });
+    };
     return new Promise((resolve) => {
         server.listen(0, "127.0.0.1", () => {
             const port = server.address().port;

package/dist/core/phrases.js

@@ -32,6 +32,7 @@ export const PHRASES = {
     "story.why": "{count} facts from records tell the life (generation {generation} of {research}); the family reads it in the Strom app's family book",
     "story.done": "strom story set {id} with every fact it rests on (--fact) — a draft until the user approves it",
     "review.research": "Review of {name}",
+    "review.unproven.research": "People without a record of their own",
     "review.more": " (and {count} more after these)",
     "review.mentions.what": "What the tree already says of {name} outside their data: {list}{more}",
     "review.mentions.why": "records, notes or the diary name {name}, yet their data do not show it — the cheapest finds of a review ({research})",

package/dist/core/review.js

@@ -7,7 +7,7 @@
 // Each kind is at most one task per person at a time, and what a task of that
 // kind took up is never proposed again.
 import { dateYears } from "./gdate.js";
-import { RECORD_KINDS, recordsetsCovering, researchPeople } from "./frontier.js";
+import { birthEstimate, RECORD_KINDS, recordsetsCovering, researchPeople } from "./frontier.js";
 import { birthEvent, displayName, familiesAsPartner, lifespan } from "./people.js";
 import { phrase } from "./phrases.js";
 import { foldText } from "./text.js";
@@ -55,6 +55,11 @@ function citedFor(tree, p) {
     for (const n of p.names)
         for (const c of n.citations ?? [])
             out.add(c.source);
+    // the record naming a family — a child's baptism names its parents — also without a fact of the family
+    for (const f of tree.list("family"))
+        if (!f.retracted && (f.partners.includes(p.id) || f.children.some((c) => c.person === p.id)))
+            for (const c of f.citations ?? [])
+                out.add(c.source);
     for (const other of tree.list("person"))
         for (const e of other.events)
             if (e.participants?.some((x) => x.person === p.id))
@@ -67,6 +72,36 @@ function citedFor(tree, p) {
                     out.add(c.source);
     return out;
 }
+/**
+ * The people no record of their own proves: not one fact of theirs proven or
+ * probable — the living among them marked. Each with how they stand — a record names them elsewhere, their
+ * facts are only leads, or nothing but a note says where they come from.
+ */
+export function unprovenPeople(tree) {
+    const out = [];
+    for (const p of tree.list("person")) {
+        if (p.retracted)
+            continue;
+        const facts = p.events.filter((e) => !e.retracted && e.status !== "retracted" && e.status !== "disproven");
+        if (facts.some((e) => e.status === "proven" || e.status === "probable"))
+            continue;
+        const sources = [...citedFor(tree, p)];
+        const kind = facts.some((e) => e.citations.length) ? "leads" : sources.length ? "named" : "none";
+        out.push({ person: p, kind, sources, living: livingBorn(tree, p) !== undefined });
+    }
+    return out;
+}
+/**
+ * Most likely alive: born (or, by their marriage or eldest child, about) less than DEATH_AFTER_YEARS ago, and no
+ * death recorded — the year, else undefined. Their records are the family's; the registers of those years are
+ * mostly closed.
+ */
+export function livingBorn(tree, p) {
+    if (p.events.some((e) => !e.retracted && e.status !== "disproven" && DEATHS.has(e.kind)))
+        return undefined;
+    const born = birthEstimate(tree, p, tree.lang).year;
+    return born !== undefined && born > new Date().getFullYear() - DEATH_AFTER_YEARS ? born : undefined;
+}
 /** The models that read each source: the sessions that recorded or corrected it (the user's hand counts as "user"). */
 export function readersOf(tree) {
     const model = new Map(tree.list("session").map((s) => [s.id, s.model ?? "unknown"]));
@@ -207,10 +242,13 @@ export function reviewProposals(tree, research) {
         };
         propose("mentions", "enrich", mentionsOf(tree, p, citedFor(tree, p)));
         propose("entries", "enrich", entriesOf(tree, p));
-        const single = singleReadings(tree, p);
-        propose("verify", "verify", single);
-        if (reread && readers)
-            propose("reread", "verify", rereads(tree, p, reread, readers).filter((e) => !single.includes(e)), { model: reread });
+        // the people without a record want one of their own first: checking what their family's facts rest on can wait
+        if (!research.review?.unproven) {
+            const single = singleReadings(tree, p);
+            propose("verify", "verify", single);
+            if (reread && readers)
+                propose("reread", "verify", rereads(tree, p, reread, readers).filter((e) => !single.includes(e)), { model: reread });
+        }
         propose("conflicts", "verify", openConflicts(tree, p));
         out.push(...gaps(tree, research, p, name, tasks));
     }

package/dist/core/self.js

@@ -33,6 +33,23 @@ export function installation() {
     }
     return (cached = { kind: "npm" });
 }
+/**
+ * Another strom on disk than the one running (strom update replaced its code or its Node): this process goes on
+ * with what it loaded, so a person is told to start strom again. `version`: the running one's.
+ */
+export function replacedOnDisk(version) {
+    const inst = installation();
+    if (inst.kind !== "installed" || !inst.root)
+        return false;
+    try {
+        const app = JSON.parse(fs.readFileSync(path.join(inst.root, "app", "package.json"), "utf8"));
+        const info = JSON.parse(fs.readFileSync(path.join(inst.root, "install.json"), "utf8"));
+        return app.version !== version || info.node !== inst.node;
+    }
+    catch {
+        return false;
+    }
+}
 /** The program and arguments that run strom: this Node and its entry script (cli.ts from sources, cli.js built). */
 export function stromLauncher() {
     const cli = path.resolve(path.dirname(here), "..", here.endsWith(".ts") ? "cli.ts" : "cli.js");

package/dist/core/stromapp.js

@@ -30,6 +30,19 @@ export const APP_OPENS_RESEARCH = true;
 export function appOpensResearch(settings) {
     return APP_OPENS_RESEARCH || stromAppUrl(settings) !== STROM_APP_URL;
 }
+/**
+ * The Strom app sends the user's edits back (?send=<the bridge>, POST <bridge>/sync — the app's spec
+ * docs/ZADANI_SYNC_Z_APLIKACE.md): the first version of stromapp.info that does (3.3.0, 2026-09-27).
+ * Another copy of the app (its beta, its development: strom.app.url) is taken as current.
+ */
+export const APP_SENDS_CHANGES = "3.3.0";
+export function appSendsChanges(settings) {
+    return APP_SENDS_CHANGES !== undefined || stromAppUrl(settings) !== STROM_APP_URL;
+}
+/** 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)}`;
+}
 /** The address that opens the Strom app following a research through its bridge. */
 export function liveAppUrl(bridge, settings) {
     return `${stromAppUrl(settings)}?live=${encodeURIComponent(bridge)}`;