strom-research 1.26.0-beta.1 → 1.26.0-beta.2

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.26.0
 
-*Připravuje se: bety do 1.26.0-beta.1. Oddíl bude úplný s vydáním.*
+*Připravuje se: bety do 1.26.0-beta.2. Oddíl bude úplný s vydáním.*
 
 - **Brána týdne předplatného už neukončí běh kvůli jedné nepřečtené odpovědi.** Zeptá se znovu, pak čtvrt hodiny počká
   a řekne, co dostala. Nepřihlášený agent se ohlásí už před prvním sezením i s postupem přihlášení; výchozí složka
@@ -21,6 +21,13 @@ Změny každé verze ve zkratce. Úplné poznámky a instalační řádky jsou n
   vrátit. Souhrn sezení o místech začíná tím, co se udělalo – ztotožněno, ověřeno, s otázkou, nedohledáno – a jedno
   sezení vezme víc míst sousedních oblastí. Z „v Lhotě v čp. 12“ už nezůstane místo „v Lhotě v“:
   místem je obec, jak ji výzkum píše jinde, i když ji věta skloňuje. Každý název se do záznamu místa zapíše jen jednou.
+- **Fronta míst se po vyřízení míst vyprázdní.** Místo ztotožněné, ověřené, předané k otázce nebo nedohledané odejde z
+  fronty se všemi svými tvary, i s tím, který fakta mezitím píší jinak; místa, která sezení už udělalo, se znovu neberou
+  a počet čekajících sedí. Co ve frontě nechala dřívější verze, se odebere samo (jen vyřízená místa, krok jde vrátit);
+  kontrola vyžádaná u místa, které čeká na ztotožnění, zůstane jako kontrola. Každý krok nad místy jde vrátit vlastním
+  číslem, i když čeká jiný (také odpovědi člověka). Chybné jméno v záznamu místa — překlep ze záznamu, který už žádný
+  fakt nepíše, jméno jiného místa — jde odebrat i s důvodem (`strom place names L… --drop`); sezení nad místy vidí další
+  jména záznamu s jazykem a roky; kontrola může uvést, o jaký zdroj se opřela; příslušnost jde zadat i k jednomu roku.
 - V rozporech úpravy z aplikace už číslo domu, které značku má, nedostane značku podruhé (polsky „nr domu nr domu 12“),
   a pomlčka v titulku je podle jazyka výzkumu.
 

package/CHANGELOG.de.md

@@ -7,7 +7,7 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
 
 ## 1.26.0
 
-*In Vorbereitung: die Betas bis 1.26.0-beta.1. Der Abschnitt ist mit dem Release vollständig.*
+*In Vorbereitung: die Betas bis 1.26.0-beta.2. Der Abschnitt ist mit dem Release vollständig.*
 
 - **Das Tor der Abo-Woche beendet einen Lauf nicht mehr wegen einer unlesbaren Antwort.** Es fragt erneut, wartet dann
   eine Viertelstunde und nennt, was es erhielt. Ein nicht angemeldeter Agent wird schon vor der ersten Sitzung gemeldet,
@@ -25,6 +25,16 @@ Die Änderungen jeder Version in Kürze. Die vollständigen Hinweise und die Ins
   benachbarter Gebiete. Aus „in Lhota in Nr. 12“ bleibt kein Ort „in Lhota in“ mehr:
   Ort ist die Gemeinde, wie die Forschung sie sonst schreibt, auch wenn der Satz sie beugt. Jeder Name steht nur einmal
   im Eintrag eines Ortes.
+- **Die Warteschlange der Orte leert sich, wenn die Orte erledigt sind.** Ein Ort, der bestimmt, geprüft, erfragt oder
+  nicht gefunden wurde, verlässt die Warteschlange mit allen seinen Formen, auch mit einer, die die Fakten inzwischen
+  anders schreiben; Orte, die eine Sitzung schon erledigt hat, werden nicht erneut genommen, und die Zahl des Wartenden
+  stimmt. Was eine frühere Version in der Warteschlange ließ, wird von selbst entfernt (nur erledigte Orte, der Schritt
+  lässt sich rückgängig machen); eine Prüfung, die für einen Ort verlangt wird, der auf die Bestimmung wartet, bleibt
+  als Prüfung. Jeder Schritt bei den Orten lässt sich mit seiner eigenen Nummer rückgängig machen, auch wenn ein anderer
+  wartet (auch die Antworten der Person). Ein falscher Name im Datensatz eines Ortes — ein Versehen eines Eintrags, das
+  kein Faktum mehr schreibt, der Name eines anderen Ortes — lässt sich mit Begründung entfernen (`strom place names L…
+  --drop`); die Sitzung über die Orte sieht die weiteren Namen des Datensatzes mit Sprache und Jahren; eine Prüfung kann
+  die Quelle nennen, auf die sie sich stützt; eine Zugehörigkeit lässt sich auch für ein einzelnes Jahr angeben.
 - In den Widersprüchen einer Änderung aus der App bekommt eine Hausnummer, die ihre Bezeichnung schon trägt, sie nicht
   ein zweites Mal (polnisch „nr domu nr domu 12“), und der Gedankenstrich im Titel richtet sich nach der Sprache der
   Forschung.

package/CHANGELOG.md

@@ -7,7 +7,7 @@ The changes of each version in short. The full notes and the install lines are o
 
 ## 1.26.0
 
-*In preparation: the betas up to 1.26.0-beta.1. The section is complete with the release.*
+*In preparation: the betas up to 1.26.0-beta.2. The section is complete with the release.*
 
 - **The gate of the subscription's week no longer ends a run over one answer it cannot read.** It asks again, then
   waits a quarter of an hour and says what it got. An agent not logged in is said before the first session, with how to
@@ -23,6 +23,14 @@ The changes of each version in short. The full notes and the install lines are o
   located — and takes more places of neighbouring areas at once. "in Lhota in no. 12" no longer leaves "in Lhota in" as
   a place: the place is the municipality as the research writes it elsewhere, also where the sentence declined it. Each
   name goes into a place's record once.
+- **The queue of places empties as the places are done.** A place identified, checked, asked about or not located leaves
+  the queue with every form of it, also one the facts write otherwise since; the places a session already did are no
+  longer taken again, and the count of what waits is right. What an earlier version left in the queue is taken out by
+  itself (only places dealt with, the step can be undone); a check asked of a place waiting to be identified is kept as
+  the check. Each step on places is undone by its own number, also while another waits (the person's answers among
+  them). A wrong name of a place's record — a slip of a record no fact writes any more, another place's name — can be
+  taken off with the reason (`strom place names L… --drop`); the session on the places sees the record's other names
+  with their language and years; a check can name the reference it stood on; a jurisdiction can be given for one year.
 - In the conflicts of an edit from the app a house that says it is one already no longer gets its marker twice ("nr domu nr
   domu 12" in Polish), and the title's dash is the one of the research's language.
 

package/CHANGELOG.pl.md

@@ -7,7 +7,7 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
 
 ## 1.26.0
 
-*W przygotowaniu: bety do 1.26.0-beta.1. Sekcja będzie kompletna z wydaniem.*
+*W przygotowaniu: bety do 1.26.0-beta.2. Sekcja będzie kompletna z wydaniem.*
 
 - **Warunek tygodnia subskrypcji nie kończy już przebiegu z powodu jednej nieodczytanej odpowiedzi.** Pyta ponownie,
   potem czeka kwadrans i podaje, co otrzymał. Niezalogowany agent jest zgłaszany już przed pierwszą sesją, ze sposobem
@@ -23,6 +23,15 @@ Zmiany każdej wersji w skrócie. Pełne informacje o wydaniach i polecenia inst
   odnaleziono – a jedna sesja bierze więcej miejsc z sąsiednich obszarów. Z „w Lhocie w nr 12” nie zostaje już
   miejsce „w Lhocie w”: miejscem jest miejscowość tak, jak badanie zapisuje ją gdzie indziej, także gdy zdanie ją
   odmienia. Każda nazwa trafia do rekordu miejsca tylko raz.
+- **Kolejka miejsc opróżnia się, gdy miejsca są załatwione.** Miejsce zidentyfikowane, sprawdzone, przekazane jako
+  pytanie albo nieustalone opuszcza kolejkę ze wszystkimi swoimi formami, także z tą, którą fakty zapisują teraz
+  inaczej; miejsca, które sesja już zrobiła, nie są brane ponownie, a liczba oczekujących się zgadza. To, co w kolejce
+  zostawiła wcześniejsza wersja, usuwa się samo (tylko załatwione miejsca, krok można cofnąć); sprawdzenie zlecone dla
+  miejsca czekającego na identyfikację zostaje jako sprawdzenie. Każdy krok przy miejscach można cofnąć jego własnym
+  numerem, także gdy czeka inny (również odpowiedzi osoby). Błędną nazwę w rekordzie miejsca — pomyłkę z zapisu, której
+  żaden fakt już nie zapisuje, nazwę innego miejsca — można usunąć z uzasadnieniem (`strom place names L… --drop`);
+  sesja nad miejscami widzi pozostałe nazwy rekordu z językiem i latami; sprawdzenie może podać źródło, na którym się
+  oparło; przynależność można podać także dla jednego roku.
 - W sprzecznościach zmian z aplikacji numer domu, który ma już oznaczenie, nie dostaje go po raz drugi („nr domu nr
   domu 12”), a myślnik w tytule zależy od języka badania.
 

package/dist/brief/places.js

@@ -5,7 +5,7 @@
 import { langName } from "../core/lang.js";
 import { match } from "../cli/registry.js";
 import { synopsis } from "./sheet.js";
-import { factForms, personsHand, PLACES_IDENTIFY_ORIGIN, queueBatches, readPlacesFile, recordIndex } from "../core/placeid.js";
+import { factForms, otherNames, personsHand, PLACES_IDENTIFY_ORIGIN, queueBatches, readPlacesFile, recordIndex } from "../core/placeid.js";
 import { historyOn } from "../core/pastevents.js";
 import { othersRecords } from "../core/placeadopt.js";
 import { foldText } from "../core/text.js";
@@ -24,6 +24,24 @@ function span(ys) {
     const b = Math.max(...ys);
     return a === b ? String(a) : `${a}–${b}`;
 }
+/** A name as the agent writes it: name[@lang][:from-to]. */
+function nameSaid(n) {
+    const years = n.from === undefined && n.to === undefined ? "" : n.from === n.to ? `:${n.from}` : `:${n.from ?? ""}-${n.to ?? ""}`;
+    return `${n.name}${n.lang ? `@${n.lang}` : ""}${years}`;
+}
+/** A record's names: today's, its other names (another language, old names — with their language and years), the forms of the facts. */
+function recordNames(p) {
+    const rest = otherNames(p);
+    const alt = rest.filter((n) => n.kind !== "form");
+    const forms = rest.filter((n) => n.kind === "form");
+    return [
+        nameSaid(p.names[0]),
+        alt.length ? `other names ${alt.map(nameSaid).join(", ")}` : "",
+        forms.length ? `forms ${forms.map((n) => n.name).join(", ")}` : "",
+    ]
+        .filter(Boolean)
+        .join("; ");
+}
 /** One place of the batch: its form, the facts, the people, the archives of its sources, the record of it. */
 function placeLine(tree, form, f, entry, p, others) {
     const areas = f
@@ -40,7 +58,7 @@ function placeLine(tree, form, f, entry, p, others) {
         f ? `${f.facts} fact${f.facts === 1 ? "" : "s"} ${span(f.years)}` : "",
         persons.length ? `people ${persons.join(" ")}${f.persons.size > persons.length ? " …" : ""}` : "",
         areas.length ? `sources from ${areas.join(", ")}` : "",
-        p ? `record ${p.id}: ${p.names.map((n) => n.name).join(", ")}` : "no record yet",
+        p ? `record ${p.id}: ${recordNames(p)}` : "no record yet",
         p?.parent ? `in ${p.parent}` : "",
         p?.jurisdictions.length ? p.jurisdictions.map((j) => `${j.kind} ${j.name}${j.from || j.to ? ` ${j.from ?? "…"}–${j.to ?? "…"}` : ""}`).join(", ") : "",
         p?.coords ? `on the map ${p.coords.lat.toFixed(4)}, ${p.coords.lon.toFixed(4)}${personsHand(p) ? " (the person's — never moved)" : ""}` : "",
@@ -89,8 +107,11 @@ export function placesIdentifySections(tree, task, alone, settings) {
                 "",
                 "The record of a place:",
                 "- its first name is the official name of today in the language of the country it lies in now (a village now in Poland: Polish; the German name is historical) — the names of the facts and the old names go in as --form and --alt name@lang:from-to (an old name: from-to its years; one year: name@lang:1844)",
+                "- the record's other names above are known already (name@language:years): today's name in another language may be among them — look it up by that name before calling it not found, and set it first with --name when the reference confirms it",
+                "- a name of the record found wrong (another place's name, a slip of a record no fact writes any more): strom place names L… --drop \"<name>\" --why \"what shows it is wrong\" — never left in with a note that it is wrong",
                 "- what is found of a place goes into its record, also where the coordinates are right already: strom place verify L… --ok --why \"…\" --alt … --form … (never only into the history)",
-                "- a jurisdiction found wrong (another parish): strom place verify L… --ok --why \"what the records say\" --drop-jurisdiction parish:<name> --jurisdiction parish:<right one>:from-to",
+                "- a jurisdiction found wrong (another parish): strom place verify L… --ok --why \"what the records say\" --drop-jurisdiction parish:<name> --jurisdiction parish:<right one>:from-to (one year: parish:<name>:1899)",
+                "- the reference a check stood on: strom place verify L… --ok --why \"…\" --source-title \"…\" --source-url …",
                 "- a form of the facts that is a place with a record already (\"Nové Lhoty\" of Lhoty): strom place identify L… --form \"<form>\" — never a second record; two records of one place: strom place merge L… --into L… --reason \"…\"",
                 "",
                 "Three degrees, never guessed:",
@@ -115,6 +136,7 @@ export function placesIdentifySections(tree, task, alone, settings) {
         cmd(["place", "verify"]),
         cmd(["place", "rewrite"]),
         cmd(["place", "merge"]),
+        cmd(["place", "names"]),
         cmd(["place", "show"]),
         ...(history ? [cmd(["history", "map"])] : []),
     ].filter(Boolean);

package/dist/commands/placeid.js

@@ -8,7 +8,7 @@ import { UsageError } from "../core/errors.js";
 import { listOpt } from "../core/records.js";
 import { refuseInArchive } from "../core/state.js";
 import { isAgent } from "../core/which.js";
-import { answerPlaces, cancelPlaces, factForms, identifyEstimate, identifyPlace, parseCandidate, parseJurisdiction, PLACE_TAKES, placeState, proposePlace, queueBatches, queueOrder, queuePlaces, raisePlacesTask, readPlacesFile, recordIndex, rewriteForm, undoPlaces, unlocatePlace, verifyPlace, identifyingNow, mergePlaces, parseAltName, parseDrop, placeIdOf, PLACE_FLAGS, REQUEST_MAX, } from "../core/placeid.js";
+import { answerPlaces, cancelPlaces, dropPlaceNames, factForms, identifyEstimate, identifyPlace, parseCandidate, parseJurisdiction, PLACE_TAKES, placeState, proposePlace, queueBatches, queueOrder, queuePlaces, raisePlacesTask, readPlacesFile, recordIndex, rewriteForm, undoPlaces, unlocatePlace, verifyPlace, identifyingNow, mergePlaces, parseAltName, parseDrop, placeIdOf, PLACE_FLAGS, REQUEST_MAX, } from "../core/placeid.js";
 import { actsAsArchive } from "../core/state.js";
 function str(v) {
     return typeof v === "string" && v.trim() ? v.trim() : undefined;
@@ -24,7 +24,7 @@ const DETAIL_OPTIONS = [
     { name: "form", type: "string", multiple: true, value: "<place>", description: "another form of the facts that is the same place (kept among the record's names as a form, out of the queue; repeatable)" },
     { name: "kind", type: "string", value: "<kind>", description: "village, town, part of a municipality, …" },
     { name: "parent", type: "string", value: "<L…>", description: "the place it is part of" },
-    { name: "jurisdiction", type: "string", multiple: true, value: "<kind:name[:from-to]>", description: 'e.g. "parish:Lhotov:1784-" or "district:Lhotov" (repeatable)' },
+    { name: "jurisdiction", type: "string", multiple: true, value: "<kind:name[:from-to]>", description: 'e.g. "parish:Lhotov:1784-", "district:Lhotov" or one year "district:Lhotov:1899" (repeatable)' },
     { name: "drop-jurisdiction", type: "string", multiple: true, value: "<kind:name>", description: "a jurisdiction of the record found wrong: taken off, --why says why (repeatable)" },
 ];
 register({
@@ -121,6 +121,8 @@ register({
         { name: "ok", type: "boolean", description: "the records agree with the coordinates" },
         { name: "undecided", type: "string", value: "<why>", description: "it cannot be decided, and why" },
         { name: "why", type: "string", value: "<text>", description: "with --ok: on what (kept with the check); with --drop-jurisdiction: why it is wrong" },
+        { name: "source-title", type: "string", value: "<title>", description: "the reference the check stands on (a gazetteer, a register of places)" },
+        { name: "source-url", type: "string", value: "<url>", description: "its address" },
         ...DETAIL_OPTIONS,
     ],
     args: [{ name: "place", description: "place ID (L0012) or the place as the facts write it", required: true }],
@@ -134,7 +136,12 @@ register({
         refuseInArchive(tree, "place verify", ctx.settings.agent(tree.config).value);
         if (!!opts.ok === !!opts.undecided)
             throw new UsageError("--ok or --undecided \"<why>\"", { hint: `strom place verify ${args[0] ?? "L…"} --ok --why "on what" (names found: --alt, --form)` });
-        const r = verifyPlace(tree, args[0], opts.ok ? { ok: true, ...(str(opts.why) ? { why: str(opts.why) } : {}) } : { ok: false, why: String(opts.undecided) }, detailsOf(opts));
+        const title = str(opts["source-title"]);
+        const url = str(opts["source-url"]);
+        if (url && !title)
+            throw new UsageError("--source-url with its --source-title");
+        const source = title ? { source: { title, ...(url ? { url } : {}) } } : {};
+        const r = verifyPlace(tree, args[0], opts.ok ? { ok: true, ...(str(opts.why) ? { why: str(opts.why) } : {}), ...source } : { ok: false, why: String(opts.undecided), ...source }, detailsOf(opts));
         raisePlacesTask(tree, actsAsArchive(tree));
         return stepResult(tree, r);
     },
@@ -185,11 +192,35 @@ register({
             propose: !!opts.propose,
             ...(str(opts.why) ? { why: str(opts.why) } : {}),
         });
+        raisePlacesTask(tree, actsAsArchive(tree));
         return {
             text: lines(written(tree), r.left ? `left: ${counted(r.left, "fact")} (their house says another thing — never written over)` : undefined),
             data: { place: r.place, changed: r.changed, left: r.left, asked: r.asked },
         };
     },
+}, {
+    path: ["place", "names"],
+    summary: "Take a wrong name off a place record (a slip of a record kept as a form, another place's name), with the reason",
+    group: "sources",
+    tree: true,
+    writes: true,
+    description: "Never today's name (the first: --name of strom place verify or identify sets another) and never a name a fact still writes for the place (strom place rewrite first). Other names are added with --alt and --form of strom place identify or verify.",
+    args: [{ name: "place", description: "place ID (L0012)", required: true }],
+    options: [
+        { name: "drop", type: "string", multiple: true, value: "<name>", description: "the name to take off, as the record has it" },
+        { name: "why", type: "string", value: "<text>", description: "why it is wrong (kept with the step)" },
+    ],
+    examples: ['strom place names L0002 --drop "v Lhotě v" --why "a slip of the register; the facts write Lhota now"'],
+    run(ctx, { args, opts }) {
+        const tree = ctx.tree();
+        refuseInArchive(tree, "place names", ctx.settings.agent(tree.config).value);
+        const r = dropPlaceNames(tree, args[0], listOpt(opts.drop), String(opts.why ?? ""));
+        raisePlacesTask(tree, actsAsArchive(tree));
+        return {
+            text: lines(`${r.place.id}: ${r.dropped.map((n) => n.name).join(", ")} taken off`, `undo (the person's): strom place undo ${r.undo}`, written(tree)),
+            data: { place: r.place, dropped: r.dropped, undo: r.undo },
+        };
+    },
 }, {
     path: ["place", "queue"],
     summary: "Queue places to be identified (or their coordinates checked) — or show the queue",
@@ -304,12 +335,12 @@ register({
     },
 }, {
     path: ["place", "undo"],
-    summary: "Undo the person's last step on places (answers)",
+    summary: "Undo a step on places by its id (the person's answers, names taken off, the queue tidied)",
     group: "sources",
     tree: true,
     writes: true,
-    person: "Undoing the person's answers is the person's own",
-    args: [{ name: "step", description: "the step's id (the answer prints it)", required: true }],
+    person: "Undoing a step on places is the person's own",
+    args: [{ name: "step", description: "the step's id (the step prints it; each of the last 20 steps once)", required: true }],
     examples: ["strom place undo u1a2b3c"],
     run(ctx, { args }) {
         const tree = ctx.tree();

package/dist/core/placeid.js

@@ -41,12 +41,30 @@ export function readPlacesFile(tree) {
         for (const [k, v] of Object.entries(f?.queue ?? {}))
             if (v && typeof v.form === "string" && v.form.trim())
                 queue[k] = v;
-        return { queue, ...(f?.undo ? { undo: f.undo } : {}), ...(f?.converted ? { converted: f.converted } : {}), ...(typeof f?.repaired === "number" ? { repaired: f.repaired } : {}) };
+        const undos = Array.isArray(f?.undos) ? f.undos.filter((u) => u && typeof u.id === "string") : [];
+        return { queue, ...(f?.undo ? { undo: f.undo } : {}), ...(undos.length ? { undos } : {}), ...(f?.converted ? { converted: f.converted } : {}), ...(typeof f?.repaired === "number" ? { repaired: f.repaired } : {}) };
     }
     catch {
         return { queue: {} };
     }
 }
+/** How many steps on places can be undone, each by its own ID (the oldest go first). */
+export const UNDO_KEPT = 20;
+/** A step to be undone kept: the newest; the one before it waits among the others, never lost to it. */
+function keepUndo(file, u) {
+    if (file.undo)
+        file.undos = [...(file.undos ?? []), file.undo].slice(-(UNDO_KEPT - 1));
+    file.undo = u;
+    return u.id;
+}
+/** A new step's undo ID: never one waiting already (two steps in one millisecond). */
+function undoId(file) {
+    const taken = new Set([file.undo?.id, ...(file.undos ?? []).map((u) => u.id)]);
+    let t = Date.now();
+    while (taken.has(`u${t.toString(36)}`))
+        t++;
+    return `u${t.toString(36)}`;
+}
 function fileContent(f) {
     return stringifyCanonical(f);
 }
@@ -96,8 +114,12 @@ export function factForms(tree) {
  * okres Horní"); none when two do — a place two records could be belongs to none until its writing is set right.
  */
 export function recordIndex(tree) {
+    return recordIndexOf(tree.list("place"));
+}
+/** recordIndex over the given records (the records as a step leaves them). */
+function recordIndexOf(places) {
     const byName = new Map();
-    for (const p of tree.list("place")) {
+    for (const p of places) {
         if (p.retracted)
             continue;
         for (const k of new Set(p.names.map((n) => foldText(n.name))))
@@ -297,7 +319,17 @@ export function queuePlaces(tree, req, by = "person") {
                 skipped.push({ form: w.form, why: "running" });
                 continue;
             }
-            if ([w.key, ...others].some((k) => file.queue[k])) {
+            const had = [w.key, ...others].find((k) => file.queue[k]);
+            if (had) {
+                const e = file.queue[had];
+                // queued to be looked for, and on the map since: the check asked now takes its place (the tidying would take
+                // the old entry out as identified, and the person's check with it)
+                if (req.check && w.place?.coords && !e.check) {
+                    const { back: _b, ...rest } = e;
+                    file.queue[had] = { ...rest, at, by, check: true };
+                    queued.push(e.form);
+                    continue;
+                }
                 skipped.push({ form: w.form, why: "queued" });
                 continue;
             }
@@ -512,7 +544,7 @@ function setFirst(p, today, forms) {
 }
 /** "<kind>:<name>" of a jurisdiction to take off. */
 export function parseDrop(s) {
-    const m = /^([^:]+):(.+?)(?::\d{0,4}-\d{0,4})?$/u.exec(s.normalize("NFC").trim());
+    const m = /^([^:]+):(.+?)(?::\d{0,4}-\d{0,4}|:\d{3,4})?$/u.exec(s.normalize("NFC").trim());
     if (!m || !JURISDICTIONS.includes(m[1].trim()))
         throw new UsageError(`--drop-jurisdiction "${s}": "<kind>:<name>", kind one of ${JURISDICTIONS.join(", ")}`, { code: "place.jurisdiction" });
     return { kind: m[1].trim(), name: m[2].trim() };
@@ -609,10 +641,68 @@ function originUnknown(p) {
 export function personsHand(p) {
     return !!p.coords && (!p.locating || p.locating.by === "person");
 }
-/** The forms queued for a place, and the place's forms, out of the queue. */
-function unqueue(file, keys) {
+/**
+ * A step done on a place takes out of the queue every entry that leads to it now — the forms of its facts, and any
+ * form the queue keeps whose writing is a name of the record as the step leaves it (the facts written otherwise since,
+ * a rewrite, a merge) — and only those. `keys`: forms the step names itself. `only`: which entries go (all by default).
+ */
+function unqueue(tree, file, changed, keys, only = () => true) {
+    const ids = new Set(changed.filter((p) => !p.retracted).map((p) => p.id));
+    const byId = new Set(changed.map((p) => p.id));
+    const recordOf = recordIndexOf([...tree.list("place").filter((p) => !byId.has(p.id)), ...changed]);
+    for (const [k, e] of Object.entries(file.queue)) {
+        const p = recordOf(e.form);
+        if ((keys.includes(k) && only(e, changed[0])) || (p && ids.has(p.id) && only(e, p)))
+            delete file.queue[k];
+    }
+}
+/**
+ * A queue entry whose place was dealt with after it was queued (identified, checked, asked, not located) — what an
+ * earlier strom left in the queue when the facts' form of it was written otherwise before the step. An entry the
+ * person put back (`back`) is never taken out so.
+ */
+export function settledBy(p, e) {
+    if (e.back)
+        return false;
+    const l = p.locating;
+    const asked = !!l?.question && l.question.at >= e.at;
+    // checked after it was queued: the time of the check (an earlier strom kept only the day of a check found right — a
+    // later day; the same day, or a check undecided of no time, is not known to come after)
+    if (e.check)
+        return !!p.coords && (asked || (l?.checked ? l.checked >= e.at : !!l?.verified && l.verified > e.at.slice(0, 10)));
+    // a place on the map is never queued to be looked for (queuePlaces): on the map since, it was identified
+    return !!p.coords || asked || (!!p.unlocated && (l?.at ?? "") >= e.at);
+}
+/**
+ * The entries of the queue whose place was dealt with already (settledBy) taken out — nothing else: an entry of no
+ * record, of a record two places bear, or of a place still to be done stays. One operation; while the person has no
+ * step to undo, `strom place undo` puts them back (and they stay then). Inside the tree's lock; the forms taken out.
+ */
+export function settleQueue(tree) {
+    const file = readPlacesFile(tree);
+    if (!Object.keys(file.queue).length)
+        return [];
+    const recordOf = recordIndex(tree);
+    const gone = {};
+    for (const [k, e] of Object.entries(file.queue)) {
+        const p = recordOf(e.form);
+        if (p && settledBy(p, e))
+            gone[k] = e;
+    }
+    const keys = Object.keys(gone);
+    if (!keys.length)
+        return [];
     for (const k of keys)
         delete file.queue[k];
+    const undo = keepUndo(file, { id: undoId(file), at: now(), places: {}, queue: gone });
+    const forms = keys.map((k) => gone[k].form);
+    write(tree, [], file, {
+        op: "place.settle",
+        targets: [],
+        reason: "queue entries of places dealt with already, left by an earlier version; nothing else taken out",
+        summary: `out of the queue, dealt with already: ${forms.length === 1 ? `place "${forms[0]}"` : `${forms.length} places (${forms.join(", ").slice(0, 600)})`} — undo: strom place undo ${undo}`,
+    });
+    return forms;
 }
 /**
  * A place identified surely (K2.2, K2.4): its coordinates, names, parent and jurisdictions written into its record (made
@@ -663,7 +753,7 @@ export function identifyPlace(tree, ref, input) {
         p.locating = locating;
         p.updated = now();
         const file = readPlacesFile(tree);
-        unqueue(file, [...t.keys, ...more]);
+        unqueue(tree, file, [p], [...t.keys, ...more]);
         write(tree, [p], file, {
             op: "place.identify",
             targets: [p.id],
@@ -700,7 +790,7 @@ export function unlocatePlace(tree, ref, why, needs, by = "research") {
             delete p.locating.needs;
         p.updated = now();
         const file = readPlacesFile(tree);
-        unqueue(file, t.keys);
+        unqueue(tree, file, [p], t.keys);
         write(tree, [p], file, { op: "place.unlocated", targets: [p.id], summary: `${p.id} ${p.names[0].name} not located: ${w.slice(0, 80)}` });
         return p;
     });
@@ -757,7 +847,7 @@ export function proposePlace(tree, ref, q) {
         p.locating = { ...(p.locating ?? originUnknown(p)), question };
         p.updated = now();
         const file = readPlacesFile(tree);
-        unqueue(file, t.keys);
+        unqueue(tree, file, [p], t.keys);
         write(tree, [p], file, { op: "place.propose", targets: [p.id], summary: `${p.id} ${p.names[0].name}: a question for the person (${q.kind}${q.candidates ? `, ${q.candidates.length} candidates` : ""})` });
         return p;
     });
@@ -779,18 +869,21 @@ export function verifyPlace(tree, ref, result, details = {}) {
             throw new UsageError('why the jurisdiction is wrong: --why "…" (what the records or the reference say)', { code: "place.why" });
         const { more, dropped, today } = applyDetails(tree, p, t, details, forms);
         const base = p.locating ?? { by: "person", at: p.updated };
+        const { verifiedSource: _s, ...kept } = base;
+        const source = result.source ? { verifiedSource: { title: text(result.source.title, 300, "--source-title"), ...(result.source.url ? { url: result.source.url.trim() } : {}) } } : {};
         if (result.ok) {
-            const { checkWhy: _c, verifiedWhy: _w, ...rest } = base;
-            p.locating = { ...rest, verified: now().slice(0, 10), ...(why ? { verifiedWhy: why } : {}) };
+            const { checkWhy: _c, verifiedWhy: _w, ...rest } = kept;
+            const at = now();
+            p.locating = { ...rest, verified: at.slice(0, 10), checked: at, ...(why ? { verifiedWhy: why } : {}), ...source };
         }
         else {
             if (!why)
                 throw new UsageError('why it cannot be decided: --undecided "…"', { code: "place.why" });
-            p.locating = { ...base, checkWhy: why };
+            p.locating = { ...kept, checkWhy: why, checked: now(), ...source };
         }
         p.updated = now();
         const file = readPlacesFile(tree);
-        unqueue(file, [...t.keys, ...more]);
+        unqueue(tree, file, [p], [...t.keys, ...more]);
         write(tree, [p], file, {
             op: "place.verify",
             targets: [p.id],
@@ -860,7 +953,11 @@ export function mergePlaces(tree, dupRef, intoRef, reason) {
             .filter((x) => !x.retracted && x.parent === dup.id && x.id !== into.id)
             .map((x) => ({ ...structuredClone(x), parent: into.id, updated: t }));
         const gone = { ...structuredClone(dup), retracted: { at: t, reason: `the same place as ${into.id}: ${why}` }, mergedInto: into.id, updated: t };
-        write(tree, [into, gone, ...parts], undefined, {
+        // the queue's forms of the duplicate lead to the one record now: out where it was dealt with already
+        const file = readPlacesFile(tree);
+        const was = JSON.stringify(file.queue);
+        unqueue(tree, file, [into, gone, ...parts], [], (e, p) => settledBy(p, e));
+        write(tree, [into, gone, ...parts], JSON.stringify(file.queue) !== was ? file : undefined, {
             op: "place.merge",
             targets: [into.id, dup.id, ...parts.map((x) => x.id)].sort(),
             summary: `${dup.id} ${dup.names[0].name} merged into ${into.id} ${into.names[0].name}${parts.length ? ` (its parts ${parts.map((x) => x.id).join(", ")} with it)` : ""}`,
@@ -953,7 +1050,11 @@ export function rewriteForm(tree, form, to, opts) {
             throw new UsageError('why the facts write it so: --reason "…"', { code: "place.why" });
         const { records, done, left: gone } = applyChanges(tree, changes, "before");
         place.updated = now();
-        write(tree, [place, ...records], undefined, {
+        // the form's entry of the queue leads to the record now: out where the place was dealt with already
+        const file = readPlacesFile(tree);
+        const was = JSON.stringify(file.queue);
+        unqueue(tree, file, [place], [], (e, x) => settledBy(x, e));
+        write(tree, [place, ...records], JSON.stringify(file.queue) !== was ? file : undefined, {
             op: "place.rewrite",
             targets: [place.id, ...records.map((r) => r.id)].sort(),
             summary: `the facts' place "${form}" → ${name}${to.house ? ` (house ${to.house})` : ""}: ${done.length} facts in ${records.length} records${left.length ? `, ${left.length} left (another house)` : ""}`,
@@ -1057,12 +1158,12 @@ export function answerPlaces(tree, ids, take, opts = {}) {
         const file = readPlacesFile(tree);
         const before = new Map(places.map((p) => [p.id, tree.get(p.id)]));
         const undo = {
-            id: `u${Date.now().toString(36)}`,
+            id: undoId(file),
             at: now(),
             places: Object.fromEntries(places.map((p) => [p.id, { before: before.get(p.id), after: p.updated }])),
             ...(done.length ? { facts: done } : {}),
         };
-        file.undo = undo;
+        keepUndo(file, undo);
         write(tree, [...places, ...records], file, {
             op: "place.answer",
             targets: [...places.map((p) => p.id), ...records.map((r) => r.id)].sort(),
@@ -1073,15 +1174,16 @@ export function answerPlaces(tree, ids, take, opts = {}) {
     });
 }
 /**
- * The person's last step on places undone (answers, a whole batch of them): each place as it was where nothing changed
- * it since, the facts' places back where still so. Inside the tree's lock.
+ * A step on places undone by its ID (the person's answers, a whole batch of them; names taken off; the queue tidied —
+ * each of the last UNDO_KEPT once): each place as it was where nothing changed it since, the facts' places back where
+ * still so, the queue's entries back. Inside the tree's lock.
  */
 export function undoPlaces(tree, id) {
     return tree.withTreeLock(() => {
         const file = readPlacesFile(tree);
-        const u = file.undo;
-        if (!u || u.id !== id)
-            throw new UsageError("nothing to undo of that step (only the last step on places, once)", { code: "places.undo.later" });
+        const u = file.undo?.id === id ? file.undo : file.undos?.find((x) => x.id === id);
+        if (!u)
+            throw new UsageError(`nothing to undo of that step (each step on places once, the last ${UNDO_KEPT})`, { code: "places.undo.later" });
         const restored = [];
         const left = [];
         const records = [];
@@ -1096,13 +1198,42 @@ export function undoPlaces(tree, id) {
             restored.push(pid);
         }
         if (left.length)
-            throw new UsageError(`changed since: ${left.join(", ")} — the step is not undone`, { code: "places.undo.later", params: { places: left.join(", ") } });
+            throw new UsageError(`changed since: ${left.join(", ")} — the step is not undone (a later step on the same place is undone first)`, {
+                code: "places.undo.later",
+                params: { places: left.join(", ") },
+            });
+        // an earlier step still to be undone that left a place as this undo puts it back: it knows the place by its new time
+        for (const r of records) {
+            const was = u.places[r.id].before.updated;
+            for (const x of [file.undo, ...(file.undos ?? [])])
+                if (x && x !== u && x.places[r.id]?.after === was)
+                    x.places[r.id] = { ...x.places[r.id], after: r.updated };
+        }
         const back = applyChanges(tree, u.facts ?? [], "after");
-        delete file.undo;
+        // the queue's entries the step took out: back, and kept there (never taken out by the tidying again)
+        let queued = 0;
+        for (const [k, e] of Object.entries(u.queue ?? {})) {
+            if (file.queue[k])
+                continue;
+            file.queue[k] = { ...e, back: true };
+            queued++;
+        }
+        // out of the steps to be undone; the one before it the newest again
+        if (file.undo === u) {
+            const before = file.undos?.pop();
+            if (before)
+                file.undo = before;
+            else
+                delete file.undo;
+        }
+        else
+            file.undos = file.undos.filter((x) => x !== u);
+        if (!file.undos?.length)
+            delete file.undos;
         write(tree, [...records, ...back.records], file, {
             op: "place.undo",
             targets: [...restored, ...back.records.map((r) => r.id)].sort(),
-            summary: `the last step on places undone: ${restored.length} places${back.done.length ? `, ${back.done.length} facts' places back` : ""}`,
+            summary: `a step on places undone (${u.id}): ${restored.length} places${back.done.length ? `, ${back.done.length} facts' places back` : ""}${queued ? `, ${queued} back in the queue` : ""}`,
         });
         return { restored, left };
     });
@@ -1160,6 +1291,8 @@ export function raisePlacesTask(tree, archive) {
     if (tree.dryRun || archive)
         return undefined;
     return tree.withTreeLock(() => {
+        // what an earlier version left in the queue of places dealt with already: out first, so the count is right
+        settleQueue(tree);
         const file = readPlacesFile(tree);
         const forms = factForms(tree);
         const recordOf = recordIndex(tree);
@@ -1220,6 +1353,55 @@ export function raisePlacesTask(tree, archive) {
         return task.id;
     });
 }
+/**
+ * Names of a place record found wrong (a slip of a record kept as a form, another place's name) taken off, with the
+ * reason: never today's name (the first), never a name a fact of the tree still writes for this place (set the facts
+ * right first: strom place rewrite). One operation; while the person has no step to undo, `strom place undo` puts them
+ * back. Inside the tree's lock.
+ */
+export function dropPlaceNames(tree, ref, names, reason) {
+    return tree.withTreeLock(() => {
+        const id = placeIdOf(ref);
+        const was = id ? tree.get(id) : undefined;
+        if (!was || was.type !== "place" || was.retracted)
+            throw new UsageError(`no place ${ref}: a place ID (L0012)`, { code: "place.unknown", hint: "strom place list" });
+        const why = text(reason, 1000, "--why");
+        if (!why)
+            throw new UsageError('why the name is wrong: --why "…"', { code: "place.why" });
+        if (!names.length)
+            throw new UsageError('which name: --drop "<name>"', { code: "place.name" });
+        const p = structuredClone(was);
+        const forms = factForms(tree);
+        const recordOf = recordIndex(tree);
+        const dropped = [];
+        for (const raw of names) {
+            const n = raw.normalize("NFC").trim();
+            const key = foldText(n);
+            // the very writing first, else any of the same letters (any accent)
+            const exact = p.names.findIndex((x) => x.name === n);
+            const hit = exact >= 0 ? exact : p.names.findIndex((x) => foldText(x.name) === key);
+            if (hit < 0)
+                throw new UsageError(`${p.id} has no name "${n}" (it has ${p.names.map((x) => x.name).join(", ")})`, { code: "place.name" });
+            if (hit === 0)
+                throw new UsageError(`"${n}" is the first name of ${p.id} — today's name is set with --name (strom place verify ${p.id} --ok --name "…")`, { code: "place.name" });
+            const f = forms.get(foldText(p.names[hit].name));
+            if (f && recordOf(f.form)?.id === p.id && !p.names.some((x, i) => i !== hit && foldText(x.name) === foldText(p.names[hit].name)))
+                throw new UsageError(`${f.facts === 1 ? "a fact" : `${f.facts} facts`} of the tree still write "${f.form}" — set them right first: strom place rewrite "${f.form}" --to ${p.id} --reason "…"`, { code: "place.form" });
+            dropped.push(p.names[hit]);
+            p.names.splice(hit, 1);
+        }
+        p.updated = now();
+        const file = readPlacesFile(tree);
+        const undo = keepUndo(file, { id: undoId(file), at: now(), places: { [p.id]: { before: was, after: p.updated } } });
+        write(tree, [p], file, {
+            op: "place.names",
+            targets: [p.id],
+            reason: why,
+            summary: `${p.id} ${p.names[0].name}: name${dropped.length === 1 ? "" : "s"} taken off as wrong: ${dropped.map((x) => `${x.name}${x.lang ? `@${x.lang}` : ""}`).join(", ")} — ${why.slice(0, 80)} — undo: strom place undo ${undo}`,
+        });
+        return { place: p, dropped, undo };
+    });
+}
 /**
  * The other names history's map is told of a place (strom history map --also) written among its record's names too —
  * the record is where the app and the identification read them. Nothing where the facts' place has no one record.
@@ -1361,19 +1543,17 @@ export function repairPlaces(tree) {
     if (!records.length)
         return [];
     file.repaired = PLACES_REPAIR;
-    if (!file.undo) {
-        file.undo = {
-            id: `u${Date.now().toString(36)}`,
-            at: now(),
-            places: Object.fromEntries(records.map((p) => [p.id, { before: tree.get(p.id), after: p.updated }])),
-        };
-    }
+    const undo = keepUndo(file, {
+        id: undoId(file),
+        at: now(),
+        places: Object.fromEntries(records.map((p) => [p.id, { before: tree.get(p.id), after: p.updated }])),
+    });
     write(tree, records, file, {
         op: "place.repair",
         targets: records.map((p) => p.id).sort(),
         // a name read from its syntax, or written twice, is no name lost: the data check takes the step as reasoned
         reason: "what an earlier version wrote into the place records set right, nothing lost (undo kept)",
-        summary: `place records set right (${records.length}): ${said.join(" · ").slice(0, 1500)}${file.undo?.places[records[0].id] ? ` — undo: strom place undo ${file.undo.id}` : ""}`,
+        summary: `place records set right (${records.length}): ${said.join(" · ").slice(0, 1500)} — undo: strom place undo ${undo}`,
     });
     return said;
 }
@@ -1423,11 +1603,15 @@ export function keepPlacesTask(tree) {
     tree.withTreeLock(() => repairPlaces(tree));
     return raisePlacesTask(tree, false);
 }
-/** The jurisdiction of "<kind>:<name>[:from-to]". */
+/** The jurisdiction of "<kind>:<name>[:from-to]" — one year (":1899"): known so in that year, from and to alike. */
 export function parseJurisdiction(s) {
-    const m = /^([^:]+):([^:]+?)(?::(\d{3,4})?-(\d{3,4})?)?$/u.exec(s.normalize("NFC").trim());
+    const m = /^([^:]+):([^:]+?)(?::(?:(\d{3,4})?-(\d{3,4})?|(\d{3,4})))?$/u.exec(s.normalize("NFC").trim());
     const kind = m?.[1]?.trim();
     if (!m || !kind || !JURISDICTIONS.includes(kind))
-        throw new UsageError(`--jurisdiction "${s}": "<kind>:<name>[:from-to]", kind one of ${JURISDICTIONS.join(", ")}`, { code: "place.jurisdiction" });
-    return { kind: kind, name: m[2].trim(), recordsets: [], ...(m[3] ? { from: Number(m[3]) } : {}), ...(m[4] ? { to: Number(m[4]) } : {}) };
+        throw new UsageError(`--jurisdiction "${s}": "<kind>:<name>[:from-to]" or one year "<kind>:<name>:<year>", kind one of ${JURISDICTIONS.join(", ")}`, { code: "place.jurisdiction" });
+    const from = m[3] ?? m[5];
+    const to = m[4] ?? m[5];
+    if (from && to && Number(from) > Number(to))
+        throw new UsageError(`--jurisdiction "${s}": the years ${from}-${to} go backwards`, { code: "place.jurisdiction" });
+    return { kind: kind, name: m[2].trim(), recordsets: [], ...(from ? { from: Number(from) } : {}), ...(to ? { to: Number(to) } : {}) };
 }

package/dist/core/placesview.js

@@ -60,6 +60,7 @@ function view(k, p) {
         ...(why ? { why } : {}),
         ...(loc?.source ? { source: loc.source } : {}),
         ...(loc?.verified ? { verified: loc.verified } : {}),
+        ...(loc?.verifiedSource ? { verifiedSource: loc.verifiedSource } : {}),
         ...(loc?.checkWhy ? { checkWhy: loc.checkWhy } : {}),
         ...(!p.coords && p.unlocated && loc?.needs ? { needs: loc.needs } : {}),
         ...(q && (state === "proposed" || state === "conflict") ? { waiting: p.id } : {}),

package/dist/core/schema.js

@@ -78,7 +78,9 @@ export const SCHEMAS = {
                 source: { t: "object", of: { title: S({ req: true, max: 300 }), url: S({ max: 2000 }) } },
                 verified: S(),
                 verifiedWhy: S({ max: 1000 }),
+                verifiedSource: { t: "object", of: { title: S({ req: true, max: 300 }), url: S({ max: 2000 }) } },
                 checkWhy: S({ max: 1000 }),
+                checked: S(),
                 needs: S({ max: 300 }),
                 context: { t: "number", int: true, min: 0 },
                 kept: { t: "object", of: { lat: { t: "number", req: true, min: -90, max: 90 }, lon: { t: "number", req: true, min: -180, max: 180 } } },

package/dist/core/tree.js

@@ -31,7 +31,7 @@ export const TREE_FILE = "strom.json";
 export const SEAL_FOREIGN = "seal.foreign";
 // 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.26.0-beta.1";
+export const VERSION = "1.26.0-beta.2";
 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.26.0-beta.1",
+  "version": "1.26.0-beta.2",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "stromLayout": 2,