@finbheara/archive-client 0.53.0 → 0.53.1

package/README.md

@@ -124,6 +124,7 @@ c.features;   // [{ feature: "dancers", state: "full" | "missing", missing: [...
 | `schools.registry` | `schools.list` | 260 |
 | `schools.prints`, `schools.redirects` | `schools.prints`; `schools.redirects` | 184 |
 | `schools.lineage` | `schools.links`, `schools.line`, `schools.lineage` | 184 |
+| `school-graph` | the tables `schools.redirects`, `schools.lineage`, `schools.links`, `schools.line` and a dancer question's lineage read in place of the jsonl, the same answers; the jsonl, never refused, without them | none yet |
 | `schools.associations` | `schools.associations` | 215 |
 
 A spec is `pinned` (the default: the user-local pin, else the latest), `latest`, a cut number
@@ -325,6 +326,20 @@ await rel.schools.associations({ school_id: "<id>" });
                                    //   association_type, src_type, src, candidate_school_id, candidate_rung, ... }] }
 ```
 
+THE SCHOOL GRAPH'S TABLES (feature `school-graph`): a release whose `results.sqlite` carries
+`school_nodes`, `school_edges` and `school_aliases` answers `redirects`, `lineage`, `links`,
+`line` and a dancer question's lineage from them, and one without them from
+`school-redirects.jsonl` and `school-lineage.jsonl`, as before. The answers are the same rows in
+the same order: a redirect is an alias of kind `fold` or `reslug`, or a former school (a node
+with `closed_into`) to the school that absorbed it, each landing on a live school in one hop; a
+lineage edge is a `school_edges` row of a lineage kind (`rename`, `absorb`, `merger`, `split`,
+`branch`, `related`) with no `lag_months`, given as its two ends, its `decision` the first of its
+`decision_rows`. A former school's absorbed-by line (the one with `lag_months`), a `distinct`,
+`disbanded`, banner or tie line, and a `shelf`, `site_fold`, path, print or `retired` alias are
+none of these, as the jsonl publishes none of them: an id the tables hold only that way answers
+nothing, never a guess. The tables round a `confidence` to 6 places, and the jsonl writes
+`1 - posterior` unrounded, so the two can differ past the sixth place.
+
 `prints` is every (print, school id) pair the release's result rows attach in an event-year (the
 print trimmed), with the rows that carry it: an event's (case-blind), a year's, both or every one.
 A row attached to no school is in no pair, and a team result's school is `rel.teams.results`'.
@@ -382,6 +397,8 @@ r.unlinked;    // rows printing a matched name that the release linked to no dan
 await rel.dancers.search({ surname: "Quellan" });  // or { like: "a* quellan" }, or { name }
                                                     // at most `limit` (default 50, 0 for all);
                                                     // `truncated` counts the rest
+                                                    // a surname folds as the print's key does:
+                                                    // `Karłowska` and `Karlowska` ask one key
 await rel.dancers.get(1001);                        // every print and school of one dancer
 ```
 
@@ -409,13 +426,14 @@ names package's Spanish reading (`createNameKinship({ spanishNames: true })`), a
 relates is a candidate at `nameLevel: "spanish"`. A release with no `spanish_names` reads every
 school the default way. A name the release already finds answers exactly as before.
 
-THE LINEAGE is the release's `school-lineage.jsonl`: every line joins its `id` and its `other`,
+THE LINEAGE is the release's `school-lineage.jsonl` (or its `school_edges`, where it carries the
+school graph's tables, the same edges): every line joins its `id` and its `other`,
 whatever its direction (`precedes`, `succeeds`) or shape (a rename, a split, a merger, an absorb,
 a relation), so a file carrying one end of an edge reads as one carrying both. The whole line
 joins: every school reached through any number of edges, in either direction (the two halves of a
 split are joined through their predecessor, the schools of a merger through their successor). An
 earlier row at a joined school alone is no match. `r.school.lineage` lists the ids joined to the
-asked ones. A release that publishes no lineage (feature `schools.lineage`) joins
+asked ones. A release that publishes no lineage (feature `schools.lineage`, nor `school-graph`) joins
 nothing and its answer carries no `lineage`, never refused. The line is read on the same school
 graph as `rel.schools.line` (`@finbheara/domain/school-graph`): untimed, every path, and as of a
 year, every path none of whose steps is dated after it, a rename at any year (`LINE_AS_OF`).

package/dist/chunks/{index-6np7hsst.js → index-aj1n1q7j.js}

@@ -141,7 +141,6 @@ import {
 } from "@finbheara/domain/title";
 import {
   composeNames,
-  foldNameKey,
   nameBlockKeys,
   nameKinship as nameKinship2,
   surnameBlock
@@ -1079,6 +1078,25 @@ var FEATURES2 = [
     since: 184,
     calls: "schools.redirects"
   },
+  {
+    feature: "school-graph",
+    needs: [
+      ...["alias", "kind", "node_id", "school_id"].map((c) => `results:school_aliases.${c}`),
+      ...["node_id", "kind", "minted_reslug_from", "minted_reslug_pass", "closed_into"].map((c) => `results:school_nodes.${c}`),
+      ...[
+        "from_id",
+        "to_id",
+        "kind",
+        "valid_from",
+        "provisional",
+        "confidence",
+        "decision_rows",
+        "lag_months"
+      ].map((c) => `results:school_edges.${c}`)
+    ],
+    since: 365,
+    calls: "schools.redirects, schools.lineage, schools.links, schools.line and the `lineage` school evidence of dancers.resolve and dancers.search read the tables, the same answers as the jsonl; without them, the jsonl, never refused"
+  },
   {
     feature: "schools.associations",
     needs: ["observed-associations.jsonl"],
@@ -1823,6 +1841,81 @@ class MajorsFinder2 {
 import {
   schoolGraph
 } from "@finbheara/domain/school-graph";
+
+var SCHOOL_GRAPH_FEATURE = "school-graph";
+var LINEAGE_KINDS = [
+  "rename",
+  "absorb",
+  "merger",
+  "split",
+  "branch",
+  "related"
+];
+async function schoolTables(rel) {
+  if ((await rel.capability(SCHOOL_GRAPH_FEATURE)).state !== "full")
+    return null;
+  await rel.fetch("results");
+  return rel.db("results");
+}
+var num = (v) => typeof v === "number" ? v : null;
+var cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var suffixOf = (id) => id.slice(id.lastIndexOf("-") + 1);
+function redirectsOfTables(db) {
+  const rows = db.query(`SELECT a.alias AS old_id, a.school_id AS new_id, a.kind AS kind,
+			        n.minted_reslug_from AS reslug_from, n.minted_reslug_pass AS reslug_pass
+			 FROM school_aliases a LEFT JOIN school_nodes n ON n.node_id = a.node_id
+			 WHERE a.kind IN ('fold', 'reslug') AND a.school_id IS NOT NULL
+			 UNION ALL
+			 SELECT f.node_id, f.closed_into, NULL,
+			        n.minted_reslug_from, n.minted_reslug_pass
+			 FROM school_nodes f LEFT JOIN school_nodes n ON n.node_id = f.closed_into
+			 WHERE f.kind = 'school' AND f.closed_into IS NOT NULL`).all();
+  const absorber = new Map;
+  for (const r of rows)
+    if (r.kind === null)
+      absorber.set(r.old_id, r.new_id);
+  const live = (id) => {
+    const seen = new Set;
+    let at = id;
+    for (let next = absorber.get(at);next !== undefined && !seen.has(at); next = absorber.get(at)) {
+      seen.add(at);
+      at = next;
+    }
+    return at;
+  };
+  return rows.map((r) => {
+    const named = r.reslug_from === r.old_id;
+    return {
+      old_id: r.old_id,
+      new_id: live(r.new_id),
+      kind: r.kind ?? (named || suffixOf(r.old_id) === suffixOf(r.new_id) ? "reslug" : "fold"),
+      since: num(named ? r.reslug_pass : null)
+    };
+  }).sort((a, b) => cmp(a.old_id, b.old_id) || cmp(a.new_id, b.new_id));
+}
+function lineageOfTables(db) {
+  const rows = db.query(`SELECT from_id, to_id, kind, valid_from, provisional, confidence, decision_rows
+			 FROM school_edges
+			 WHERE kind IN (${LINEAGE_KINDS.map(() => "?").join(", ")}) AND lag_months IS NULL`).all(...LINEAGE_KINDS);
+  const out = [];
+  for (const r of rows) {
+    const rowsBehind = r.decision_rows === null ? [] : JSON.parse(r.decision_rows).map(String);
+    const decision = rowsBehind[0] ?? null;
+    const end = (id, direction, other) => ({
+      id,
+      direction,
+      other,
+      shape: r.kind,
+      year: num(r.valid_from),
+      provisional: r.provisional === 1,
+      decision,
+      confidence: decision === null ? null : num(r.confidence)
+    });
+    out.push(end(r.from_id, "precedes", r.to_id), end(r.to_id, "succeeds", r.from_id));
+  }
+  return out.sort((a, b) => cmp(a.id, b.id) || cmp(a.year ?? -1, b.year ?? -1) || cmp(a.direction, b.direction) || cmp(a.other, b.other) || cmp(a.shape, b.shape));
+}
+
 var LINEAGE_FILE2 = "school-lineage.jsonl";
 var REDIRECTS_FILE = "school-redirects.jsonl";
 function linksOfLineage2(lines) {
@@ -1861,6 +1954,14 @@ function backingOf(r) {
   };
 }
 async function releaseSchoolGraph2(rel) {
+  const tables = await schoolTables(rel);
+  if (tables !== null) {
+    const to = new Map(redirectsOfTables(tables).map((r) => [r.old_id, r.new_id]));
+    return schoolGraph({
+      links: linksOfLineage2(lineageOfTables(tables)),
+      redirect: (id) => to.get(id) ?? null
+    });
+  }
   await rel.require("schools.lineage");
   await rel.fetch(LINEAGE_FILE2);
   const links = linksOfLineage2(readJsonl(rel.path(LINEAGE_FILE2)));
@@ -1880,7 +1981,7 @@ import {
 } from "@finbheara/domain/school";
 
 var str = (v) => typeof v === "string" && v !== "" ? v : null;
-var num = (v) => typeof v === "number" ? v : null;
+var num2 = (v) => typeof v === "number" ? v : null;
 var uniq = (xs) => [...new Set(xs)];
 async function registrySchools(rel) {
   await rel.require("schools.registry");
@@ -1913,17 +2014,23 @@ async function schoolPrints(rel, q) {
   return { tag: rel.tag, asked: q, prints };
 }
 async function schoolRedirects(rel) {
+  const tables = await schoolTables(rel);
+  if (tables !== null)
+    return { tag: rel.tag, redirects: redirectsOfTables(tables) };
   await rel.require("schools.redirects");
   await rel.fetch("school-redirects.jsonl");
   const redirects = readJsonl(rel.path("school-redirects.jsonl")).map((r) => ({
     old_id: String(r.old_id),
     new_id: String(r.new_id),
     kind: String(r.kind),
-    since: num(r.since)
+    since: num2(r.since)
   }));
   return { tag: rel.tag, redirects };
 }
 async function schoolLineage(rel) {
+  const tables = await schoolTables(rel);
+  if (tables !== null)
+    return { tag: rel.tag, edges: lineageOfTables(tables) };
   await rel.require("schools.lineage");
   await rel.fetch("school-lineage.jsonl");
   const edges = readJsonl(rel.path("school-lineage.jsonl")).map((r) => ({
@@ -1931,10 +2038,10 @@ async function schoolLineage(rel) {
     direction: String(r.direction),
     other: String(r.other),
     shape: String(r.shape),
-    year: num(r.year),
+    year: num2(r.year),
     provisional: r.provisional === true,
     decision: str(r.decision),
-    confidence: num(r.confidence)
+    confidence: num2(r.confidence)
   }));
   return { tag: rel.tag, edges };
 }
@@ -1948,7 +2055,7 @@ async function observedAssociations(rel, q) {
       continue;
     associations.push({
       at: String(r.at),
-      seq: num(r.seq) ?? 0,
+      seq: num2(r.seq) ?? 0,
       date: str(r.date),
       person: str(r.person),
       person_printed: typeof r.personPrinted === "string" ? r.personPrinted : "",
@@ -2193,6 +2300,7 @@ var PACKAGE_KEY_PARTS = [
   `domain=${domainPkg.version}`
 ];
 var ENCODER = personEncoder({ read: (p, o) => dancerName(p, o) });
+var surnameBlockOf = (surname) => surnameBlock(dancerName(`${surname}, X`, "surname-first").surnameKey());
 var PERSON = { table: "person", value: "id", valueType: "INTEGER PRIMARY KEY" };
 var ASKED = ["surname_key", "nn4", "blk_surname"];
 var dancersIndex = {
@@ -2403,6 +2511,9 @@ class DancerResolver2 {
   }
   lineage() {
     this.lineageOf ??= (async () => {
+      const tables = await schoolTables(this.rel);
+      if (tables !== null)
+        return schoolGraph2({ links: linksOfLineage2(lineageOfTables(tables)) });
       if ((await this.rel.capability("schools.lineage")).state !== "full")
         return null;
       await this.rel.fetch(LINEAGE_FILE2);
@@ -2557,7 +2668,7 @@ class DancerResolver2 {
     const hits = new Map;
     const names = createIndex2(db, ENCODER, PERSON);
     if (q.surname !== undefined) {
-      const block = surnameBlock(foldNameKey(q.surname).toUpperCase());
+      const block = surnameBlockOf(q.surname);
       if (block !== null)
         for (const { value } of names.rows({ blk_surname: [block] }, ["print"]))
           hits.set(value, "surname");
@@ -3807,7 +3918,7 @@ async function parquetColumns(path) {
 }
 
 var str2 = (v) => typeof v === "string" && v !== "" ? v : null;
-var num2 = (v) => typeof v === "number" ? v : null;
+var num3 = (v) => typeof v === "number" ? v : null;
 var strs = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
 var scope = (id) => id === null ? null : id >= FEIS_LOCAL_ID_FLOOR2 ? "per-release" : "stable";
 var TEAM_TABLES = [
@@ -3864,7 +3975,7 @@ var teamsIndex = {
     for (const r of t.event_years) {
       const k = str2(r.event_year);
       const event = str2(r.event);
-      const year = num2(r.year);
+      const year = num3(r.year);
       if (k === null || event === null || year === null)
         continue;
       ey.set(k, { event, year });
@@ -3873,19 +3984,19 @@ var teamsIndex = {
     const putR = out.prepare("INSERT OR IGNORE INTO result VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     let ord = 0;
     for (const r of t.team_results)
-      putR.run(str2(r.address), str2(r.slug), str2(r.event), num2(r.year), str2(r.card), str2(r.comp_no), str2(r.title), str2(r.category), num2(r.hands), str2(r.letter), str2(r.label), str2(r.name_printed), str2(r.school_printed), str2(r.school_loc), str2(r.school_id), num2(r.place), str2(r.place_printed), num2(r.tie), num2(r.competitors), JSON.stringify(strs(r.atts)), str2(r.age), str2(r.gender), JSON.stringify(strs(r.printed_status)), num2(r.competitors_printed), num2(r.recalled_only), ord++);
+      putR.run(str2(r.address), str2(r.slug), str2(r.event), num3(r.year), str2(r.card), str2(r.comp_no), str2(r.title), str2(r.category), num3(r.hands), str2(r.letter), str2(r.label), str2(r.name_printed), str2(r.school_printed), str2(r.school_loc), str2(r.school_id), num3(r.place), str2(r.place_printed), num3(r.tie), num3(r.competitors), JSON.stringify(strs(r.atts)), str2(r.age), str2(r.gender), JSON.stringify(strs(r.printed_status)), num3(r.competitors_printed), num3(r.recalled_only), ord++);
     const putT = out.prepare("INSERT OR IGNORE INTO roster_team VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of t.roster_teams) {
       const e = ey.get(str2(r.event_year) ?? "");
-      putT.run(str2(r.team), str2(r.kind), e?.event ?? null, num2(r.year) ?? e?.year ?? null, str2(r.comp_no), str2(r.title), str2(r.team_index), num2(r.seq), str2(r.school_id), str2(r.school_print_materialized), str2(r.dance), str2(r.school_print_as_of), ord++);
+      putT.run(str2(r.team), str2(r.kind), e?.event ?? null, num3(r.year) ?? e?.year ?? null, str2(r.comp_no), str2(r.title), str2(r.team_index), num3(r.seq), str2(r.school_id), str2(r.school_print_materialized), str2(r.dance), str2(r.school_print_as_of), ord++);
     }
     const putM = out.prepare("INSERT INTO roster_member VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of t.roster_members)
-      putM.run(str2(r.team), num2(r.seq), typeof r.name_printed === "string" ? r.name_printed : "", str2(r.name), num2(r.yob), num2(r.dancer_id), str2(r.gender), ord++);
+      putM.run(str2(r.team), num3(r.seq), typeof r.name_printed === "string" ? r.name_printed : "", str2(r.name), num3(r.yob), num3(r.dancer_id), str2(r.gender), ord++);
     const putJ = out.prepare("INSERT INTO result_roster VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of t.team_result_rosters) {
       const e = ey.get(str2(r.event_year) ?? "");
-      putJ.run(str2(r.team), e?.event ?? null, e?.year ?? null, str2(r.comp_no), str2(r.school_id), str2(r.result_address), str2(r.join_kind), num2(r.via_split) === 1 ? 1 : 0, num2(r.roster_teams), num2(r.result_teams), str2(r.roster_index), str2(r.result_letter), ord++);
+      putJ.run(str2(r.team), e?.event ?? null, e?.year ?? null, str2(r.comp_no), str2(r.school_id), str2(r.result_address), str2(r.join_kind), num3(r.via_split) === 1 ? 1 : 0, num3(r.roster_teams), num3(r.result_teams), str2(r.roster_index), str2(r.result_letter), ord++);
     }
     for (const s of TEAMS_INDEXES)
       out.run(s);
@@ -3906,10 +4017,10 @@ var eventsIndex = {
     const put = out.prepare("INSERT OR IGNORE INTO event_year VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of rows) {
       const event = str2(r.event);
-      const year = num2(r.year);
+      const year = num3(r.year);
       if (event === null || year === null)
         continue;
-      put.run(event, year, str2(r.date_lo), str2(r.date_hi), str2(r.resolution), str2(r.source), JSON.stringify(strs(r.date_printed)), str2(r.place), JSON.stringify(strs(r.place_printed)), str2(r.published), num2(r.listed));
+      put.run(event, year, str2(r.date_lo), str2(r.date_hi), str2(r.resolution), str2(r.source), JSON.stringify(strs(r.date_printed)), str2(r.place), JSON.stringify(strs(r.place_printed)), str2(r.published), num3(r.listed));
     }
     out.run("CREATE INDEX event_year_event ON event_year(event COLLATE NOCASE)");
   }

package/dist/cli.js

@@ -23,7 +23,7 @@ import {
   staleWarning2,
   progressMode2,
   progressRenderer2
-} from "./chunks/index-6np7hsst.js";
+} from "./chunks/index-aj1n1q7j.js";
 import"./chunks/index-hghdy980.js";
 
 var USAGE_HEADER = "usage: idq <verb> [--cache <dir>] [--repo <owner/name>] [--json] [--live] [--progress tty|plain|none]";

package/dist/index.js

@@ -85,7 +85,7 @@ import {
   PROGRESS_MODES2,
   progressMode2,
   progressRenderer2
-} from "./chunks/index-6np7hsst.js";
+} from "./chunks/index-aj1n1q7j.js";
 import {
   cacheRoot2,
   repoOf2

package/dist/types/dancers.d.ts

@@ -182,6 +182,7 @@ export interface DancerRecord {
     schools: DancerSchool[];
 }
 export declare const PACKAGE_KEY_PARTS: readonly string[];
+export declare const surnameBlockOf: (surname: string) => string | null;
 export declare const dancersIndex: IndexBuilder;
 export declare function yearOf(asOf: string | undefined): number | null;
 export interface DancerBulkRecord {

package/dist/types/school-tables.d.ts

@@ -0,0 +1,8 @@
+import type { Database } from "bun:sqlite";
+import type { Release } from "./release.js";
+import type { LineageEdge, SchoolRedirect } from "./school-bulk.js";
+export declare const SCHOOL_GRAPH_FEATURE = "school-graph";
+export declare const LINEAGE_KINDS: readonly string[];
+export declare function schoolTables(rel: Release): Promise<Database | null>;
+export declare function redirectsOfTables(db: Database): SchoolRedirect[];
+export declare function lineageOfTables(db: Database): LineageEdge[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@finbheara/archive-client",
-	"version": "0.53.0",
+	"version": "0.53.1",
 	"description": "Open a versioned release of an Irish dance results archive: download, verify, decompress and cache it by tag, keep the cache, and resolve feises and schools against it",
 	"keywords": ["irish-dance", "results", "release", "cache", "sqlite"],
 	"license": "MIT",
@@ -44,8 +44,8 @@
 		"prepublishOnly": "bun scripts/build.ts && bun ../../tools/checks/archive-client-tarball.ts"
 	},
 	"dependencies": {
-		"@finbheara/domain": "0.59.0",
-		"@finbheara/names": "0.30.0",
+		"@finbheara/domain": "0.60.1",
+		"@finbheara/names": "0.31.0",
 		"hyparquet": "1.31.2"
 	},
 	"devDependencies": {