@finbheara/archive-client 0.24.0 → 0.25.0

package/README.md

@@ -95,6 +95,13 @@ c.features;   // [{ feature: "dancers", state: "full" | "missing", missing: [...
 | `teams` | `teams.results`, `teams.rosters`, `teams.resultRosters` | 260 |
 | `teams.fields` | the fields `teams.results` (`age`, `gender`, `printed_status`) and `teams.rosters` (`dance`, `school_printed_as_of`, a member's `gender`) carry; absent, never refused, without it | 266 |
 | `events` | `events.years` | 260 |
+| `tabs`, `panels` | `tabs.query`, `tabs.stream`; `panels.query` | 184 |
+| `feis-panels` | `feisPanels.query` | 260 |
+| `staff.adjudicators` | `staff.adjudicators` | 230 |
+| `schools.registry` | `schools.list` | 260 |
+| `schools.prints`, `schools.redirects` | `schools.prints`; `schools.redirects` | 184 |
+| `schools.lineage` | `schools.links`, `schools.line`, `schools.lineage` | 184 |
+| `schools.associations` | `schools.associations` | 215 |
 
 A spec is `pinned` (the default: the user-local pin, else the latest), `latest`, a cut number
 (`42`, or `42.1` for a fraction) or a tag (`archive-YYYY.MM.DD-N`).
@@ -227,6 +234,29 @@ rows were published under and their rows, so it agrees with each print lookup of
 
 Every answer carries the release tag it came from.
 
+### The schools in bulk
+
+```ts
+await rel.schools.list();          // { schools: [{ school_id, display, regions, places }] }: the registry
+await rel.schools.prints({ event: "<event>", year: 2024 });
+                                   // { prints: [{ event, year, print, school_id, rows }] }
+await rel.schools.redirects();     // { redirects: [{ old_id, new_id, kind, since }] }
+await rel.schools.lineage();       // { edges: [{ id, direction, other, shape, year, provisional,
+                                   //             decision, confidence }] }
+await rel.schools.associations({ school_id: "<id>" });
+                                   // { associations: [{ at, seq, date, person, person_printed,
+                                   //   person_type, credentials, caption, school_printed, school_id,
+                                   //   association_type, src_type, src, candidate_school_id, candidate_rung, ... }] }
+```
+
+`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`'.
+`lineage` is each edge end as the release publishes it (an edge may carry both ends): `links` and
+`line` are the graph over them. `associations` is the people a directory lists beside a school, as
+evidence of an association, never an identity: `school_id` is the school the print attached to,
+`candidate_school_id` one it reached without attaching.
+
 ### How two schools are linked
 
 ```ts
@@ -550,6 +580,33 @@ await rel.feises.dates();                      // every feis id with its first a
 await rel.majors.tabulated({ min_true_round: 3 });     // the majors addresses marked to round 3 or later
 ```
 
+## Marks sheets and panels
+
+```ts
+const s = await rel.tabs.query({ competition: "<competition>" });   // or { address }, and a { round }
+s.rows;      // [{ address, competition, card, line, event, year, tier, round, true_round, seat_index,
+             //    section, panel_size, column_order, drop_rule, the judge (name, print, TD number,
+             //    id, unmatched reason), mark, mark_printed, place, place_printed, tie, points,
+             //    points_printed }]
+for await (const t of rel.tabs.stream({ tier: ["T1", "T2", "T3"], year: [2015, 2025] })) ...
+await rel.panels.query({ competition: "<competition>" });  // { seats: [{ competition, panel, round,
+             //    seat_index, address, the judge (print, TD number, id, unmatched reason) }] }
+await rel.feisPanels.query({ address: "fweb:<code>.<comp>" });  // { seats: [{ address, platform, round,
+             //    seat_index, panel_size, panel_kind, the judge (print, state printed, TD number, id,
+             //    unmatched reason, basis) }] }
+```
+
+A marks sheet is a row per card, round and seat, with the seat's mark, place and points as read
+beside their prints, from `results.sqlite` (every tabulated sheet, the T4 events' too). The stream
+takes an event (or several, case-blind), a year or an inclusive range, tiers, competitions, or
+nothing (every cell), and yields one competition's rows together. A sheet's `event`, `year` and
+`tier` are its competition's: a solo competition's from the results, a team competition's from the
+team results (with the tier the release gives that event-year's solo competitions). A sheet the
+release places in neither carries nulls, and a filter on them never reaches it. `panels` and
+`feisPanels` with nothing named answer every seat. `round` is `rx` where one panel sat every round.
+A seat carries its judge's TD number where the release linked one, else a judge id, else the
+reason it is linked to neither (`TabRow`, `PanelSeat` and `FeisPanelSeat` name the fields).
+
 ## Teams and event-years
 
 ```ts
@@ -596,6 +653,9 @@ release into the `teams` and `events` indexes.
 ```ts
 await rel.staff.teacher("<name>");        // or a TD number
 await rel.staff.adjudicator("<name>");
+await rel.staff.adjudicators({ year: 2025 });   // the register's rows (or a TD number's, or every one):
+       // [{ the TD number, year, cat, name_printed, country, country_printed, country_code, region,
+       //    region_printed, region_code, geohash, src }] (`RegisterRow`)
 ```
 
 One person per TD number (else per judge id, else per name): the schools taught at (role,
@@ -747,6 +807,13 @@ is passed to the dancer resolver as asked (`rel.dancers`, above).
     idq records --years [--release <spec>] [--dancer <id,...>] [--year <y>]
     idq feis-dates [--release <spec>]
     idq tabulated [--release <spec>] [--min-round <n>]
+    idq tabs [--release <spec>] --comp <competition> | --address <address> [--round <r>]
+    idq tabs --stream [--release <spec>] [--comp <c,...>] [--event <e,...>] [--year <y> | --year <from>..<to>] [--tier <t,...>]
+    idq panels [--release <spec>] [--comp <competition>]
+    idq feis-panels [--release <spec>] [--address <feis competition>] [--platform <p>]
+    idq register [--release <spec>] [--year <y>] [--td <TD number>]
+    idq schools [--release <spec>] [--prints [--event <e>] [--year <y>] | --redirects | --lineage
+                | --associations [--school <school_id>]]
     idq teams [--release <spec>] [--event <e>] [--year <y>] [--rosters | --joins]
     idq events [--release <spec>] [--event <e>] [--year <y>]
     idq teacher [--release <spec>] <name|TD number>
@@ -759,7 +826,7 @@ is passed to the dancer resolver as asked (`rel.dancers`, above).
                        [--oireachtas <region>[:<year>]]
     idq resolve registrations
 
-`stream` prints one JSON line per row (or entry), as it reads them. `dancer` prints the results of the one dancer where the answer is unique (every candidate's with
+`stream` (and `tabs --stream`) prints one JSON line per row (or entry, or cell), as it reads them. `dancer` prints the results of the one dancer where the answer is unique (every candidate's with
 `--rows`). `--json` prints the call's answer as it is. `--cache` and `--repo` override the defaults.
 
 `update` moves to the newest published release, as a package manager's `update` moves to the newest

package/dist/chunks/{index-vsk6837c.js → index-2ms980hc.js}

@@ -774,6 +774,96 @@ import {
   DEFAULT_SCHOOL_NAME_READER,
   schoolEncoder
 } from "@finbheara/domain/school";
+
+var str = (v) => typeof v === "string" && v !== "" ? v : null;
+var num = (v) => typeof v === "number" ? v : null;
+var uniq = (xs) => [...new Set(xs)];
+async function registrySchools(rel) {
+  await rel.require("schools.registry");
+  await rel.fetch("school-registry.jsonl");
+  const schools = readJsonl(rel.path("school-registry.jsonl")).map((r) => ({
+    school_id: r.school_id,
+    display: r.display,
+    regions: uniq((r.regions ?? []).map((x) => x.region)),
+    places: uniq((r.locations ?? []).map((x) => x.place))
+  })).sort((a, b) => a.school_id < b.school_id ? -1 : a.school_id > b.school_id ? 1 : 0);
+  return { tag: rel.tag, schools };
+}
+async function schoolPrints(rel, q) {
+  await rel.fetch("results");
+  await rel.require("schools.prints");
+  const where = ["r.school_id IS NOT NULL"];
+  const args = [];
+  if (q.event !== undefined) {
+    where.push("c.event = ? COLLATE NOCASE");
+    args.push(q.event);
+  }
+  if (q.year !== undefined) {
+    where.push("c.year = ?");
+    args.push(q.year);
+  }
+  const prints = rel.db("results").query(`SELECT c.event AS event, c.year AS year, trim(r.school_printed) AS print,
+			        r.school_id AS school_id, count(*) AS rows
+			 FROM competitions c JOIN results r ON r.file = c.file AND r.competition_line = c.line
+			 WHERE ${where.join(" AND ")} GROUP BY 1, 2, 3, 4 ORDER BY 2, 1, 3, 4`).all(...args);
+  return { tag: rel.tag, asked: q, prints };
+}
+async function schoolRedirects(rel) {
+  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)
+  }));
+  return { tag: rel.tag, redirects };
+}
+async function schoolLineage(rel) {
+  await rel.require("schools.lineage");
+  await rel.fetch("school-lineage.jsonl");
+  const edges = readJsonl(rel.path("school-lineage.jsonl")).map((r) => ({
+    id: String(r.id),
+    direction: String(r.direction),
+    other: String(r.other),
+    shape: String(r.shape),
+    year: num(r.year),
+    provisional: r.provisional === true,
+    decision: str(r.decision),
+    confidence: num(r.confidence)
+  }));
+  return { tag: rel.tag, edges };
+}
+async function observedAssociations(rel, q) {
+  await rel.require("schools.associations");
+  await rel.fetch("observed-associations.jsonl");
+  const associations = [];
+  for (const r of readJsonl(rel.path("observed-associations.jsonl"))) {
+    const school_id = str(r.schoolId);
+    if (q.school_id !== undefined && school_id !== q.school_id)
+      continue;
+    associations.push({
+      at: String(r.at),
+      seq: num(r.seq) ?? 0,
+      date: str(r.date),
+      person: str(r.person),
+      person_printed: typeof r.personPrinted === "string" ? r.personPrinted : "",
+      reading: str(r.reading),
+      person_type: str(r.personType),
+      credentials: str(r.credentials),
+      caption: str(r.caption),
+      school_printed: str(r.school),
+      school_id,
+      association_type: str(r.associationType),
+      src_type: str(r.srcType),
+      src: str(r.src),
+      candidate_school_id: str(r.candidateSchoolId),
+      candidate_rung: str(r.candidateRung)
+    });
+  }
+  return { tag: rel.tag, asked: q, associations };
+}
+
 function readsSpanishNames2(candidates) {
   return candidates.some((c) => c.spanishNames !== undefined && (c.spanishNames.file || c.prints.some((p) => c.spanishNames?.prints.includes(p.trim()))));
 }
@@ -846,6 +936,21 @@ class SchoolResolver2 {
     this.graph ??= releaseSchoolGraph2(this.rel);
     return { tag: this.rel.tag, ...(await this.graph).line(a.trim(), q) };
   }
+  list() {
+    return registrySchools(this.rel);
+  }
+  prints(q = {}) {
+    return schoolPrints(this.rel, q);
+  }
+  redirects() {
+    return schoolRedirects(this.rel);
+  }
+  lineage() {
+    return schoolLineage(this.rel);
+  }
+  associations(q = {}) {
+    return observedAssociations(this.rel, q);
+  }
   async resolve(asked, q = {}) {
     const db = await this.rel.indexDb("schools");
     const reg = db.query("SELECT display, regions, places, spanish FROM registry WHERE school_id = ?");
@@ -2246,6 +2351,218 @@ import {
   roleEncoder
 } from "@finbheara/domain/noun-index";
 import { roleName } from "@finbheara/domain/person";
+
+var TAB_COLUMNS = `address, slug AS competition, card, line, round, true_round, seat_index,
+	section, panel_size, column_order, drop_rule, judge_name, judge_name_printed, judge_clrg,
+	judge_id, judge_unmatched, mark, mark_printed, place, place_printed, tie, points, points_printed`;
+var TAB_NEEDS = [
+  "address",
+  "slug",
+  "card",
+  "line",
+  "round",
+  "true_round",
+  "seat_index",
+  "section",
+  "panel_size",
+  "column_order",
+  "drop_rule",
+  "judge_name",
+  "judge_name_printed",
+  "judge_clrg",
+  "judge_id",
+  "judge_unmatched",
+  "mark",
+  "mark_printed",
+  "place",
+  "place_printed",
+  "tie",
+  "points",
+  "points_printed"
+].map((c) => `results:tabs.${c}`);
+var NO_SHEET = { event: null, year: null, tier: null };
+var cardRange = (competition) => [`${competition}#`, `${competition}$`];
+
+class TabFinder2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async db() {
+    await this.rel.fetch("results");
+    await this.rel.require("tabs");
+    return this.rel.db("results");
+  }
+  async sheets(db, only) {
+    const out = new Map;
+    const tiers = new Map;
+    const rows = [];
+    if (only === null)
+      rows.push(...db.query("SELECT competition, event, year, tier FROM competitions WHERE competition IN (SELECT DISTINCT slug FROM tabs)").all());
+    else
+      for (let i = 0;i < only.length; i += 500) {
+        const part = only.slice(i, i + 500);
+        rows.push(...db.query(`SELECT competition, event, year, tier FROM competitions WHERE competition IN (${part.map(() => "?").join(", ")})`).all(...part));
+      }
+    for (const r of rows) {
+      out.set(r.competition, { event: r.event, year: r.year, tier: r.tier });
+      tiers.set(`${r.event.toLowerCase()}\x00${r.year}`, r.tier);
+    }
+    const missing = only === null ? null : only.filter((c) => !out.has(c));
+    if (missing !== null && missing.length === 0)
+      return out;
+    if ((await this.rel.capability("teams")).state !== "full")
+      return out;
+    const teams = await this.rel.indexDb("teams");
+    const team = teams.query("SELECT competition, event, year FROM result WHERE competition IS NOT NULL GROUP BY competition");
+    const want = missing === null ? null : new Set(missing);
+    for (const t of team.all()) {
+      if (out.has(t.competition) || want !== null && !want.has(t.competition))
+        continue;
+      out.set(t.competition, {
+        event: t.event,
+        year: t.year,
+        tier: tiers.get(`${t.event.toLowerCase()}\x00${t.year}`) ?? null
+      });
+    }
+    if ([...out.values()].some((s) => s.tier === null && s.event !== null)) {
+      for (const r of db.query("SELECT event, year, min(tier) AS tier FROM competitions GROUP BY event, year").all())
+        tiers.set(`${r.event.toLowerCase()}\x00${r.year}`, r.tier);
+      for (const s of out.values())
+        if (s.tier === null && s.event !== null)
+          s.tier = tiers.get(`${s.event.toLowerCase()}\x00${s.year}`) ?? null;
+    }
+    return out;
+  }
+  async query(q) {
+    const db = await this.db();
+    const where = [];
+    const args = [];
+    if (q.address !== undefined) {
+      where.push("address = ?");
+      args.push(q.address);
+    } else if (q.competition !== undefined) {
+      const [lo, hi] = cardRange(q.competition);
+      where.push("address >= ? AND address < ? AND slug = ?");
+      args.push(lo, hi, q.competition);
+    } else
+      throw new Error("archive-client: a tabs query names a competition or an address");
+    if (q.round !== undefined) {
+      where.push("round = ?");
+      args.push(q.round);
+    }
+    const raw = db.query(`SELECT ${TAB_COLUMNS} FROM tabs WHERE ${where.join(" AND ")} ORDER BY address, round, seat_index, line`).all(...args);
+    const sheets = raw.length === 0 ? new Map : await this.sheets(db, [...new Set(raw.map((r) => r.competition))]);
+    return {
+      tag: this.rel.tag,
+      asked: q,
+      rows: raw.map((r) => ({ ...r, ...sheets.get(r.competition) ?? NO_SHEET }))
+    };
+  }
+  async* stream(q = {}) {
+    const db = await this.db();
+    const sheets = await this.sheets(db, q.competition ?? null);
+    const events = q.event === undefined ? null : new Set((typeof q.event === "string" ? [q.event] : q.event).map((e) => e.toLowerCase()));
+    const tiers = q.tier === undefined ? null : new Set(q.tier);
+    const holds = (s) => {
+      if (events !== null && (s.event === null || !events.has(s.event.toLowerCase())))
+        return false;
+      if (tiers !== null && (s.tier === null || !tiers.has(s.tier)))
+        return false;
+      if (typeof q.year === "number" && s.year !== q.year)
+        return false;
+      if (Array.isArray(q.year) && (s.year === null || s.year < q.year[0] || s.year > q.year[1]))
+        return false;
+      return true;
+    };
+    const filtered = events !== null || tiers !== null || q.year !== undefined;
+    const run = function* (stmt, args) {
+      for (const r of stmt.iterate(...args))
+        yield { ...r, ...sheets.get(r.competition) ?? NO_SHEET };
+    };
+    if (!filtered && q.competition === undefined) {
+      const all = db.prepare(`SELECT ${TAB_COLUMNS} FROM tabs ORDER BY address, round, seat_index, line`);
+      try {
+        yield* run(all, []);
+      } finally {
+        all.finalize();
+      }
+      return;
+    }
+    const asked = [...new Set(q.competition ?? sheets.keys())].filter((c) => holds(sheets.get(c) ?? NO_SHEET));
+    const one = db.prepare(`SELECT ${TAB_COLUMNS} FROM tabs WHERE address >= ? AND address < ? AND slug = ? ORDER BY address, round, seat_index, line`);
+    try {
+      for (const c of asked.sort((a, b) => a < b ? -1 : a > b ? 1 : 0)) {
+        const [lo, hi] = cardRange(c);
+        yield* run(one, [lo, hi, c]);
+      }
+    } finally {
+      one.finalize();
+    }
+  }
+}
+
+class PanelFinder2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async query(q = {}) {
+    await this.rel.fetch("results");
+    await this.rel.require("panels");
+    const where = q.competition === undefined ? "" : " WHERE slug = ?";
+    const seats = this.rel.db("results").query(`SELECT slug AS competition, panel, round, seat_index, address, judge_name_printed,
+				        judge_clrg, judge_id, judge_unmatched
+				 FROM panels${where} ORDER BY slug, panel, round, seat_index`).all(...q.competition === undefined ? [] : [q.competition]);
+    return { tag: this.rel.tag, asked: q, seats };
+  }
+}
+
+class FeisPanelFinder2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async query(q = {}) {
+    await this.rel.fetch("results");
+    await this.rel.require("feis-panels");
+    const where = [];
+    const args = [];
+    if (q.address !== undefined) {
+      where.push("address = ?");
+      args.push(q.address);
+    }
+    if (q.platform !== undefined) {
+      where.push("platform = ?");
+      args.push(q.platform);
+    }
+    const seats = this.rel.db("results").query(`SELECT address, platform, round, seat_index, panel_size, panel_kind, judge_name_printed,
+				        judge_state_printed, judge_clrg, judge_id, judge_unmatched, judge_basis
+				 FROM feis_panels${where.length === 0 ? "" : ` WHERE ${where.join(" AND ")}`}
+				 ORDER BY address, round, seat_index`).all(...args);
+    return { tag: this.rel.tag, asked: q, seats };
+  }
+}
+async function registerRows(rel, q) {
+  await rel.fetch("results");
+  await rel.require("staff.adjudicators");
+  const where = [];
+  const args = [];
+  if (q.judge_clrg !== undefined) {
+    where.push("judge_clrg = ?");
+    args.push(q.judge_clrg);
+  }
+  if (q.year !== undefined) {
+    where.push("year = ?");
+    args.push(q.year);
+  }
+  const rows = rel.db("results").query(`SELECT judge_clrg, year, cat, name_printed, country, country_printed, country_code, region,
+			        region_printed, region_code, geohash, src
+			 FROM adjudicators${where.length === 0 ? "" : ` WHERE ${where.join(" AND ")}`}
+			 ORDER BY judge_clrg, year`).all(...args);
+  return { tag: rel.tag, asked: q, rows };
+}
+
 var ENCODER2 = roleEncoder();
 var WHO = { table: "who", value: "entry", valueType: "INTEGER PRIMARY KEY" };
 var ASKED2 = ["surname_key", "nn4", "id"];
@@ -2363,6 +2680,9 @@ class StaffFinder2 {
   adjudicator(asked) {
     return this.find(asked, "adjudicator");
   }
+  adjudicators(q = {}) {
+    return registerRows(this.rel, q);
+  }
   async find(asked, role) {
     const db = await this.rel.indexDb("staff");
     const a = asked.trim();
@@ -2507,8 +2827,8 @@ async function parquetColumns(path) {
   return new Set(parquetSchema(meta).children.map((c) => c.element.name));
 }
 
-var str = (v) => typeof v === "string" && v !== "" ? v : null;
-var num = (v) => typeof v === "number" ? v : null;
+var str2 = (v) => typeof v === "string" && v !== "" ? v : null;
+var num2 = (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 = [
@@ -2563,9 +2883,9 @@ var teamsIndex = {
     const ey = new Map;
     const putEy = out.prepare("INSERT OR IGNORE INTO event_year VALUES (?, ?, ?)");
     for (const r of t.event_years) {
-      const k = str(r.event_year);
-      const event = str(r.event);
-      const year = num(r.year);
+      const k = str2(r.event_year);
+      const event = str2(r.event);
+      const year = num2(r.year);
       if (k === null || event === null || year === null)
         continue;
       ey.set(k, { event, year });
@@ -2574,19 +2894,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(str(r.address), str(r.slug), str(r.event), num(r.year), str(r.card), str(r.comp_no), str(r.title), str(r.category), num(r.hands), str(r.letter), str(r.label), str(r.name_printed), str(r.school_printed), str(r.school_loc), str(r.school_id), num(r.place), str(r.place_printed), num(r.tie), num(r.competitors), JSON.stringify(strs(r.atts)), str(r.age), str(r.gender), JSON.stringify(strs(r.printed_status)), ord++);
+      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)), ord++);
     const putT = out.prepare("INSERT OR IGNORE INTO roster_team VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of t.roster_teams) {
-      const e = ey.get(str(r.event_year) ?? "");
-      putT.run(str(r.team), str(r.kind), e?.event ?? null, num(r.year) ?? e?.year ?? null, str(r.comp_no), str(r.title), str(r.team_index), num(r.seq), str(r.school_id), str(r.school_print_materialized), str(r.dance), str(r.school_print_as_of), ord++);
+      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++);
     }
     const putM = out.prepare("INSERT INTO roster_member VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of t.roster_members)
-      putM.run(str(r.team), num(r.seq), typeof r.name_printed === "string" ? r.name_printed : "", str(r.name), num(r.yob), num(r.dancer_id), str(r.gender), ord++);
+      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++);
     const putJ = out.prepare("INSERT INTO result_roster VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of t.team_result_rosters) {
-      const e = ey.get(str(r.event_year) ?? "");
-      putJ.run(str(r.team), e?.event ?? null, e?.year ?? null, str(r.comp_no), str(r.school_id), str(r.result_address), str(r.join_kind), num(r.via_split) === 1 ? 1 : 0, num(r.roster_teams), num(r.result_teams), str(r.roster_index), str(r.result_letter), ord++);
+      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++);
     }
     for (const s of TEAMS_INDEXES)
       out.run(s);
@@ -2606,11 +2926,11 @@ var eventsIndex = {
     out.run(EVENTS_SCHEMA);
     const put = out.prepare("INSERT OR IGNORE INTO event_year VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
     for (const r of rows) {
-      const event = str(r.event);
-      const year = num(r.year);
+      const event = str2(r.event);
+      const year = num2(r.year);
       if (event === null || year === null)
         continue;
-      put.run(event, year, str(r.date_lo), str(r.date_hi), str(r.resolution), str(r.source), JSON.stringify(strs(r.date_printed)), str(r.place), JSON.stringify(strs(r.place_printed)));
+      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)));
     }
     out.run("CREATE INDEX event_year_event ON event_year(event COLLATE NOCASE)");
   }
@@ -3238,7 +3558,7 @@ var FEATURES2 = [
     feature: "schools.lineage",
     needs: ["school-lineage.jsonl"],
     since: 184,
-    calls: "schools.links and schools.line (refused on a release without it), and the `lineage` school evidence of dancers.resolve and dancers.search: no school is joined by lineage, never refused, on a release without it"
+    calls: "schools.links, schools.line and schools.lineage (refused on a release without it), and the `lineage` school evidence of dancers.resolve and dancers.search: no school is joined by lineage, never refused, on a release without it"
   },
   {
     feature: "results.stream",
@@ -3407,6 +3727,91 @@ var FEATURES2 = [
     ],
     since: 260,
     calls: "staff.teacher, staff.adjudicator (the staff index)"
+  },
+  { feature: "tabs", needs: TAB_NEEDS, since: 184, calls: "tabs.query, tabs.stream" },
+  {
+    feature: "panels",
+    needs: [
+      "slug",
+      "panel",
+      "round",
+      "seat_index",
+      "address",
+      "judge_name_printed",
+      "judge_clrg",
+      "judge_id",
+      "judge_unmatched"
+    ].map((c) => `results:panels.${c}`),
+    since: 184,
+    calls: "panels.query"
+  },
+  {
+    feature: "feis-panels",
+    needs: [
+      "address",
+      "platform",
+      "round",
+      "seat_index",
+      "panel_size",
+      "panel_kind",
+      "judge_name_printed",
+      "judge_state_printed",
+      "judge_clrg",
+      "judge_id",
+      "judge_unmatched",
+      "judge_basis"
+    ].map((c) => `results:feis_panels.${c}`),
+    since: 260,
+    calls: "feisPanels.query"
+  },
+  {
+    feature: "staff.adjudicators",
+    needs: [
+      "judge_clrg",
+      "year",
+      "cat",
+      "name_printed",
+      "country",
+      "country_printed",
+      "country_code",
+      "region",
+      "region_printed",
+      "region_code",
+      "geohash",
+      "src"
+    ].map((c) => `results:adjudicators.${c}`),
+    since: 230,
+    calls: "staff.adjudicators"
+  },
+  {
+    feature: "schools.registry",
+    needs: ["school-registry.jsonl"],
+    since: 260,
+    calls: "schools.list"
+  },
+  {
+    feature: "schools.prints",
+    needs: [
+      "results:results.school_printed",
+      "results:results.school_id",
+      "results:results.competition_line",
+      "results:competitions.event",
+      "results:competitions.year"
+    ],
+    since: 184,
+    calls: "schools.prints"
+  },
+  {
+    feature: "schools.redirects",
+    needs: ["school-redirects.jsonl"],
+    since: 184,
+    calls: "schools.redirects"
+  },
+  {
+    feature: "schools.associations",
+    needs: ["observed-associations.jsonl"],
+    since: 215,
+    calls: "schools.associations"
   }
 ];
 async function hasNeed(probe, n) {
@@ -3490,6 +3895,9 @@ class Release2 {
   registrations;
   teams;
   events;
+  tabs;
+  panels;
+  feisPanels;
   opts;
   handles = new Map;
   remoteAssets = null;
@@ -3512,6 +3920,9 @@ class Release2 {
     this.registrations = new RegistrationResolver2(this, this.comps, opts.dancerResolver);
     this.teams = new TeamFinder2(this);
     this.events = new EventFinder2(this);
+    this.tabs = new TabFinder2(this);
+    this.panels = new PanelFinder2(this);
+    this.feisPanels = new FeisPanelFinder2(this);
   }
   receipt() {
     return readReceipt(this.dir) ?? { tag: this.tag, source: "unknown", files: {} };
@@ -4232,4 +4643,4 @@ function staleWarning2(answered, latest, floor, tags = [], command = "idq") {
   return `answered from ${answered}. ${floorTag ?? `cut ${floor.cut}`} is required${why}: run \`${command} use ${floor.cut}\` to get it`;
 }
 
-export { DATABASES2, planAsset2, sha256File2, unzstdTo2, NAME_LEVELS2, nameLevel2, NO_CALENDAR2, FeisFinder2, ADVANCEMENT_DANCES2, entryRank2, FEIS_LOCAL_ID_FLOOR2, ResultFinder2, MajorsFinder2, LINEAGE_FILE2, linksOfLineage2, releaseSchoolGraph2, readsSpanishNames2, SchoolResolver2, initialsOnly2, nameOrderOf, DancerResolver2, readPopulation2, syllabusSourceOf2, canonicalOf2, CompResolver2, StaffFinder2, TeamFinder2, EventFinder2, defaultBuilders2, indexPath2, indexKey2, isCurrent2, buildIndex2, ensureIndex2, listIndexes2, readPin2, youngest2, dancerResolverOf2, RegistrationResolver2, ghRemote2, httpsRemote2, fallbackRemote2, setRemote2, defaultRemote, columnsOf2, FEATURES2, capabilityOf2, needsRelease2, resolveTag2, Release2, openRelease2, openCached2, DEFAULT_KEEP2, ReleaseManager2, releases2, LOCAL_DIR2, localRoot2, newerThan2, incomplete2, releaseVersion2, pickBuild2, buildTag2, lacks, openBuild2, sweepBuilds2, LATEST_CHECK_MS2, LATEST_CHECK_BUDGET_MS2, latestCheckPath2, readLatestCheck2, latestCheck2, within, staleWarning2 };
+export { DATABASES2, planAsset2, sha256File2, unzstdTo2, NAME_LEVELS2, nameLevel2, NO_CALENDAR2, FeisFinder2, ADVANCEMENT_DANCES2, entryRank2, FEIS_LOCAL_ID_FLOOR2, ResultFinder2, MajorsFinder2, LINEAGE_FILE2, linksOfLineage2, releaseSchoolGraph2, readsSpanishNames2, SchoolResolver2, initialsOnly2, nameOrderOf, DancerResolver2, readPopulation2, syllabusSourceOf2, canonicalOf2, CompResolver2, TabFinder2, PanelFinder2, FeisPanelFinder2, StaffFinder2, TeamFinder2, EventFinder2, defaultBuilders2, indexPath2, indexKey2, isCurrent2, buildIndex2, ensureIndex2, listIndexes2, readPin2, youngest2, dancerResolverOf2, RegistrationResolver2, ghRemote2, httpsRemote2, fallbackRemote2, setRemote2, defaultRemote, columnsOf2, FEATURES2, capabilityOf2, needsRelease2, resolveTag2, Release2, openRelease2, openCached2, DEFAULT_KEEP2, ReleaseManager2, releases2, LOCAL_DIR2, localRoot2, newerThan2, incomplete2, releaseVersion2, pickBuild2, buildTag2, lacks, openBuild2, sweepBuilds2, LATEST_CHECK_MS2, LATEST_CHECK_BUDGET_MS2, latestCheckPath2, readLatestCheck2, latestCheck2, within, staleWarning2 };

package/dist/cli.js

@@ -21,7 +21,7 @@ import {
   latestCheck2,
   within,
   staleWarning2
-} from "./chunks/index-vsk6837c.js";
+} from "./chunks/index-2ms980hc.js";
 import"./chunks/index-hghdy980.js";
 
 var USAGE_HEADER = "usage: idq <verb> [--cache <dir>] [--repo <owner/name>] [--json] [--live]";
@@ -285,6 +285,61 @@ var VERBS = [
       "                                    or later (default 3)"
     ]
   },
+  {
+    verb: "tabs",
+    value: ["--release", "--comp", "--address", "--round", "--event", "--year", "--tier"],
+    bool: ["--stream"],
+    usage: [
+      "  tabs [--release <spec>] --comp <competition> | --address <address> [--round <r>]",
+      "                                    a marks sheet (or one card of it): every seat's mark,",
+      "                                    place and points, with the judge",
+      "  tabs --stream [--release <spec>] [--comp <c,...>] [--event <e,...>]",
+      "       [--year <y> | --year <from>..<to>] [--tier <t,...>]",
+      "                                    every cell of every sheet named, one JSON line each"
+    ]
+  },
+  {
+    verb: "panels",
+    value: ["--release", "--comp"],
+    bool: [],
+    usage: [
+      "  panels [--release <spec>] [--comp <competition>]",
+      "                                    who sat a major's competition (every one's, with no --comp)"
+    ]
+  },
+  {
+    verb: "feis-panels",
+    value: ["--release", "--address", "--platform"],
+    bool: [],
+    usage: [
+      "  feis-panels [--release <spec>] [--address <feis competition>] [--platform <p>]",
+      "                                    who sat a feis's competition (fweb:ABC24.105)"
+    ]
+  },
+  {
+    verb: "register",
+    value: ["--release", "--year", "--td"],
+    bool: [],
+    usage: [
+      "  register [--release <spec>] [--year <y>] [--td <TD number>]",
+      "                                    the adjudicator register's rows: category, country,",
+      "                                    region, geohash, per year"
+    ]
+  },
+  {
+    verb: "schools",
+    value: ["--release", "--event", "--year", "--school"],
+    bool: ["--prints", "--redirects", "--lineage", "--associations"],
+    usage: [
+      "  schools [--release <spec>]        every school the registry lists: display, regions, places",
+      "  schools --prints [--release <spec>] [--event <e>] [--year <y>]",
+      "                                    the (print, school_id) pairs the rows attach, per event-year",
+      "  schools --redirects | --lineage [--release <spec>]",
+      "                                    the retired ids; the lineage edges",
+      "  schools --associations [--release <spec>] [--school <school_id>]",
+      "                                    the people a directory lists beside a school"
+    ]
+  },
   {
     verb: "teams",
     value: ["--release", "--event", "--year"],
@@ -662,6 +717,27 @@ function streamQueryOf(p) {
     q.primary = true;
   return q;
 }
+function tabStreamQueryOf(p) {
+  const q = {};
+  const comp = p.flags.get("--comp");
+  if (comp !== undefined)
+    q.competition = listOf(comp);
+  const event = p.flags.get("--event");
+  if (event !== undefined)
+    q.event = listOf(event);
+  const tier = p.flags.get("--tier");
+  if (tier !== undefined)
+    q.tier = listOf(tier);
+  const year = p.flags.get("--year");
+  if (year !== undefined) {
+    const m = /^(\d{4})\.\.(\d{4})$/.exec(year);
+    q.year = m === null ? Number(year) : [Number(m[1]), Number(m[2])];
+    if (typeof q.year === "number" && !Number.isInteger(q.year))
+      throw new Error(`--year takes a year or <from>..<to>, not "${year}"`);
+  }
+  return q;
+}
+var tabLine = (t) => `  ${t.address}  ${t.round} seat ${t.seat_index}/${t.panel_size}  ${t.judge_clrg ?? t.judge_id ?? "-"} ${t.judge_name_printed ?? "-"}  mark ${t.mark_printed ?? "-"}  place ${t.place_printed ?? "-"}${t.tie === 1 ? "=" : ""}  points ${t.points_printed ?? "-"}`;
 function eventYearOf(p) {
   const event = p.flags.get("--event");
   const year = p.flags.get("--year");
@@ -683,6 +759,11 @@ var ANSWERING = new Set([
   "records",
   "feis-dates",
   "tabulated",
+  "tabs",
+  "panels",
+  "feis-panels",
+  "register",
+  "schools",
   "teams",
   "events",
   "teacher",
@@ -1163,6 +1244,145 @@ async function main(argv, io = {}) {
           rel.close();
         }
       }
+      case "tabs": {
+        const stream = p.bools.has("--stream");
+        const tq = stream ? tabStreamQueryOf(p) : null;
+        const comp = p.flags.get("--comp");
+        const address = p.flags.get("--address");
+        if (!stream && comp === undefined && address === undefined) {
+          log("tabs --comp <competition> | --address <address> [--round <r>], or tabs --stream");
+          return 2;
+        }
+        const rel = await open(spec, { ...opts, assets: [] });
+        try {
+          if (tq !== null) {
+            let n = 0;
+            for await (const t of rel.tabs.stream(tq)) {
+              say(JSON.stringify(t));
+              n++;
+            }
+            log(`${n} cell(s) in ${rel.tag}`);
+            return n === 0 ? 1 : 0;
+          }
+          const round = p.flags.get("--round");
+          const a = await rel.tabs.query({
+            ...address !== undefined ? { address } : { competition: comp },
+            ...round !== undefined ? { round } : {}
+          });
+          out(a, () => {
+            for (const t of a.rows)
+              say(tabLine(t));
+            say(`${a.rows.length} cell(s) in ${a.tag}`);
+          });
+          return a.rows.length === 0 ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "panels": {
+        const rel = await open(spec, { ...opts, assets: [] });
+        try {
+          const comp = p.flags.get("--comp");
+          const a = await rel.panels.query(comp !== undefined ? { competition: comp } : {});
+          out(a, () => {
+            for (const s of a.seats)
+              say(`  ${s.competition}  ${s.panel} ${s.round} seat ${s.seat_index}  ${s.judge_clrg ?? s.judge_id ?? "-"} ${s.judge_name_printed ?? "-"}${s.judge_unmatched === null ? "" : ` (${s.judge_unmatched})`}`);
+            say(`${a.seats.length} seat(s) in ${a.tag}`);
+          });
+          return a.seats.length === 0 ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "feis-panels": {
+        const rel = await open(spec, { ...opts, assets: [] });
+        try {
+          const address = p.flags.get("--address");
+          const platform = p.flags.get("--platform");
+          const a = await rel.feisPanels.query({
+            ...address !== undefined ? { address } : {},
+            ...platform !== undefined ? { platform } : {}
+          });
+          out(a, () => {
+            for (const s of a.seats)
+              say(`  ${s.address}  ${s.round} seat ${s.seat_index}/${s.panel_size}  ${s.judge_clrg ?? s.judge_id ?? "-"} ${s.judge_name_printed}${s.judge_basis === null ? "" : ` (${s.judge_basis})`}`);
+            say(`${a.seats.length} seat(s) in ${a.tag}`);
+          });
+          return a.seats.length === 0 ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "register": {
+        const rel = await open(spec, { ...opts, assets: [] });
+        try {
+          const year = p.flags.get("--year");
+          const td = p.flags.get("--td");
+          const a = await rel.staff.adjudicators({
+            ...year !== undefined ? { year: Number(year) } : {},
+            ...td !== undefined ? { judge_clrg: Number(td) } : {}
+          });
+          out(a, () => {
+            for (const r of a.rows)
+              say(`  ${r.judge_clrg}  ${r.year}  ${r.cat}  ${r.name_printed}  ${r.country_code ?? r.country}  ${r.region_code ?? r.region}  ${r.geohash ?? "-"}`);
+            say(`${a.rows.length} register row(s) in ${a.tag}`);
+          });
+          return a.rows.length === 0 ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "schools": {
+        const rel = await open(spec, { ...opts, assets: [] });
+        try {
+          if (p.bools.has("--prints")) {
+            const a = await rel.schools.prints(eventYearOf(p));
+            out(a, () => {
+              for (const x of a.prints)
+                say(`  ${x.year ?? "?"} ${x.event}  ${x.school_id}  "${x.print}"  ${x.rows} rows`);
+              say(`${a.prints.length} pair(s) in ${a.tag}`);
+            });
+            return a.prints.length === 0 ? 1 : 0;
+          }
+          if (p.bools.has("--redirects")) {
+            const a = await rel.schools.redirects();
+            out(a, () => {
+              for (const r of a.redirects)
+                say(`  ${r.old_id} -> ${r.new_id}  ${r.kind}${r.since === null ? "" : ` since ${r.since}`}`);
+              say(`${a.redirects.length} redirect(s) in ${a.tag}`);
+            });
+            return a.redirects.length === 0 ? 1 : 0;
+          }
+          if (p.bools.has("--lineage")) {
+            const a = await rel.schools.lineage();
+            out(a, () => {
+              for (const e of a.edges)
+                say(`  ${e.id} ${e.direction} ${e.other}  ${e.shape} ${e.year ?? "?"}${e.provisional ? "  provisional" : ""}`);
+              say(`${a.edges.length} edge end(s) in ${a.tag}`);
+            });
+            return a.edges.length === 0 ? 1 : 0;
+          }
+          if (p.bools.has("--associations")) {
+            const school = p.flags.get("--school");
+            const a = await rel.schools.associations(school !== undefined ? { school_id: school } : {});
+            out(a, () => {
+              for (const x of a.associations)
+                say(`  ${x.school_id ?? "(no id)"} "${x.school_printed ?? ""}"  ${x.person_printed} (${x.person_type ?? "-"}${x.credentials === null ? "" : `, ${x.credentials}`})  ${x.date ?? "-"} ${x.src_type ?? ""}`);
+              say(`${a.associations.length} association(s) in ${a.tag}`);
+            });
+            return a.associations.length === 0 ? 1 : 0;
+          }
+          const a = await rel.schools.list();
+          out(a, () => {
+            for (const s of a.schools)
+              say(`  ${s.school_id}  ${s.display}  ${s.regions.join(",") || "-"}  ${s.places.join(",") || "-"}`);
+            say(`${a.schools.length} school(s) in ${a.tag}`);
+          });
+          return a.schools.length === 0 ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
       case "teams": {
         const rel = await open(spec, { ...opts, assets: [] });
         try {
@@ -1320,5 +1540,6 @@ export {
   parseArgs,
   renderUsage,
   streamQueryOf,
+  tabStreamQueryOf,
   valueFlags
 };

package/dist/index.js

@@ -24,6 +24,9 @@ import {
   syllabusSourceOf2,
   canonicalOf2,
   CompResolver2,
+  TabFinder2,
+  PanelFinder2,
+  FeisPanelFinder2,
   StaffFinder2,
   TeamFinder2,
   EventFinder2,
@@ -68,7 +71,7 @@ import {
   readLatestCheck2,
   latestCheck2,
   staleWarning2
-} from "./chunks/index-vsk6837c.js";
+} from "./chunks/index-2ms980hc.js";
 import {
   cacheRoot2,
   repoOf2
@@ -93,6 +96,7 @@ export {
   FEATURES2 as FEATURES,
   FEIS_LOCAL_ID_FLOOR2 as FEIS_LOCAL_ID_FLOOR,
   FeisFinder2 as FeisFinder,
+  FeisPanelFinder2 as FeisPanelFinder,
   LATEST_CHECK_BUDGET_MS2 as LATEST_CHECK_BUDGET_MS,
   LATEST_CHECK_MS2 as LATEST_CHECK_MS,
   LINEAGE_FILE2 as LINEAGE_FILE,
@@ -100,12 +104,14 @@ export {
   MajorsFinder2 as MajorsFinder,
   NAME_LEVELS2 as NAME_LEVELS,
   NO_CALENDAR2 as NO_CALENDAR,
+  PanelFinder2 as PanelFinder,
   RegistrationResolver2 as RegistrationResolver,
   Release2 as Release,
   ReleaseManager2 as ReleaseManager,
   ResultFinder2 as ResultFinder,
   SchoolResolver2 as SchoolResolver,
   StaffFinder2 as StaffFinder,
+  TabFinder2 as TabFinder,
   TeamFinder2 as TeamFinder,
   buildIndex2 as buildIndex,
   buildTag2 as buildTag,

package/dist/types/cli.d.ts

@@ -3,6 +3,7 @@ import { type FreshnessFloor } from "./freshness.js";
 import { type LocalBuild } from "./local.js";
 import type { OpenOptions } from "./release.js";
 import type { StreamQuery } from "./stream.js";
+import type { TabStreamQuery } from "./tabs.js";
 export { GLOBAL_FLAGS, USAGE_FOOTER, USAGE_HEADER, VERBS, type VerbSpec, renderUsage, valueFlags, } from "./cli-spec.js";
 export declare const USAGE: string;
 export interface Parsed {
@@ -20,6 +21,7 @@ type Line<T> = {
 };
 export declare function jsonLines<T>(text: string, check: (v: T) => string | null): Line<T>[];
 export declare function streamQueryOf(p: Parsed): StreamQuery;
+export declare function tabStreamQueryOf(p: Parsed): TabStreamQuery;
 export interface LocalIO {
     builds: () => readonly LocalBuild[];
 }

package/dist/types/index.d.ts

@@ -16,10 +16,12 @@ export { type Remote, type RemoteAsset, fallbackRemote, ghRemote, httpsRemote, s
 export { type OpenOptions, Release, openCached, openRelease, resolveTag, } from "./release.js";
 export { type MajorCompetition, type MajorEvent, MajorsFinder, type ResultAnswer, ResultFinder, type ResultQuery, type ResultRow, } from "./results.js";
 export { type DancerAnswerLike, type DancerQueryLike, type DancerResolverLike, type DancerUnavailable, type RegistrationRow, type ResolvedDancer, RegistrationResolver, type ResolvedRegistration, dancerResolverOf, youngest, } from "./registrations.js";
+export type { LineageEdge, ObservedAssociation, RegistrySchool, SchoolPrint, SchoolRedirect, } from "./school-bulk.js";
 export { type SchoolAnswer, type SchoolCandidate, type SchoolQuery, SchoolResolver, type SchoolRung, readsSpanishNames, type SpanishNames, } from "./schools.js";
 export { LINEAGE_FILE, type SchoolLineAnswer, type SchoolLinksAnswer, linksOfLineage, releaseSchoolGraph, } from "./school-links.js";
 export type { LineCandidate, LinkPath, LinkPolicy, LinkQuery, LinkStep, PathFlags, SchoolLink, StepFlags, StepPolicy, } from "@finbheara/domain/school-graph";
 export { type Capability, FEATURES, type Feature, type SchemaProbe, capabilityOf, columnsOf, needsRelease, } from "./schema.js";
 export { type EntryRow, type StreamQuery, type StreamRow, type StreamScope, entryRank, } from "./stream.js";
+export { type FeisPanelSeat, FeisPanelFinder, PanelFinder, type PanelSeat, type RegisterRow, type TabAnswer, TabFinder, type TabQuery, type TabRow, type TabStreamQuery, } from "./tabs.js";
 export { EventFinder, type EventYear, type EventYearQuery, type ResultRoster, type RosterMember, type RosterTeam, TeamFinder, type TeamResult, } from "./teams.js";
 export { ARCHIVE_TAG, type ArchiveTag, type ReleaseSpec, compareTagsNewestFirst, cutOf, parseArchiveTag, parseReleaseSpec, pickTag, renderArchiveTag, } from "./tag.js";

package/dist/types/people.d.ts

@@ -2,6 +2,7 @@ import { type StaffRole } from "@finbheara/domain/noun-index";
 import { type NameLevel } from "./dancers-names.js";
 import type { IndexBuilder } from "./indexes.js";
 import type { Release } from "./release.js";
+import { type RegisterRow } from "./tabs.js";
 export interface Taught {
     school_id: string;
     school: string | null;
@@ -59,6 +60,17 @@ export declare class StaffFinder {
     constructor(rel: Release);
     teacher(asked: string): Promise<StaffAnswer>;
     adjudicator(asked: string): Promise<StaffAnswer>;
+    adjudicators(q?: {
+        year?: number;
+        judge_clrg?: number;
+    }): Promise<{
+        tag: string;
+        asked: {
+            year?: number;
+            judge_clrg?: number;
+        };
+        rows: RegisterRow[];
+    }>;
     private find;
     private person;
     private taughtWhere;

package/dist/types/release.d.ts

@@ -11,6 +11,7 @@ import { type Remote } from "./remote.js";
 import { MajorsFinder, ResultFinder } from "./results.js";
 import { type Capability } from "./schema.js";
 import { type SchoolReaderChoice, SchoolResolver } from "./schools.js";
+import { FeisPanelFinder, PanelFinder, TabFinder } from "./tabs.js";
 import { type ReleaseSpec } from "./tag.js";
 import { EventFinder, TeamFinder } from "./teams.js";
 export interface OpenOptions extends ClientOptions {
@@ -44,6 +45,9 @@ export declare class Release {
     readonly registrations: RegistrationResolver;
     readonly teams: TeamFinder;
     readonly events: EventFinder;
+    readonly tabs: TabFinder;
+    readonly panels: PanelFinder;
+    readonly feisPanels: FeisPanelFinder;
     private readonly opts;
     private readonly handles;
     private remoteAssets;

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

@@ -0,0 +1,80 @@
+import type { Release } from "./release.js";
+export interface RegistrySchool {
+    school_id: string;
+    display: string;
+    regions: string[];
+    places: string[];
+}
+export interface SchoolPrint {
+    event: string;
+    year: number | null;
+    print: string;
+    school_id: string;
+    rows: number;
+}
+export interface SchoolRedirect {
+    old_id: string;
+    new_id: string;
+    kind: string;
+    since: number | null;
+}
+export interface LineageEdge {
+    id: string;
+    direction: string;
+    other: string;
+    shape: string;
+    year: number | null;
+    provisional: boolean;
+    decision: string | null;
+    confidence: number | null;
+}
+export interface ObservedAssociation {
+    at: string;
+    seq: number;
+    date: string | null;
+    person: string | null;
+    person_printed: string;
+    reading: string | null;
+    person_type: string | null;
+    credentials: string | null;
+    caption: string | null;
+    school_printed: string | null;
+    school_id: string | null;
+    association_type: string | null;
+    src_type: string | null;
+    src: string | null;
+    candidate_school_id: string | null;
+    candidate_rung: string | null;
+}
+export declare function registrySchools(rel: Release): Promise<{
+    tag: string;
+    schools: RegistrySchool[];
+}>;
+export declare function schoolPrints(rel: Release, q: {
+    event?: string;
+    year?: number;
+}): Promise<{
+    tag: string;
+    asked: {
+        event?: string;
+        year?: number;
+    };
+    prints: SchoolPrint[];
+}>;
+export declare function schoolRedirects(rel: Release): Promise<{
+    tag: string;
+    redirects: SchoolRedirect[];
+}>;
+export declare function schoolLineage(rel: Release): Promise<{
+    tag: string;
+    edges: LineageEdge[];
+}>;
+export declare function observedAssociations(rel: Release, q: {
+    school_id?: string;
+}): Promise<{
+    tag: string;
+    asked: {
+        school_id?: string;
+    };
+    associations: ObservedAssociation[];
+}>;

package/dist/types/schools.d.ts

@@ -1,6 +1,7 @@
 import { type SchoolNameParser } from "@finbheara/domain/school";
 import type { IndexBuilder } from "./indexes.js";
 import type { Release } from "./release.js";
+import { type LineageEdge, type ObservedAssociation, type RegistrySchool, type SchoolPrint, type SchoolRedirect } from "./school-bulk.js";
 import { type LinkQuery, type SchoolLineAnswer, type SchoolLinksAnswer } from "./school-links.js";
 export type SchoolRung = "id" | "redirect" | "print" | "sn3" | "realWords";
 export interface SchoolCandidate {
@@ -57,5 +58,37 @@ export declare class SchoolResolver {
     constructor(rel: Release);
     links(a: string, b: string, q?: LinkQuery): Promise<SchoolLinksAnswer>;
     line(a: string, q?: LinkQuery): Promise<SchoolLineAnswer>;
+    list(): Promise<{
+        tag: string;
+        schools: RegistrySchool[];
+    }>;
+    prints(q?: {
+        event?: string;
+        year?: number;
+    }): Promise<{
+        tag: string;
+        asked: {
+            event?: string;
+            year?: number;
+        };
+        prints: SchoolPrint[];
+    }>;
+    redirects(): Promise<{
+        tag: string;
+        redirects: SchoolRedirect[];
+    }>;
+    lineage(): Promise<{
+        tag: string;
+        edges: LineageEdge[];
+    }>;
+    associations(q?: {
+        school_id?: string;
+    }): Promise<{
+        tag: string;
+        asked: {
+            school_id?: string;
+        };
+        associations: ObservedAssociation[];
+    }>;
     resolve(asked: string, q?: SchoolQuery): Promise<SchoolAnswer>;
 }

package/dist/types/tabs.d.ts

@@ -0,0 +1,132 @@
+import type { Release } from "./release.js";
+export interface TabRow {
+    address: string;
+    competition: string;
+    card: string;
+    line: number;
+    event: string | null;
+    year: number | null;
+    tier: string | null;
+    round: string;
+    true_round: number;
+    seat_index: number;
+    section: string;
+    panel_size: number;
+    column_order: string;
+    drop_rule: string;
+    judge_name: string | null;
+    judge_name_printed: string | null;
+    judge_clrg: number | null;
+    judge_id: number | null;
+    judge_unmatched: string | null;
+    mark: number | null;
+    mark_printed: string | null;
+    place: number | null;
+    place_printed: string | null;
+    tie: number;
+    points: number | null;
+    points_printed: string | null;
+}
+export interface TabQuery {
+    competition?: string;
+    address?: string;
+    round?: string;
+}
+export interface TabStreamQuery {
+    event?: string | string[];
+    year?: number | [number, number];
+    tier?: string[];
+    competition?: string[];
+}
+export interface TabAnswer {
+    tag: string;
+    asked: TabQuery;
+    rows: TabRow[];
+}
+export interface PanelSeat {
+    competition: string;
+    panel: string;
+    round: string;
+    seat_index: number;
+    address: string | null;
+    judge_name_printed: string | null;
+    judge_clrg: number | null;
+    judge_id: number | null;
+    judge_unmatched: string | null;
+}
+export interface FeisPanelSeat {
+    address: string;
+    platform: string;
+    round: string;
+    seat_index: number;
+    panel_size: number;
+    panel_kind: string;
+    judge_name_printed: string;
+    judge_state_printed: string | null;
+    judge_clrg: number | null;
+    judge_id: number | null;
+    judge_unmatched: string | null;
+    judge_basis: string | null;
+}
+export interface RegisterRow {
+    judge_clrg: number;
+    year: number;
+    cat: string;
+    name_printed: string;
+    country: string;
+    country_printed: string;
+    country_code: string | null;
+    region: string;
+    region_printed: string;
+    region_code: string | null;
+    geohash: string | null;
+    src: string;
+}
+export declare const TAB_NEEDS: readonly string[];
+export declare class TabFinder {
+    private readonly rel;
+    constructor(rel: Release);
+    private db;
+    private sheets;
+    query(q: TabQuery): Promise<TabAnswer>;
+    stream(q?: TabStreamQuery): AsyncGenerator<TabRow>;
+}
+export declare class PanelFinder {
+    private readonly rel;
+    constructor(rel: Release);
+    query(q?: {
+        competition?: string;
+    }): Promise<{
+        tag: string;
+        asked: {
+            competition?: string;
+        };
+        seats: PanelSeat[];
+    }>;
+}
+export declare class FeisPanelFinder {
+    private readonly rel;
+    constructor(rel: Release);
+    query(q?: {
+        address?: string;
+        platform?: string;
+    }): Promise<{
+        tag: string;
+        asked: {
+            address?: string;
+            platform?: string;
+        };
+        seats: FeisPanelSeat[];
+    }>;
+}
+export declare function registerRows(rel: Release, q: {
+    year?: number;
+    judge_clrg?: number;
+}): Promise<{
+    tag: string;
+    asked: {
+        year?: number;
+        judge_clrg?: number;
+    };
+    rows: RegisterRow[];
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@finbheara/archive-client",
-	"version": "0.24.0",
+	"version": "0.25.0",
 	"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",