@finbheara/archive-client 0.23.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 };