strom-research 1.0.0

package/dist/core/deps.js

@@ -0,0 +1,73 @@
+// What strom needs on the computer besides itself, and how it gets it with the
+// user's yes (strom doctor --fix, the setup wizard): git above all.
+//
+//   Windows  strom's own git — MinGit, the official portable Git for Windows,
+//            downloaded, checked against its SHA-256 and unpacked into strom's
+//            folder; for strom only: no admin, no installer, nothing on PATH
+//   macOS    Apple's command line tools (git comes with them): a window of the
+//            system installs them
+//   Linux    the package manager — sudo is the user's; strom says the command
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { gitProgram, ownGitDir, resetCache } from "./git.js";
+/** The MinGit strom installs (from git-for-windows' releases on GitHub). */
+export const MINGIT = {
+    version: "2.55.0.5",
+    url: "https://github.com/git-for-windows/git/releases/download/v2.55.0.windows.5/MinGit-2.55.0.5-64-bit.zip",
+    sha256: "56d7b226b7693196cfc71fef26568f536c4a021ab6c37ff2db4287bed908e96e",
+    mb: 39,
+};
+export function gitWay(platform = process.platform) {
+    return platform === "win32" ? "download" : platform === "darwin" ? "window" : "command";
+}
+/** The command a Linux user runs (their package manager). */
+export function linuxGitCommand() {
+    for (const [pm, cmd] of [
+        ["apt-get", "sudo apt install git"],
+        ["dnf", "sudo dnf install git"],
+        ["pacman", "sudo pacman -S git"],
+        ["zypper", "sudo zypper install git"],
+    ])
+        if (spawnSync("sh", ["-c", `command -v ${pm}`], { stdio: "ignore" }).status === 0)
+            return cmd;
+    return "sudo apt install git";
+}
+/** Windows: download MinGit into strom's folder. True when git works after it. */
+export async function installOwnGit(env, say) {
+    if (env.STROM_NO_INSTALL === "1")
+        return false;
+    const dir = ownGitDir(env);
+    const part = `${dir}.part`;
+    const zip = `${dir}.zip`;
+    try {
+        const res = await fetch(MINGIT.url);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const data = Buffer.from(await res.arrayBuffer());
+        const got = crypto.createHash("sha256").update(data).digest("hex");
+        if (got !== MINGIT.sha256)
+            throw new Error("the download is damaged (checksum mismatch)");
+        fs.mkdirSync(path.dirname(dir), { recursive: true });
+        fs.writeFileSync(zip, data);
+        fs.rmSync(part, { recursive: true, force: true });
+        fs.mkdirSync(part, { recursive: true });
+        // Windows 10 and later have tar, which unpacks a zip.
+        const r = spawnSync("tar", ["-xf", zip, "-C", part], { stdio: "ignore", windowsHide: true });
+        if (r.status !== 0)
+            throw new Error("could not unpack it");
+        fs.rmSync(dir, { recursive: true, force: true });
+        fs.renameSync(part, dir);
+    }
+    catch (e) {
+        say(e.message);
+        return false;
+    }
+    finally {
+        fs.rmSync(zip, { force: true });
+        fs.rmSync(part, { recursive: true, force: true });
+    }
+    resetCache();
+    return Boolean(gitProgram(env));
+}

package/dist/core/dialog.js

@@ -0,0 +1,61 @@
+// A yes/no question in a window of the operating system. Consents are the
+// user's: from inside an agent's session strom cannot tell whether the user or
+// the agent typed a command, but a window on the screen is answered by the
+// person in front of it — the agent neither sees it nor clicks it. So the user
+// never has to leave the conversation for a terminal of their own.
+import { spawnSync } from "node:child_process";
+import { which } from "./which.js";
+/** How long the window waits for an answer before it counts as a no. */
+const WAIT_SECONDS = 300;
+/** AppleScript string literal. */
+function appleString(s) {
+    return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/** PowerShell single-quoted string literal. */
+function psString(s) {
+    return `'${s.replace(/'/g, "''")}'`;
+}
+/**
+ * Ask in a window: true (yes), false (no, closed or no answer in time), or
+ * undefined when this computer cannot show one (no desktop, no dialog tool).
+ */
+export function systemDialog(text, env, platform = process.platform) {
+    // A test run, or a user who wants their consents in a terminal only.
+    if (env.STROM_NO_DIALOG === "1")
+        return undefined;
+    const run = (cmd, args) => spawnSync(cmd, args, { encoding: "utf8", timeout: (WAIT_SECONDS + 10) * 1000, windowsHide: false, env: env });
+    if (platform === "darwin") {
+        const script = `display dialog ${appleString(text.question)} with title ${appleString(text.title)} ` +
+            `buttons {${appleString(text.no)}, ${appleString(text.yes)}} default button ${appleString(text.no)} ` +
+            `cancel button ${appleString(text.no)} with icon caution giving up after ${WAIT_SECONDS}`;
+        const r = run("osascript", ["-e", script]);
+        if (r.error)
+            return undefined;
+        return r.status === 0 && r.stdout.includes(`button returned:${text.yes}`) && !r.stdout.includes("gave up:true");
+    }
+    if (platform === "win32") {
+        const ps = "Add-Type -AssemblyName PresentationFramework; " +
+            `$r = [System.Windows.MessageBox]::Show(${psString(text.question)}, ${psString(text.title)}, 'YesNo', 'Warning', 'No', 'DefaultDesktopOnly'); ` +
+            "Write-Output $r";
+        const r = run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps]);
+        if (r.error || r.status !== 0)
+            return undefined;
+        return r.stdout.trim() === "Yes";
+    }
+    // Linux and others: only with a desktop and a dialog tool.
+    if (!env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return undefined;
+    if (which("zenity", env)) {
+        const r = run("zenity", ["--question", "--title", text.title, "--text", text.question, "--ok-label", text.yes, "--cancel-label", text.no, "--timeout", String(WAIT_SECONDS)]);
+        if (r.error)
+            return undefined;
+        return r.status === 0;
+    }
+    if (which("kdialog", env)) {
+        const r = run("kdialog", ["--title", text.title, "--yesno", text.question, "--yes-label", text.yes, "--no-label", text.no]);
+        if (r.error)
+            return undefined;
+        return r.status === 0;
+    }
+    return undefined;
+}

package/dist/core/errors.js

@@ -0,0 +1,89 @@
+// Error types with stable exit codes. Every error carries an optional hint:
+// the exact command the caller (usually an agent) should run next.
+export const EXIT = {
+    ok: 0,
+    error: 1,
+    usage: 2,
+    needsInput: 3,
+    needsConsent: 4,
+    locked: 5,
+};
+export class StromError extends Error {
+    exitCode;
+    hint;
+    details;
+    constructor(message, opts = {}) {
+        super(message);
+        this.name = "StromError";
+        this.exitCode = opts.exitCode ?? EXIT.error;
+        this.hint = opts.hint;
+        this.details = opts.details;
+    }
+    toJSON() {
+        const out = { status: "error", message: this.message };
+        if (this.hint)
+            out.hint = this.hint;
+        if (this.details !== undefined)
+            out.details = this.details;
+        return out;
+    }
+}
+/** Invalid arguments or an ambiguous reference. */
+export class UsageError extends StromError {
+    constructor(message, opts = {}) {
+        super(message, { ...opts, exitCode: EXIT.usage });
+        this.name = "UsageError";
+    }
+}
+/** A name matched more than one record. Never pick one silently. */
+export class AmbiguousError extends StromError {
+    candidates;
+    constructor(query, candidates) {
+        super(`"${query}" matches ${candidates.length} records`, {
+            exitCode: EXIT.usage,
+            hint: "use the ID instead of the name",
+            details: { candidates },
+        });
+        this.name = "AmbiguousError";
+        this.candidates = candidates;
+    }
+    toJSON() {
+        return { status: "ambiguous", message: this.message, hint: this.hint, candidates: this.candidates };
+    }
+}
+/** A setting is missing and there is no TTY to ask. */
+export class NeedsInputError extends StromError {
+    needs;
+    constructor(needs) {
+        super(`missing setting: ${needs.map((n) => n.key).join(", ")}`, {
+            exitCode: EXIT.needsInput,
+            hint: needs.map((n) => n.set).join("\n"),
+        });
+        this.name = "NeedsInputError";
+        this.needs = needs;
+    }
+    toJSON() {
+        return { status: "needs-input", needs: this.needs };
+    }
+}
+/** A human must grant consent on a terminal. Agents must never grant it. */
+export class NeedsConsentError extends StromError {
+    needs;
+    constructor(needs) {
+        super(`consent required — ${needs.map((n) => n.question).join(" · ")}`, {
+            exitCode: EXIT.needsConsent,
+            hint: `ask the user to run in their own terminal: ${needs.map((n) => n.set).join(" ; ")}`,
+        });
+        this.name = "NeedsConsentError";
+        this.needs = needs;
+    }
+    toJSON() {
+        return { status: "needs-consent", needs: this.needs, hint: this.hint };
+    }
+}
+export class LockedError extends StromError {
+    constructor(message, hint) {
+        super(message, { exitCode: EXIT.locked, ...(hint ? { hint } : {}) });
+        this.name = "LockedError";
+    }
+}

package/dist/core/evidence.js

@@ -0,0 +1,58 @@
+// Two different questions, kept apart:
+//
+//   How good is this evidence?   — a property of one citation: the source
+//     (original / derivative / authored) and its information for this fact
+//     (primary: written at the time by someone who knew; secondary; unknown).
+//     GEDCOM carries it as QUAY on the citation.
+//   How sure is the conclusion?  — the status of the fact (proven … lead),
+//     drawn from all of its evidence.
+//
+// The status may not claim more than the evidence gives: a family tree or a
+// memory never proves anything, and "proven" needs a record with primary
+// information for the fact.
+import { UsageError } from "./errors.js";
+/** Sources that are leads by nature: compiled by someone, not a record of the event. */
+export function isWeak(src) {
+    return !src || src.kind === "family-tree" || src.kind === "family-memory" || src.form === "authored";
+}
+/** The information of a source for one fact: the citation's own assessment wins. */
+export function informationOf(src, c) {
+    return c.information ?? src?.information ?? "unknown";
+}
+/**
+ * GEDCOM 5.5.1 QUAY of one citation: 3 direct and primary, 2 secondary
+ * (recorded later), 1 questionable reliability, 0 unreliable or estimated.
+ */
+export function quay(src, c) {
+    if (!src || src.kind === "family-tree" || src.kind === "family-memory")
+        return 0;
+    if (src.form === "authored")
+        return 1;
+    const info = informationOf(src, c);
+    if (src.form === "original")
+        return info === "primary" ? 3 : 2;
+    return info === "primary" ? 2 : 1; // derivative: a copy, an index, a transcript
+}
+/** The status a fact gets when none is given. */
+export function defaultStatus(tree, citations) {
+    if (citations.length === 0)
+        return "lead";
+    return citations.some((c) => !isWeak(tree.get(c.source))) ? "probable" : "lead";
+}
+/** Refuse a status the evidence cannot carry, with what to do instead. */
+export function checkStatus(tree, status, citations) {
+    if (status !== "proven" && status !== "probable")
+        return;
+    if (citations.length === 0)
+        throw new UsageError(`status ${status} needs a citation`, { hint: 'cite the record: --cite S0001 --locator "fol. 12" (or keep it a lead: --status lead)' });
+    const strong = citations.filter((c) => !isWeak(tree.get(c.source)));
+    if (strong.length === 0)
+        throw new UsageError(`a family tree, a memory or a compiled work cannot make a fact ${status}`, {
+            hint: "keep it a lead (or --status possible) until a record says it: cite that record",
+        });
+    if (status === "proven" && !strong.some((c) => informationOf(tree.get(c.source), c) === "primary"))
+        throw new UsageError("proven needs a record written at the time by someone who knew (primary information)", {
+            hint: "if the record is like that: --information primary on the citation (or the source); otherwise --status probable",
+        });
+}
+export const INFORMATION = ["primary", "secondary", "unknown"];

package/dist/core/frontier.js

@@ -0,0 +1,219 @@
+// The frontier of a research: the people in scope whose parents are not yet
+// proven. For searching ancestors the next step is derivable, so strom
+// proposes the tasks itself instead of hoping an agent remembers to.
+import { dateYears } from "./gdate.js";
+import { ancestorGenerations, birthEvent, displayName, familiesAsChild, familiesAsPartner, isBirthFamily, lifespan } from "./people.js";
+import { foldText } from "./text.js";
+import { phrase } from "./phrases.js";
+const OPEN_STATES = new Set(["open", "doing", "parked", "waiting"]);
+const FINISHED_STATES = new Set(["done", "dropped"]);
+const FRONTIER_LEVELS = new Set(["locate", "link", "request"]);
+function birthRecordProven(p) {
+    return p.events.some((e) => ["BIRT", "CHR", "BAPM"].includes(e.kind) && (e.status === "proven" || e.status === "probable") && !e.retracted);
+}
+/** The kinds of record set in which an event of this kind is written down. */
+const RECORD_KINDS = {
+    BIRT: ["baptism", "birth"],
+    CHR: ["baptism", "birth"],
+    BAPM: ["baptism", "birth"],
+    MARR: ["marriage"],
+    MARB: ["marriage"],
+    ENGA: ["marriage"],
+    DEAT: ["burial", "death"],
+    BURI: ["burial", "death"],
+};
+const GENERAL_KINDS = ["church", "civil"];
+/** Is `name` the place `place` names? "Vavřinec čp. 13" and "Vavřinec, Blansko" are in Vavřinec. */
+function inPlace(place, name) {
+    const n = foldText(name);
+    return !!n && (place === n || place.startsWith(n + " ") || place.startsWith(n + ","));
+}
+/** Record sets that could hold an event of these kinds at `place` around `year`. */
+function recordsetsCovering(tree, place, year, kinds) {
+    if (!place)
+        return [];
+    const key = foldText(place);
+    // Names of the place and of the parishes it belonged to.
+    const names = [key];
+    for (const pl of tree.list("place"))
+        if (pl.names.some((n) => inPlace(key, n.name)))
+            for (const j of pl.jurisdictions)
+                if (!year || ((!j.from || j.from <= year) && (!j.to || j.to >= year)))
+                    names.push(foldText(j.name));
+    return tree.list("recordset").filter((b) => {
+        if (b.kinds.length && !b.kinds.some((k) => kinds.includes(k) || GENERAL_KINDS.includes(k)))
+            return false;
+        if (!b.places.some((pl) => names.some((n) => inPlace(n, pl))))
+            return false;
+        if (!year || !b.years)
+            return true;
+        const [from, to] = b.years.split("-").map(Number);
+        return year >= from - 2 && year <= (to ?? from) + 2;
+    });
+}
+/** Record sets that could hold the birth/baptism of someone born at `place` around `year`. */
+function candidateRecordsets(tree, place, year) {
+    return recordsetsCovering(tree, place, year, RECORD_KINDS.BIRT);
+}
+/**
+ * The record sets a task works in: those in its `where`. A task written before
+ * the books were known names none; then the ones its text mentions (B…), else
+ * the ones covering an event of its people in a year the task mentions
+ * ("Baptism of František 18 Oct 1862" → the baptisms of his birthplace in 1862).
+ */
+export function taskRecordsets(tree, task) {
+    const get = (id) => {
+        const b = tree.get(id);
+        return b?.type === "recordset" ? b : undefined;
+    };
+    const named = task.where.map(get).filter((b) => !!b);
+    if (named.length)
+        return { sets: named, guessed: false };
+    const text = [task.what, ...task.where, task.why, task.doneWhen, ...task.notes.map((n) => n.text)].join(" ");
+    const mentioned = [...new Set(text.match(/\bB\d{4,}\b/g) ?? [])].map(get).filter((b) => !!b);
+    if (mentioned.length)
+        return { sets: mentioned, guessed: true };
+    const years = dateYears(text);
+    const found = new Map();
+    for (const id of task.subject) {
+        const p = tree.get(id);
+        if (p?.type !== "person")
+            continue;
+        for (const e of [...p.events, ...familiesAsPartner(tree, id).flatMap((f) => f.events)]) {
+            const kinds = RECORD_KINDS[e.kind];
+            if (!kinds || e.retracted || !e.date)
+                continue;
+            const span = dateYears(e.date);
+            if (!span.length)
+                continue;
+            const lo = Math.min(...span);
+            const hi = Math.max(...span);
+            const year = years.find((y) => y >= lo && y <= hi);
+            if (year === undefined)
+                continue;
+            for (const b of recordsetsCovering(tree, e.place, year, kinds))
+                found.set(b.id, b);
+        }
+    }
+    return { sets: [...found.values()], guessed: true };
+}
+/**
+ * When and where a person was born, if only roughly: their own birth, else about
+ * 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) {
+    const own = birthEvent(p);
+    const ownYear = own?.date ? dateYears(own.date)[0] : undefined;
+    if (ownYear && own?.place)
+        return { year: ownYear, place: own.place };
+    const fams = familiesAsPartner(tree, p.id);
+    const marr = fams.flatMap((f) => f.events).find((e) => e.kind === "MARR" && !e.retracted && e.date);
+    const marrYear = marr?.date ? dateYears(marr.date)[0] : undefined;
+    const kids = fams
+        .flatMap((f) => f.children.map((c) => tree.get(c.person)))
+        .map((k) => ({ k, b: k ? birthEvent(k) : undefined }))
+        .map(({ k, b }) => ({ k, b, year: b?.date ? dateYears(b.date)[0] : undefined }))
+        .filter((x) => x.year)
+        .sort((a, z) => a.year - z.year);
+    const eldest = kids[0];
+    const year = ownYear ?? (marrYear ? marrYear - 25 : eldest ? eldest.year - 28 : undefined);
+    const place = own?.place ?? marr?.place ?? eldest?.b?.place;
+    const from = ownYear ? undefined : marrYear ? phrase(lang, "estimate.marriage", { year: marrYear }) : eldest ? phrase(lang, "estimate.child", { year: eldest.year }) : undefined;
+    return { ...(year ? { year } : {}), ...(place ? { place } : {}), ...(from ? { from } : {}) };
+}
+export function frontier(tree, research) {
+    if (research.direction !== "ancestors")
+        return [];
+    const gens = ancestorGenerations(tree, research.focus, research.limits?.generations ?? 50);
+    const all = tree.list("task");
+    const tasks = all.filter((t) => FRONTIER_LEVELS.has(t.level));
+    const lang = tree.lang;
+    const out = [];
+    for (const [id, generation] of gens) {
+        const p = tree.get(id);
+        if (!p || p.retracted)
+            continue;
+        const est = birthEstimate(tree, p, lang);
+        const year = est.year;
+        if (research.limits?.generations && generation >= research.limits.generations)
+            continue;
+        if (research.limits?.before && year && year < research.limits.before)
+            continue;
+        const birthFamilies = familiesAsChild(tree, id).filter((f) => isBirthFamily(f, id));
+        const hasBirthFamily = birthFamilies.some((f) => f.partners.length === 2);
+        const proven = birthRecordProven(p);
+        if (hasBirthFamily && proven)
+            continue;
+        // The birth record is read and names one parent (a child born out of wedlock):
+        // another search for the same baptism will not name the other.
+        if (proven && birthFamilies.some((f) => f.partners.length === 1))
+            continue;
+        const mine = tasks.filter((t) => t.subject.includes(id));
+        // Covered also by other work in the books of the baptism: a task that records or checks it there.
+        const births = candidateRecordsets(tree, est.place, year).map((b) => b.id);
+        const covered = mine.find((t) => OPEN_STATES.has(t.state)) ??
+            all.find((t) => (t.level === "enrich" || t.level === "verify") && OPEN_STATES.has(t.state) && t.subject.includes(id) && t.where.some((w) => births.includes(w)));
+        const finished = mine.filter((t) => FINISHED_STATES.has(t.state));
+        const name = `${displayName(p)}${lifespan(p) ? ` (${lifespan(p)})` : ""}`;
+        const item = {
+            person: p,
+            generation,
+            reason: !hasBirthFamily ? "parents unknown" : "parents not proven by a record",
+            ...(covered ? { coveredBy: covered.id } : {}),
+        };
+        if (!covered) {
+            // What was already tried is never proposed again: a finished link task
+            // used up its record sets, a finished locate task its search for them.
+            const tried = new Set(finished.filter((t) => t.level === "link").flatMap((t) => t.where));
+            const place = est.place;
+            // an estimate needs a wider search than a known year
+            const span = est.from ? 10 : 3;
+            const about = est.from && year ? phrase(lang, "born.about", { year, from: est.from }) : "";
+            const reason = phrase(lang, hasBirthFamily ? "reason.unproven" : "reason.unknown");
+            const sets = candidateRecordsets(tree, place, year).filter((b) => !tried.has(b.id));
+            const located = finished.some((t) => t.level === "locate");
+            const requested = finished.some((t) => t.level === "request");
+            if (sets.length)
+                item.proposal = {
+                    level: "link",
+                    priority: 3, // the queue puts nearer generations first
+                    what: phrase(lang, "link.what", { name, place: place ? phrase(lang, "link.place", { place }) : "", about }),
+                    where: sets.map((b) => b.id),
+                    why: phrase(lang, "link.why", { reason, generation, research: research.name }),
+                    doneWhen: phrase(lang, "link.done", { years: year ? `${year - span}–${year + span}` : phrase(lang, "whole.book") }),
+                    subject: [id],
+                    research: research.id,
+                };
+            else if ((place || year) && !located)
+                item.proposal = {
+                    level: "locate",
+                    priority: 3, // the queue puts nearer generations first
+                    what: phrase(lang, "locate.what", { place: place ?? phrase(lang, "the.birthplace"), around: year ? phrase(lang, "locate.around", { year }) : "", name, about }),
+                    where: [
+                        (place ? phrase(lang, "locate.where", { place }) : phrase(lang, "locate.where.unknown")) +
+                            (year ? phrase(lang, "locate.years", { from: year - span - 2, to: year + span + 2 }) : ""),
+                    ],
+                    why: phrase(lang, "locate.why", { reason }),
+                    doneWhen: phrase(lang, "locate.done"),
+                    subject: [id],
+                    research: research.id,
+                };
+            else if (finished.length && !requested)
+                item.proposal = {
+                    level: "request",
+                    priority: 2,
+                    what: phrase(lang, "request.what", { name, tasks: finished.map((t) => t.id).join(", ") }),
+                    where: [phrase(lang, "request.where", { place: place ?? phrase(lang, "the.birthplace") })],
+                    why: phrase(lang, "request.why", { reason }),
+                    doneWhen: phrase(lang, "request.done"),
+                    subject: [id],
+                    research: research.id,
+                };
+            else if (finished.length)
+                item.exhausted = finished.map((t) => t.id);
+        }
+        out.push(item);
+    }
+    return out.sort((a, b) => a.generation - b.generation);
+}

package/dist/core/gdate.js

@@ -0,0 +1,77 @@
+// Genealogical dates in GEDCOM 5.5.1 form: "24 JUN 1783", "ABT 1783",
+// "BET 1811 AND 1812", "BEF MAR 1850", "FROM 1839 TO 1845".
+// ISO input ("1783-06-24", "1783-06") is accepted and converted.
+export const MONTHS = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
+const SIMPLE = /^(?:(\d{1,2}) )?(?:(JAN|FEB|MAR|APR|MAY|JUN|JUL|AUG|SEP|OCT|NOV|DEC) )?(\d{3,4})$/;
+const QUALIFIERS = ["ABT", "CAL", "EST", "BEF", "AFT"];
+function daysInMonth(month, year) {
+    return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function validSimple(s) {
+    const m = SIMPLE.exec(s);
+    if (!m)
+        return false;
+    const [, day, mon, year] = m;
+    if (day && !mon)
+        return false;
+    if (day && mon) {
+        const monthIndex = MONTHS.indexOf(mon) + 1;
+        const d = Number(day);
+        if (d < 1 || d > daysInMonth(monthIndex, Number(year)))
+            return false;
+    }
+    return true;
+}
+function fromIso(s) {
+    const m = /^(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?$/.exec(s);
+    if (!m)
+        return undefined;
+    const [, y, mo, d] = m;
+    if (!mo)
+        return y;
+    const mon = MONTHS[Number(mo) - 1];
+    if (!mon)
+        return undefined;
+    return d ? `${Number(d)} ${mon} ${y}` : `${mon} ${y}`;
+}
+/** Normalize user input to GEDCOM form, or return undefined if invalid. */
+export function normalizeDate(input) {
+    let s = input.trim().toUpperCase().replace(/\s+/g, " ");
+    if (s === "")
+        return undefined;
+    s = s.replace(/\b(\d{4}(?:-\d{2}){0,2})\b/g, (iso) => fromIso(iso) ?? iso);
+    const bet = /^BET (.+) AND (.+)$/.exec(s);
+    if (bet?.[1] && bet[2])
+        return validSimple(bet[1]) && validSimple(bet[2]) ? s : undefined;
+    const fromTo = /^FROM (.+?)(?: TO (.+))?$/.exec(s);
+    if (fromTo?.[1])
+        return validSimple(fromTo[1]) && (!fromTo[2] || validSimple(fromTo[2])) ? s : undefined;
+    const to = /^TO (.+)$/.exec(s);
+    if (to?.[1])
+        return validSimple(to[1]) ? s : undefined;
+    const q = /^([A-Z]{3}) (.+)$/.exec(s);
+    if (q?.[1] && q[2] && QUALIFIERS.includes(q[1]))
+        return validSimple(q[2]) ? s : undefined;
+    return validSimple(s) ? s : undefined;
+}
+/** All years mentioned in a GEDCOM date. */
+export function dateYears(date) {
+    return [...date.matchAll(/\b(\d{3,4})\b/g)].map((m) => Number(m[1])).filter((y) => y >= 100);
+}
+/** Short year label for listings: "1783", "~1783", "<1850", "1811/1812". */
+export function yearLabel(date) {
+    if (!date)
+        return "?";
+    const years = dateYears(date);
+    if (years.length === 0)
+        return "?";
+    if (date.startsWith("BET") || date.startsWith("FROM"))
+        return years.join("/");
+    if (/^(ABT|CAL|EST) /.test(date))
+        return `~${years[0]}`;
+    if (date.startsWith("BEF"))
+        return `<${years[0]}`;
+    if (date.startsWith("AFT"))
+        return `>${years[0]}`;
+    return String(years[0]);
+}