@finbheara/archive-client 0.0.0-stage → 0.1.1

package/dist/chunks/index-zr8tfjk0.js

@@ -0,0 +1,2357 @@
+// @bun
+import {
+  cacheRoot2,
+  readConfig2,
+  writeJsonAtomic2,
+  writeConfig2,
+  repoOf2,
+  requireRepo2
+} from "./index-hne1wadw.js";
+import {
+  parseArchiveTag2,
+  compareTagsNewestFirst2,
+  parseReleaseSpec2,
+  pickTag2
+} from "./index-hghdy980.js";
+
+var DATABASES2 = ["results", "majors"];
+var isDatabase = (name) => DATABASES2.includes(name);
+function planAsset2(name, manifest) {
+  if (isDatabase(name)) {
+    const file = manifest?.databases?.[name]?.file ?? `${name}.sqlite`;
+    return {
+      asked: name,
+      published: [`${file}.zst`, file],
+      local: file,
+      decompress: true,
+      contentSha256: manifest?.databases?.[name]?.sha256 ?? null
+    };
+  }
+  return {
+    asked: name,
+    published: [name],
+    local: name,
+    decompress: false,
+    contentSha256: manifest?.parquet?.files?.[name]?.sha256 ?? null
+  };
+}
+
+import { createHash } from "crypto";
+import { createReadStream, createWriteStream } from "fs";
+import { Transform } from "stream";
+import { pipeline } from "stream/promises";
+import { createZstdDecompress } from "zlib";
+async function sha256File2(path) {
+  const h = createHash("sha256");
+  await pipeline(createReadStream(path), async (source) => {
+    for await (const chunk of source)
+      h.update(chunk);
+  });
+  return h.digest("hex");
+}
+async function unzstdTo2(src, dest) {
+  const h = createHash("sha256");
+  const tap = new Transform({
+    transform(chunk, _enc, cb) {
+      h.update(chunk);
+      cb(null, chunk);
+    }
+  });
+  await pipeline(createReadStream(src), createZstdDecompress(), tap, createWriteStream(dest));
+  return h.digest("hex");
+}
+function sha256OfDigest(digest) {
+  if (typeof digest !== "string")
+    return null;
+  const m = /^sha256:([0-9a-f]{64})$/i.exec(digest.trim());
+  return m === null ? null : m[1].toLowerCase();
+}
+
+import { Age } from "@finbheara/domain/age";
+import { createIndex, indexSchema, personEncoder } from "@finbheara/domain/noun-index";
+import domainPkg from "@finbheara/domain/package.json";
+import { dancerName } from "@finbheara/domain/person";
+import {
+  foldNameKey,
+  surnameBlock
+} from "@finbheara/names/normalize";
+import namesPkg from "@finbheara/names/package.json";
+
+import {
+  NAME_LEVEL_COLUMNS,
+  givenAbbreviates,
+  nameRelation
+} from "@finbheara/names/normalize";
+var NAME_LEVELS2 = [
+  ...NAME_LEVEL_COLUMNS,
+  "initial",
+  "middle",
+  "surname",
+  "like"
+];
+var finer = (a, b) => NAME_LEVELS2.indexOf(a) <= NAME_LEVELS2.indexOf(b) ? a : b;
+function nameLevel2(q, c) {
+  if (!q.isPerson() || !c.isPerson())
+    return null;
+  for (const level of NAME_LEVEL_COLUMNS)
+    if (q[level] === c[level])
+      return level;
+  if (q.surnameKey() !== c.surnameKey())
+    return null;
+  if (givenAbbreviates(q, c) || givenAbbreviates(c, q))
+    return "initial";
+  if (nameRelation(q, c).relation === "candidate")
+    return "middle";
+  return null;
+}
+
+var FEIS_LOCAL_ID_FLOOR2 = 17179869184;
+var COLUMNS = `r.address AS address, r.competition AS competition, c.event AS event, c.year AS year,
+	c.tier AS tier, c.title AS title, c.age AS age, c.category AS category, c.gender AS gender,
+	c.feis_level AS feis_level, c.comp_no AS comp_no, r.place AS place,
+	r.place_printed AS place_printed, c.competitors AS competitors, r.name_printed AS name_printed,
+	r.dancer_id AS dancer_id, r.school_printed AS school_printed, r.school_id AS school_id,
+	r.yob AS yob, r.qualifier AS qualifier`;
+function queryResults(rel, db, q) {
+  const where = [];
+  const args = [];
+  if (q.dancer_id !== undefined) {
+    where.push("r.dancer_id = ?");
+    args.push(q.dancer_id);
+  }
+  if (q.feis !== undefined) {
+    where.push("c.event = ? COLLATE NOCASE");
+    args.push(q.feis);
+  }
+  if (q.competition !== undefined) {
+    where.push("r.competition = ?");
+    args.push(q.competition);
+  }
+  if (q.school_id !== undefined) {
+    where.push("r.school_id = ?");
+    args.push(q.school_id);
+  }
+  if (where.length === 0)
+    throw new Error("archive-client: a results query names a dancer_id, a feis, a competition or a school_id");
+  if (q.year !== undefined) {
+    where.push("c.year = ?");
+    args.push(q.year);
+  }
+  const limit = q.limit ?? 500;
+  const all = rel.db(db).query(`SELECT ${COLUMNS} FROM results r JOIN competitions c ON c.file = r.file AND c.line = r.competition_line
+			 WHERE ${where.join(" AND ")}
+			 ORDER BY c.year, c.event, r.competition, r.place IS NULL, r.place, r.address`).all(...args);
+  return {
+    tag: rel.tag,
+    db,
+    asked: q,
+    rows: all.slice(0, limit).map((r) => ({
+      ...r,
+      dancer_scope: r.dancer_id === null ? null : r.dancer_id >= FEIS_LOCAL_ID_FLOOR2 ? "per-release" : "stable"
+    })),
+    truncated: Math.max(0, all.length - limit)
+  };
+}
+
+class ResultFinder2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async query(q) {
+    await this.rel.fetch("results");
+    return queryResults(this.rel, "results", q);
+  }
+}
+
+class MajorsFinder2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async db() {
+    await this.rel.fetch("majors");
+    return this.rel.db("majors");
+  }
+  async events() {
+    const db = await this.db();
+    const rows = new Map;
+    for (const r of db.query("SELECT c.event AS event, count(*) AS n FROM results r JOIN competitions c ON c.file = r.file AND c.line = r.competition_line GROUP BY c.event").all())
+      rows.set(r.event, r.n);
+    const events = db.query("SELECT event, json_group_array(DISTINCT year) AS years, count(*) AS n FROM competitions GROUP BY event ORDER BY event").all().map((e) => ({
+      event: e.event,
+      years: JSON.parse(e.years).filter((y) => y !== null).sort((a, b) => a - b),
+      competitions: e.n,
+      rows: rows.get(e.event) ?? 0
+    }));
+    return { tag: this.rel.tag, events };
+  }
+  async competitions(q) {
+    const db = await this.db();
+    const args = [q.event];
+    let year = "";
+    if (q.year !== undefined) {
+      year = " AND c.year = ?";
+      args.push(q.year);
+    }
+    const rows = new Map;
+    for (const r of db.query(`SELECT r.competition AS competition, count(*) AS n FROM results r JOIN competitions c ON c.file = r.file AND c.line = r.competition_line
+				 WHERE c.event = ? COLLATE NOCASE${year} GROUP BY r.competition`).all(...args))
+      rows.set(r.competition, r.n);
+    const competitions = db.query(`SELECT c.competition AS competition, c.event AS event, c.year AS year, c.tier AS tier,
+					        c.comp_no AS comp_no, c.title AS title, c.age AS age, c.gender AS gender,
+					        c.category AS category, c.competitors AS competitors
+					 FROM competitions c WHERE c.event = ? COLLATE NOCASE${year}
+					 ORDER BY c.year, c.seq, c.competition`).all(...args).map((c) => ({ ...c, rows: rows.get(c.competition) ?? 0 }));
+    return { tag: this.rel.tag, competitions };
+  }
+  async results(q) {
+    await this.db();
+    return queryResults(this.rel, "majors", q);
+  }
+}
+
+function nameOrderOf(s) {
+  return s === "surname-first" || s === "given-first" || s === "unknown" ? s : undefined;
+}
+var PACKAGE_KEY_PARTS = [
+  `names=${namesPkg.version}`,
+  `domain=${domainPkg.version}`
+];
+var ENCODER = personEncoder({ read: (p, o) => dancerName(p, o) });
+var PERSON = { table: "person", value: "id", valueType: "INTEGER PRIMARY KEY" };
+var ASKED = ["surname_key", "nn4", "blk_surname"];
+var dancersIndex = {
+  name: "dancers",
+  version: "1",
+  inputs: ["results"],
+  keyParts: () => [...PACKAGE_KEY_PARTS],
+  says: "every published dancer print at the names package's keys, its dancers, schools and years",
+  build(rel, out) {
+    const schema = indexSchema(ENCODER, PERSON);
+    out.run(schema.table);
+    out.run("CREATE TABLE print_dancer(person INTEGER NOT NULL, dancer_id INTEGER, rows INTEGER NOT NULL, year_lo INTEGER, year_hi INTEGER)");
+    out.run("CREATE TABLE dancer(dancer_id INTEGER PRIMARY KEY, display TEXT NOT NULL, names_printed TEXT NOT NULL, genders TEXT NOT NULL, appearances INTEGER NOT NULL, kind TEXT, birth_lo INTEGER, birth_hi INTEGER, birth_source TEXT NOT NULL, birth_conflict INTEGER NOT NULL, rows INTEGER NOT NULL, year_lo INTEGER, year_hi INTEGER)");
+    out.run("CREATE TABLE dancer_school(dancer_id INTEGER NOT NULL, school_id TEXT, print TEXT NOT NULL, rows INTEGER NOT NULL, year_lo INTEGER, year_hi INTEGER)");
+    const src = rel.db("results");
+    const groups = src.query(`SELECT r.name_printed AS p, r.name_order_resolved AS o, r.dancer_id AS d,
+				        r.school_printed AS sp, r.school_id AS s,
+				        count(*) AS n, min(c.year) AS lo, max(c.year) AS hi
+				 FROM results r JOIN competitions c ON c.file = r.file AND c.line = r.competition_line
+				 GROUP BY 1, 2, 3, 4, 5 ORDER BY 1, 2, 3, 4, 5`).all();
+    const names = createIndex(out, ENCODER, PERSON);
+    const personOf = new Map;
+    let next = 0;
+    const idOf = (p, o) => {
+      const k = `${p}\x00${o}`;
+      let id = personOf.get(k);
+      if (id === undefined) {
+        const order = o === "given-first" || o === "surname-first" ? o : undefined;
+        const name = dancerName(p, order);
+        const reading = `${p}\x00${ENCODER.encode(name).reading}`;
+        id = personOf.get(reading);
+        if (id === undefined) {
+          id = ++next;
+          names.add(name, id);
+          personOf.set(reading, id);
+        }
+        personOf.set(k, id);
+      }
+      return id;
+    };
+    const span = (a, lo, hi) => {
+      if (lo !== null && (a.lo === null || lo < a.lo))
+        a.lo = lo;
+      if (hi !== null && (a.hi === null || hi > a.hi))
+        a.hi = hi;
+    };
+    const pd = new Map;
+    const ds = new Map;
+    const dt = new Map;
+    for (const g of groups) {
+      const person = idOf(g.p, g.o);
+      const k1 = `${person}\x00${g.d ?? ""}`;
+      const a = pd.get(k1) ?? { person, d: g.d, rows: 0, lo: null, hi: null };
+      a.rows += g.n;
+      span(a, g.lo, g.hi);
+      pd.set(k1, a);
+      if (g.d === null)
+        continue;
+      const k2 = `${g.d}\x00${g.s ?? ""}\x00${g.sp}`;
+      const b = ds.get(k2) ?? { d: g.d, s: g.s, sp: g.sp, rows: 0, lo: null, hi: null };
+      b.rows += g.n;
+      span(b, g.lo, g.hi);
+      ds.set(k2, b);
+      const t = dt.get(g.d) ?? { rows: 0, lo: null, hi: null };
+      t.rows += g.n;
+      span(t, g.lo, g.hi);
+      dt.set(g.d, t);
+    }
+    const putPd = out.prepare("INSERT INTO print_dancer VALUES (?, ?, ?, ?, ?)");
+    for (const a of pd.values())
+      putPd.run(a.person, a.d, a.rows, a.lo, a.hi);
+    const putDs = out.prepare("INSERT INTO dancer_school VALUES (?, ?, ?, ?, ?, ?)");
+    for (const b of ds.values())
+      putDs.run(b.d, b.s, b.sp, b.rows, b.lo, b.hi);
+    const putD = out.prepare("INSERT INTO dancer VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    for (const d of src.query("SELECT dancer_id, display, names_printed, genders, appearances, scope, birth_lo, birth_hi, birth_source, birth_conflict FROM dancers ORDER BY dancer_id").all()) {
+      const t = dt.get(d.dancer_id);
+      putD.run(d.dancer_id, d.display, d.names_printed, d.genders, d.appearances, d.scope, d.birth_lo, d.birth_hi, d.birth_source, d.birth_conflict, t?.rows ?? 0, t?.lo ?? null, t?.hi ?? null);
+    }
+    for (const s of schema.indexes)
+      if (ASKED.some((c) => s.endsWith(`(${c})`)))
+        out.run(s);
+    out.run("CREATE INDEX print_dancer_person ON print_dancer(person)");
+    out.run("CREATE INDEX print_dancer_dancer ON print_dancer(dancer_id)");
+    out.run("CREATE INDEX dancer_school_dancer ON dancer_school(dancer_id)");
+  }
+};
+function yearOf(asOf) {
+  if (asOf === undefined)
+    return null;
+  const m = /^(\d{4})/.exec(asOf.trim());
+  return m === null ? null : Number(m[1]);
+}
+var NAME_WEIGHT = {
+  nn0: 5,
+  nn1: 5,
+  nn2: 4.5,
+  nn3: 4,
+  nn4: 3,
+  initial: 2,
+  middle: 1.5,
+  surname: 1,
+  like: 1
+};
+var AGE_WEIGHT = {
+  fits: 2,
+  overlaps: 1,
+  unknown: 0.5,
+  unasked: 0,
+  contradicts: -10
+};
+var SCHOOL_RANK = {
+  same: 0,
+  moved: 1,
+  none: 2,
+  unresolved: 2,
+  unasked: 2
+};
+var SCHOOL_WEIGHT = {
+  same: 2,
+  moved: 1,
+  none: 0,
+  unresolved: 0,
+  unasked: 0
+};
+
+class DancerResolver2 {
+  rel;
+  printIds = new Map;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async resolve(q) {
+    const db = await this.rel.indexDb("dancers");
+    const asked = dancerName(q.name, q.order === "unknown" ? undefined : q.order);
+    if (!asked.isPerson())
+      return {
+        tag: this.rel.tag,
+        asked: q,
+        arm: "none",
+        candidates: [],
+        excluded: [],
+        unlinked: [],
+        refused: asked.printsNoName() ? "the print names no person" : "the print reads as no person (a bare word is a surname: search it)"
+      };
+    const names = createIndex(db, ENCODER, PERSON);
+    const hits = new Map;
+    for (const { value, row } of names.rows({ surname_key: [asked.surnameKey()], nn4: [asked.nn4] }, ["print", "reading"])) {
+      const c = ENCODER.decode(row);
+      const level = nameLevel2(asked, c);
+      if (level !== null)
+        hits.set(value, level);
+    }
+    return this.answer(db, q, hits);
+  }
+  async search(q) {
+    if (q.name !== undefined) {
+      const a = await this.resolve({ ...q, name: q.name });
+      return this.capped(a, q.limit);
+    }
+    const db = await this.rel.indexDb("dancers");
+    const hits = new Map;
+    const names = createIndex(db, ENCODER, PERSON);
+    if (q.surname !== undefined) {
+      const block = surnameBlock(foldNameKey(q.surname).toUpperCase());
+      if (block !== null)
+        for (const { value } of names.rows({ blk_surname: [block] }, ["print"]))
+          hits.set(value, "surname");
+    } else if (q.like !== undefined) {
+      const like = q.like.replace(/[\\%_]/g, (c) => `\\${c}`).replace(/\*/g, "%").replace(/\?/g, "_");
+      for (const r of db.query("SELECT id FROM person WHERE print LIKE ? ESCAPE '\\'").all(like))
+        hits.set(r.id, "like");
+    } else
+      throw new Error("archive-client: a dancer search names one of name, surname, like");
+    const a = await this.answer(db, { ...q, name: q.surname ?? q.like ?? "" }, hits, false);
+    return this.capped(a, q.limit);
+  }
+  capped(a, limit = 50) {
+    return { ...a, candidates: a.candidates.slice(0, limit) };
+  }
+  async get(dancerId) {
+    const db = await this.rel.indexDb("dancers");
+    const d = db.query("SELECT * FROM dancer WHERE dancer_id = ?").get(dancerId);
+    if (d === null)
+      return null;
+    const prints = db.query("SELECT p.print AS print, sum(x.rows) AS rows, min(x.year_lo) AS year_lo, max(x.year_hi) AS year_hi FROM print_dancer x JOIN person p ON p.id = x.person WHERE x.dancer_id = ? GROUP BY p.print ORDER BY rows DESC, print").all(dancerId);
+    return {
+      tag: this.rel.tag,
+      dancer_id: d.dancer_id,
+      display: d.display,
+      scope: d.dancer_id >= FEIS_LOCAL_ID_FLOOR2 ? "per-release" : "stable",
+      kind: d.kind,
+      names_printed: JSON.parse(d.names_printed),
+      genders: d.genders,
+      appearances: d.appearances,
+      rows: d.rows,
+      year_lo: d.year_lo,
+      year_hi: d.year_hi,
+      birth: birthOf(d),
+      prints,
+      schools: schoolsOf(db, dancerId)
+    };
+  }
+  async answer(db, q, hits, narrow = true) {
+    const asOf = yearOf(q.asOf);
+    const age = q.age === undefined ? undefined : this.readAge(q.age, asOf);
+    let schoolIds = null;
+    let school;
+    if (q.school !== undefined) {
+      const s = await this.rel.schools.resolve(q.school);
+      schoolIds = s.candidates.map((c) => c.school_id);
+      school = { arm: s.arm, ids: schoolIds };
+    }
+    const byDancer = new Map;
+    const unlinked = new Map;
+    const pq = db.query("SELECT x.dancer_id AS d, x.rows AS n, p.print AS print FROM print_dancer x JOIN person p ON p.id = x.person WHERE x.person = ?");
+    for (const [person, level] of hits)
+      for (const r of pq.all(person)) {
+        if (r.d === null) {
+          unlinked.set(r.print, (unlinked.get(r.print) ?? 0) + r.n);
+          continue;
+        }
+        const e = byDancer.get(r.d) ?? { level, prints: [] };
+        e.level = finer(e.level, level);
+        e.prints.push({ print: r.print, rows: r.n, level });
+        byDancer.set(r.d, e);
+      }
+    const dq = db.query("SELECT * FROM dancer WHERE dancer_id = ?");
+    const all = [];
+    for (const [id, e] of byDancer) {
+      const d = dq.get(id);
+      if (d === null)
+        continue;
+      const schools = schoolsOf(db, id);
+      const latest = latestSchool(schools, asOf);
+      const ageEv = ageEvidence(d, age?.age ?? null);
+      const schoolEv = schoolIds === null ? "unasked" : schoolIds.length === 0 ? "unresolved" : await this.schoolEvidence(schools, schoolIds, asOf);
+      all.push({
+        dancer_id: id,
+        display: d.display,
+        scope: id >= FEIS_LOCAL_ID_FLOOR2 ? "per-release" : "stable",
+        kind: d.kind,
+        score: NAME_WEIGHT[e.level] + AGE_WEIGHT[ageEv] + SCHOOL_WEIGHT[schoolEv],
+        evidence: { nameLevel: e.level, age: ageEv, school: schoolEv },
+        prints: e.prints.sort((a, b) => b.rows - a.rows || (a.print < b.print ? -1 : 1)),
+        rows: d.rows,
+        year_lo: d.year_lo,
+        year_hi: d.year_hi,
+        birth: birthOf(d),
+        school: latest
+      });
+    }
+    all.sort((a, b) => SCHOOL_RANK[a.evidence.school] - SCHOOL_RANK[b.evidence.school] || b.score - a.score || b.rows - a.rows || a.dancer_id - b.dancer_id);
+    const excluded = [];
+    let kept = all;
+    if (narrow)
+      kept = all.filter((c) => {
+        if (c.evidence.age !== "contradicts")
+          return true;
+        excluded.push({ candidate: c, why: "age" });
+        return false;
+      });
+    let preferred;
+    if (kept.length > 1 && school !== undefined)
+      for (const ev of ["same", "moved"]) {
+        const hit = kept.filter((c) => SCHOOL_RANK[c.evidence.school] === SCHOOL_RANK[ev]);
+        if (hit.length === 0)
+          continue;
+        if (hit.length === 1)
+          preferred = {
+            dancer_id: hit[0].dancer_id,
+            why: `the only candidate ${ev === "same" ? "whose latest school is" : "that ever danced for"} ${q.school}`
+          };
+        break;
+      }
+    return {
+      tag: this.rel.tag,
+      asked: q,
+      arm: kept.length === 0 ? "none" : kept.length === 1 ? "unique" : "ambiguous",
+      candidates: kept,
+      excluded,
+      ...preferred !== undefined ? { preferred } : {},
+      unlinked: [...unlinked].map(([print, rows]) => ({ print, rows })).sort((a, b) => b.rows - a.rows || (a.print < b.print ? -1 : 1)),
+      ...age !== undefined ? { age: age.answer } : {},
+      ...school !== undefined ? { school } : {}
+    };
+  }
+  async schoolEvidence(schools, ids, asOf) {
+    const rows = schools.filter((s) => asOf === null || s.year_lo === null || s.year_lo <= asOf);
+    const meets = async (s) => {
+      if (s.school_id !== null)
+        return ids.includes(s.school_id);
+      let read = this.printIds.get(s.print);
+      if (read === undefined) {
+        read = (await this.rel.schools.resolve(s.print)).candidates.map((c) => c.school_id);
+        this.printIds.set(s.print, read);
+      }
+      return read.some((id) => ids.includes(id));
+    };
+    const top = (s) => asOf !== null && s.year_hi !== null ? Math.min(s.year_hi, asOf) : s.year_hi ?? -1;
+    const latest = Math.max(-1, ...rows.map(top));
+    let earlier = false;
+    for (const s of rows) {
+      if (!await meets(s))
+        continue;
+      if (top(s) === latest)
+        return "same";
+      earlier = true;
+    }
+    return earlier ? "moved" : "none";
+  }
+  readAge(a, asOf) {
+    const done = (age, note) => {
+      const read = age?.isAge() ? age : null;
+      const w = read === null ? null : read.birthYears();
+      return {
+        age: read,
+        answer: {
+          read: read === null ? null : read.ag1,
+          birth: w === null ? null : { from: w.from, to: w.to },
+          ...note !== undefined ? { note } : {}
+        }
+      };
+    };
+    if ("yob" in a)
+      return done(Age.fromYOB(a.yob));
+    if ("band" in a) {
+      const year = a.year ?? asOf ?? new Date().getFullYear();
+      return done(Age.from(a.band, { year }));
+    }
+    const c = this.rel.db("results").query("SELECT age, year FROM competitions WHERE competition = ? LIMIT 1").get(a.comp);
+    if (c === null)
+      return done(null, `the release holds no competition ${a.comp} (a feis's own code is \`comps.resolve\`'s)`);
+    if (c.age === null || c.year === null)
+      return done(null, `competition ${a.comp} prints no age or year`);
+    return done(Age.from(c.age, { year: c.year }));
+  }
+}
+function birthOf(d) {
+  return {
+    lo: d.birth_lo,
+    hi: d.birth_hi,
+    source: d.birth_source,
+    conflict: d.birth_conflict !== 0
+  };
+}
+function schoolsOf(db, dancerId) {
+  return db.query("SELECT school_id, print, rows, year_lo, year_hi FROM dancer_school WHERE dancer_id = ? ORDER BY year_hi DESC, rows DESC, print").all(dancerId);
+}
+function latestSchool(schools, asOf) {
+  let best = null;
+  for (const s of schools) {
+    if (asOf !== null && s.year_lo !== null && s.year_lo > asOf)
+      continue;
+    const hi = asOf !== null && s.year_hi !== null ? Math.min(s.year_hi, asOf) : s.year_hi;
+    const bh = best === null ? null : asOf !== null && best.year_hi !== null ? Math.min(best.year_hi, asOf) : best.year_hi;
+    if (best === null || (hi ?? -1) > (bh ?? -1) || (hi ?? -1) === (bh ?? -1) && s.rows > best.rows)
+      best = s;
+  }
+  return best;
+}
+function ageEvidence(d, asked) {
+  if (asked === null)
+    return "unasked";
+  if (d.birth_lo === null && d.birth_hi === null)
+    return "unknown";
+  const own = Age.fromYOB(d.birth_lo, d.birth_hi);
+  if (!own.isAge())
+    return "unknown";
+  if (own.fitsIn(asked))
+    return "fits";
+  if (own.overlaps(asked))
+    return "overlaps";
+  return "contradicts";
+}
+
+import { Age as Age2 } from "@finbheara/domain/age";
+import {
+  compTitle,
+  matchTitle,
+  populationIn,
+  titleRelation
+} from "@finbheara/domain/title";
+var LEVEL = Object.freeze({
+  100: "FF",
+  200: "BG",
+  300: "AB",
+  400: "NV",
+  500: "PW",
+  600: "PC",
+  700: "OC"
+});
+var SCHEMA = `
+CREATE TABLE comp(
+  competition TEXT PRIMARY KEY, feis_id TEXT NOT NULL, brand_id TEXT, year INTEGER,
+  code TEXT NOT NULL, code_fold TEXT NOT NULL, title TEXT, age TEXT, gender TEXT,
+  feis_level INTEGER, round TEXT, platform TEXT NOT NULL, captures INTEGER NOT NULL,
+  file TEXT NOT NULL, line INTEGER NOT NULL
+);
+`;
+var INDEXES = [
+  "CREATE INDEX comp_feis_code ON comp(feis_id, code_fold)",
+  "CREATE INDEX comp_brand_year ON comp(brand_id, year)"
+];
+var fold = (code) => code.trim().toLowerCase();
+var compsIndex = {
+  name: "comps",
+  version: "1",
+  inputs: ["results"],
+  says: "every competition by its feis and its own code, with its series and year",
+  build(rel, out) {
+    out.run(SCHEMA);
+    const src = rel.db("results");
+    const brand = new Map;
+    for (const f of src.query("SELECT feis_id, feis_brand_id, year FROM feises ORDER BY file, line").all())
+      if (!brand.has(f.feis_id))
+        brand.set(f.feis_id, { brand: f.feis_brand_id, year: f.year });
+    const captures = new Map;
+    for (const r of src.query("SELECT competition, count(*) AS n FROM competitions GROUP BY competition").all())
+      captures.set(r.competition, r.n);
+    const put = out.prepare("INSERT OR IGNORE INTO comp VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    for (const c of src.query("SELECT competition, event, year, comp_no, title, age, gender, feis_level, round, source, file, line FROM competitions WHERE comp_no IS NOT NULL AND trim(comp_no) != '' ORDER BY file, line").iterate()) {
+      const f = brand.get(c.event);
+      put.run(c.competition, c.event, f?.brand ?? null, c.year ?? f?.year ?? null, c.comp_no.trim(), fold(c.comp_no), c.title, c.age, c.gender, c.feis_level, c.round, c.source, captures.get(c.competition) ?? 1, c.file, c.line);
+    }
+    for (const s of INDEXES)
+      out.run(s);
+  }
+};
+function compOf(r) {
+  const lv = r.feis_level;
+  const kind = lv === null ? "unrated" : lv >= 600 ? "championship" : "grade";
+  const pop = populationIn(r.gender ?? "") || populationIn(r.title ?? "");
+  const round = r.round ?? (r.title === null ? null : compTitle(r.title).round?.toString() ?? null);
+  return {
+    competition: r.competition,
+    feis_id: r.feis_id,
+    year: r.year,
+    code: r.code,
+    title: r.title,
+    kind,
+    feis_level: lv,
+    level: lv === null ? null : LEVEL[lv] ?? null,
+    age: r.age,
+    population: pop === "" ? null : pop,
+    round,
+    canonical: canonicalOf2(lv, r.age),
+    platform: r.platform,
+    captures: r.captures
+  };
+}
+function canonicalOf2(level, age) {
+  if (level !== 600 && level !== 700 || age === null)
+    return null;
+  const a = Age2.from(age, { year: null });
+  const p = a.parts[0];
+  if (!a.isValid() || p === undefined)
+    return null;
+  const n = a.kind === "under" ? p : a.kind === "over" ? p + 1 : null;
+  if (n === null || n > 99)
+    return null;
+  return `${level / 100}${String(n).padStart(2, "0")}${level === 600 ? "PC" : "OC"}`;
+}
+var entryOf = (c) => ({
+  title: c.title ?? "",
+  ...c.age !== null ? { age: c.age } : {},
+  comp: c
+});
+
+class CompResolver2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async place(feis, year) {
+    const asked = feis.trim();
+    const none = {
+      asked,
+      feis_ids: [],
+      brand_id: null,
+      year: year ?? null,
+      held: false,
+      via: null
+    };
+    const found = await this.rel.feises.find({ id: asked });
+    const exact = found.feises.find((f) => f.feis_id === (found.redirected?.to ?? asked));
+    if (exact !== undefined) {
+      const y = year ?? exact.year;
+      if (y === exact.year || exact.brand_id === null)
+        return {
+          asked,
+          feis_ids: [exact.feis_id],
+          brand_id: exact.brand_id,
+          year: y,
+          held: y === exact.year,
+          via: "id"
+        };
+      return this.ofSeries(asked, exact.brand_id, y, "id");
+    }
+    if (found.feises.length > 0) {
+      const brands = [...new Set(found.feises.map((f) => f.brand_id))];
+      const instanceYears = [
+        ...new Set(found.feises.filter((f) => f.instance_id === (found.redirected?.to ?? asked)).map((f) => f.year))
+      ];
+      const y = year ?? (instanceYears.length === 1 ? instanceYears[0] ?? null : null);
+      const only = brands[0];
+      if (brands.length === 1 && only !== null && only !== undefined)
+        return this.ofSeries(asked, only, y, "series");
+    }
+    const m = /^([^:]+):(.*?)(\d{2})$/.exec(asked);
+    if (m !== null) {
+      const [, token, stem, yy] = m;
+      const brands = await this.rel.feises.codeStem(token, stem);
+      const y = year ?? 2000 + Number(yy);
+      if (brands.length === 1)
+        return this.ofSeries(asked, brands[0], y, "code-stem");
+      if (brands.length > 1)
+        return { ...none, year: y, via: "code-stem", series: brands };
+      return { ...none, year: y };
+    }
+    const s = await this.rel.feises.series(asked);
+    if (s.arm === "unique" && s.series_id !== null)
+      return this.ofSeries(asked, s.series_id, year ?? null, s.via === "name" ? "name" : "code-stem");
+    if (s.arm === "ambiguous")
+      return {
+        ...none,
+        via: s.via === "name" ? "name" : "code-stem",
+        series: s.candidates.map((c) => c.series_id)
+      };
+    return none;
+  }
+  async ofSeries(asked, brand, year, via) {
+    const db = await this.rel.indexDb("feises");
+    if (year === null)
+      year = db.query("SELECT max(year) AS y FROM feis WHERE brand_id = ?").get(brand)?.y ?? null;
+    const ids = year === null ? [] : db.query("SELECT feis_id FROM feis WHERE brand_id = ? AND year = ? ORDER BY feis_id").all(brand, year).map((r) => r.feis_id);
+    return { asked, feis_ids: ids, brand_id: brand, year, held: ids.length > 0, via };
+  }
+  async years(brand) {
+    if (brand === null)
+      return [];
+    const db = await this.rel.indexDb("comps");
+    return db.query("SELECT DISTINCT year FROM comp WHERE brand_id = ? AND year IS NOT NULL ORDER BY year").all(brand).map((r) => r.year);
+  }
+  async compsOf(feisIds, code) {
+    if (feisIds.length === 0)
+      return [];
+    const db = await this.rel.indexDb("comps");
+    const marks = feisIds.map(() => "?").join(", ");
+    const sql = `SELECT * FROM comp WHERE feis_id IN (${marks})${code !== undefined ? " AND code_fold = ?" : ""} ORDER BY file, line`;
+    const args = code !== undefined ? [...feisIds, fold(code)] : [...feisIds];
+    return db.query(sql).all(...args).map(compOf);
+  }
+  async idsOf(brand, year) {
+    return (await this.ofSeries("", brand, year, "series")).feis_ids;
+  }
+  async syllabus(feis, year) {
+    const place = await this.place(feis, year);
+    return {
+      tag: this.rel.tag,
+      feis: place,
+      year: place.year,
+      held: place.held,
+      entries: await this.compsOf(place.feis_ids),
+      years: await this.years(place.brand_id)
+    };
+  }
+  async syllabusFor(series, year) {
+    const asked = typeof series === "string" ? series.trim() : series.series_id ?? "";
+    const place = await this.place(asked, year);
+    const years = await this.years(place.brand_id);
+    const answer = (arm, read, why) => {
+      const entries = read?.entries ?? [];
+      const championships = entries.filter((c) => c.kind === "championship").length;
+      return {
+        tag: this.rel.tag,
+        asked: { series: asked, year: year ?? place.year },
+        arm,
+        series_id: place.brand_id,
+        feis: place,
+        year: read?.year ?? null,
+        held: place.held,
+        source: read === null ? null : "results",
+        feis_ids: read?.feis_ids ?? [],
+        entries,
+        years,
+        championships,
+        ...why !== undefined ? { why } : {},
+        ...read !== null && entries.length > 0 && championships === 0 ? {
+          note: "no championship is in the results this syllabus is read from: a feis whose platform did not tabulate its championships lists none here"
+        } : {}
+      };
+    };
+    if (place.series !== undefined)
+      return answer("ambiguous", null, `"${asked}" names ${place.series.length} series: ${place.series.join(", ")}`);
+    if (place.feis_ids.length === 0 && place.brand_id === null)
+      return answer("none", null, `the release holds no feis or series "${asked}"`);
+    if (place.held)
+      return answer("unique", {
+        year: place.year,
+        feis_ids: place.feis_ids,
+        entries: await this.compsOf(place.feis_ids)
+      });
+    const newest = years[years.length - 1];
+    if (newest === undefined || place.brand_id === null)
+      return answer("unique", null, `the release holds no comp of ${asked}'s series`);
+    const ids = await this.idsOf(place.brand_id, newest);
+    return answer("unique", { year: newest, feis_ids: ids, entries: await this.compsOf(ids) }, `the release holds no ${place.year ?? "asked"} feis-year of the series: read from ${newest}, its newest`);
+  }
+  async resolve(q) {
+    const place = await this.place(q.feis, q.year);
+    const base = {
+      tag: this.rel.tag,
+      asked: q,
+      feis: place
+    };
+    const answer = (arm, source, candidates, more = {}) => {
+      const u = arm === "unique" ? candidates[0] ?? null : null;
+      return {
+        ...base,
+        arm,
+        source,
+        kind: u?.kind ?? null,
+        level: u?.level ?? null,
+        feis_level: u?.feis_level ?? null,
+        age: u?.age ?? null,
+        population: u?.population ?? null,
+        round: u?.round ?? null,
+        canonical: u?.canonical ?? null,
+        title: u?.title ?? null,
+        competition: u?.competition ?? null,
+        candidates,
+        syllabus_source: source === null ? null : "results",
+        ...more
+      };
+    };
+    if (place.series !== undefined)
+      return answer("ambiguous", null, [], {
+        why: `the feis's code stem names ${place.series.length} series: ${place.series.join(", ")}`
+      });
+    if (place.feis_ids.length === 0 && place.brand_id === null)
+      return answer("none", null, [], { why: `the release holds no feis "${place.asked}"` });
+    const byTitle = async (ids, from, why) => {
+      if (q.title === undefined || q.title.trim() === "")
+        return answer("none", null, [], { why, ...from !== undefined ? { from } : {} });
+      const m = matchTitle(q.title, (await this.compsOf(ids)).map(entryOf));
+      const hits = m.entries.map((e) => e.comp);
+      const arm = hits.length === 0 ? "none" : hits.length === 1 ? "unique" : "ambiguous";
+      return answer(arm, hits.length === 0 ? null : "title", hits, {
+        ...from !== undefined ? { from } : {},
+        ...arm !== "unique" ? {
+          why: arm === "none" ? `${why}, and the title names no comp of that syllabus` : `${why}, and the title names ${hits.length} comps of that syllabus`
+        } : { why }
+      });
+    };
+    if (place.held) {
+      const hits = await this.compsOf(place.feis_ids, q.code);
+      if (hits.length === 1)
+        return answer("unique", "syllabus", hits);
+      if (hits.length > 1)
+        return answer("ambiguous", "syllabus", hits, {
+          why: `${hits.length} comps print code ${q.code}`
+        });
+      return byTitle(place.feis_ids, undefined, `no comp of ${place.feis_ids.join(", ")} prints code ${q.code}`);
+    }
+    const earlier = (await this.years(place.brand_id)).filter((y) => place.year === null || y < place.year).reverse();
+    if (earlier.length === 0 || place.brand_id === null)
+      return answer("none", null, [], {
+        why: `the release holds no year of ${place.asked}'s series before ${place.year ?? "?"}`
+      });
+    for (const y of earlier) {
+      const ids = await this.idsOf(place.brand_id, y);
+      const hits = await this.compsOf(ids, q.code);
+      if (hits.length === 0)
+        continue;
+      const from = { feis_ids: ids, year: y };
+      if (hits.length > 1)
+        return answer("ambiguous", "prior-year", hits, {
+          from,
+          why: `${hits.length} comps of ${y} print code ${q.code}`
+        });
+      const hit = hits[0];
+      if (q.title === undefined || q.title.trim() === "")
+        return answer("unique", "prior-year", hits, { from, check: "unchecked" });
+      const m = matchTitle(q.title, [entryOf(hit)]);
+      const r = titleRelation(m.title, compTitle(hit.title ?? "", {}));
+      const check = {
+        title: q.title,
+        agrees: m.isSingular(),
+        age: r.age.relation,
+        population: r.population
+      };
+      if (check.agrees)
+        return answer("unique", "prior-year", hits, { from, check });
+      const t = await byTitle(ids, from, `code ${q.code} of ${y} is "${hit.title}", which the title does not name`);
+      return { ...t, check };
+    }
+    const newest = earlier[0];
+    const ids = await this.idsOf(place.brand_id, newest);
+    const champs = (await this.compsOf(ids)).some((c) => c.kind === "championship");
+    return byTitle(ids, { feis_ids: ids, year: newest }, `no year of the series before ${place.year ?? "?"} prints code ${q.code}${champs ? "" : `, and the ${newest} syllabus, read from results, lists no championship`}`);
+  }
+}
+
+import { readFileSync } from "fs";
+var SCHEMA2 = `
+CREATE TABLE feis(
+  feis_id TEXT PRIMARY KEY, source TEXT NOT NULL, token TEXT NOT NULL, host_id TEXT NOT NULL,
+  name TEXT NOT NULL, date_lo TEXT, date_hi TEXT, date_printed TEXT, year INTEGER,
+  location TEXT, instance_id TEXT, brand_id TEXT, regions TEXT NOT NULL,
+  competitions INTEGER NOT NULL, rows INTEGER NOT NULL, captures INTEGER NOT NULL
+);
+CREATE TABLE redirect(old_id TEXT PRIMARY KEY, new_id TEXT NOT NULL, kind TEXT NOT NULL);
+`;
+var INDEXES2 = [
+  "CREATE INDEX feis_host ON feis(host_id COLLATE NOCASE)",
+  "CREATE INDEX feis_token ON feis(token)",
+  "CREATE INDEX feis_source ON feis(source)",
+  "CREATE INDEX feis_instance ON feis(instance_id)",
+  "CREATE INDEX feis_brand ON feis(brand_id)",
+  "CREATE INDEX feis_year ON feis(year)"
+];
+function readJsonl(path) {
+  return readFileSync(path, "utf8").split(`
+`).filter((l) => l.trim() !== "").map((l) => JSON.parse(l));
+}
+var feisesIndex = {
+  name: "feises",
+  version: "2",
+  inputs: ["results", "feis-redirects.jsonl"],
+  says: "every feis by id, platform, code, series and name, with its counts and regions",
+  build(rel, out) {
+    out.run(SCHEMA2);
+    const src = rel.db("results");
+    const counts = new Map;
+    for (const r of src.query("SELECT event, count(*) AS n, json_group_array(DISTINCT feis_region) AS regions FROM competitions GROUP BY event").all())
+      counts.set(r.event, {
+        comps: r.n,
+        regions: new Set(JSON.parse(r.regions).filter((x) => x !== null))
+      });
+    const rows = new Map;
+    for (const r of src.query("SELECT c.event AS event, sum(r.n) AS n FROM (SELECT competition, count(*) AS n FROM results GROUP BY competition) r JOIN (SELECT DISTINCT competition, event FROM competitions) c ON c.competition = r.competition GROUP BY c.event").all())
+      rows.set(r.event, r.n);
+    const put = out.prepare("INSERT OR IGNORE INTO feis VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    const captures = new Map;
+    const feisRows = src.query("SELECT feis_id, source, host_id, name_printed, date_lo, date_hi, date_printed, year, location_printed, feis_instance_id, feis_brand_id FROM feises ORDER BY file, line").all();
+    for (const f of feisRows)
+      captures.set(f.feis_id, (captures.get(f.feis_id) ?? 0) + 1);
+    for (const f of feisRows) {
+      const c = counts.get(f.feis_id);
+      const colon = f.feis_id.indexOf(":");
+      put.run(f.feis_id, f.source, colon === -1 ? f.source : f.feis_id.slice(0, colon), f.host_id, f.name_printed, f.date_lo, f.date_hi, f.date_printed, f.year, f.location_printed, f.feis_instance_id, f.feis_brand_id, JSON.stringify([...c?.regions ?? []].sort()), c?.comps ?? 0, rows.get(f.feis_id) ?? 0, captures.get(f.feis_id) ?? 0);
+    }
+    const red = out.prepare("INSERT OR REPLACE INTO redirect VALUES (?, ?, ?)");
+    for (const r of readJsonl(rel.path("feis-redirects.jsonl")))
+      red.run(r.old_id, r.new_id, r.kind);
+    for (const s of INDEXES2)
+      out.run(s);
+  }
+};
+var NO_CALENDAR2 = "the release holds a feis-year once its results are captured and carries no calendar of scheduled feiseanna";
+var globToLike = (g) => g.replace(/[\\%_]/g, (c) => `\\${c}`).replace(/\*/g, "%").replace(/\?/g, "_");
+
+class FeisFinder2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async find(q) {
+    const db = await this.rel.indexDb("feises");
+    const where = [];
+    const args = [];
+    let redirected;
+    if (q.platform !== undefined) {
+      where.push("(source = ? OR token = ?)");
+      args.push(q.platform, q.platform);
+    }
+    if (q.code !== undefined) {
+      where.push("host_id = ? COLLATE NOCASE");
+      args.push(q.code);
+    }
+    if (q.id !== undefined) {
+      let id = q.id;
+      const seen = new Set;
+      for (;; ) {
+        const r = db.query("SELECT new_id FROM redirect WHERE old_id = ?").get(id);
+        if (r === null || seen.has(r.new_id))
+          break;
+        seen.add(id);
+        id = r.new_id;
+      }
+      if (id !== q.id)
+        redirected = { from: q.id, to: id };
+      where.push("(feis_id = ? OR instance_id = ? OR brand_id = ?)");
+      args.push(id, id, id);
+    }
+    if (q.name !== undefined) {
+      where.push("name LIKE ? ESCAPE '\\'");
+      args.push(globToLike(q.name));
+    }
+    if (q.year !== undefined) {
+      where.push("year = ?");
+      args.push(q.year);
+    }
+    const sql = `SELECT * FROM feis${where.length > 0 ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY date_lo, feis_id`;
+    const feises = db.query(sql).all(...args).map((r) => ({
+      ...r,
+      regions: JSON.parse(r.regions)
+    }));
+    return { tag: this.rel.tag, feises, ...redirected !== undefined ? { redirected } : {} };
+  }
+  async codeStem(token, stem) {
+    const db = await this.rel.indexDb("feises");
+    const like = db.query("SELECT host_id, year, brand_id FROM feis WHERE token = ? AND host_id LIKE ? ESCAPE '\\' COLLATE NOCASE").all(token, `${stem.replace(/[\\%_]/g, (c) => `\\${c}`)}__`);
+    const fits = like.filter((f) => {
+      const d = /(\d{2})$/.exec(f.host_id);
+      return d !== null && f.host_id.slice(0, -2).toLowerCase() === stem.toLowerCase() && f.year !== null && f.year % 100 === Number(d[1]) && f.brand_id !== null;
+    });
+    return [...new Set(fits.map((f) => f.brand_id))].sort();
+  }
+  async seriesOf(brand) {
+    const db = await this.rel.indexDb("feises");
+    const rows = db.query("SELECT * FROM feis WHERE brand_id = ? ORDER BY year, date_lo, feis_id").all(brand);
+    const byYear = new Map;
+    for (const r of rows) {
+      const i = byYear.get(r.year);
+      if (i === undefined)
+        byYear.set(r.year, {
+          year: r.year,
+          feis_ids: [r.feis_id],
+          date_lo: r.date_lo,
+          name: r.name
+        });
+      else
+        i.feis_ids.push(r.feis_id);
+    }
+    const instances = [...byYear.values()];
+    const newest = rows[rows.length - 1];
+    return {
+      series_id: brand,
+      name: newest?.name ?? "",
+      host: newest?.source ?? "",
+      hosts: [...new Set(rows.map((r) => r.source))].sort(),
+      codes: [...new Set(rows.map((r) => r.host_id))].sort(),
+      years: instances.map((i) => i.year).filter((y) => y !== null),
+      instances
+    };
+  }
+  async series(q) {
+    const asked = q.trim();
+    const answer = async (brands, via, more = {}) => {
+      const candidates = [];
+      for (const b of brands)
+        candidates.push(await this.seriesOf(b));
+      const arm = candidates.length === 0 ? "none" : candidates.length === 1 ? "unique" : "ambiguous";
+      const u = arm === "unique" ? candidates[0] : null;
+      return {
+        tag: this.rel.tag,
+        asked,
+        arm,
+        via: candidates.length === 0 ? null : via,
+        series_id: u?.series_id ?? null,
+        name: u?.name ?? null,
+        host: u?.host ?? null,
+        years: u?.years ?? [],
+        instances: u?.instances ?? [],
+        next: null,
+        ...u !== null ? { next_why: NO_CALENDAR2 } : {},
+        candidates,
+        ...arm === "ambiguous" ? { why: `${candidates.length} series answer "${asked}": ${brands.join(", ")}` } : {},
+        ...more
+      };
+    };
+    if (asked === "")
+      return answer([], null, { why: "no series was asked" });
+    const byId = await this.find({ id: asked });
+    if (byId.feises.length > 0) {
+      const brands = [...new Set(byId.feises.map((f) => f.brand_id))];
+      const filed = brands.filter((b) => b !== null).sort();
+      const redirected = byId.redirected !== undefined ? { redirected: byId.redirected } : {};
+      if (filed.length === 0)
+        return answer([], null, {
+          ...redirected,
+          why: `the release files ${byId.feises.map((f) => f.feis_id).join(", ")} under no series`
+        });
+      return answer(filed, "id", redirected);
+    }
+    const code = /^([^:\s]+):(.*?)(\d{2})?$/.exec(asked);
+    if (code !== null) {
+      const [, token, stem] = code;
+      const brands = stem === "" ? [] : await this.codeStem(token, stem);
+      if (brands.length > 0)
+        return answer(brands, "code-stem");
+    }
+    const glob = /[*?]/.test(asked) ? asked : `*${asked}*`;
+    const byName = await this.find({ name: glob });
+    const brands = [
+      ...new Set(byName.feises.map((f) => f.brand_id).filter((b) => b !== null))
+    ].sort();
+    if (brands.length > 0)
+      return answer(brands, "name");
+    return answer([], null, {
+      why: byName.feises.length > 0 ? `the feises named "${asked}" are filed under no series` : `the release holds no feis or series "${asked}"`
+    });
+  }
+}
+
+import { Database } from "bun:sqlite";
+import { createHash as createHash2 } from "crypto";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "fs";
+import { join } from "path";
+
+import {
+  createIndex as createIndex2,
+  indexSchema as indexSchema2,
+  roleEncoder
+} from "@finbheara/domain/noun-index";
+import { roleName } from "@finbheara/domain/person";
+var ENCODER2 = roleEncoder();
+var WHO = { table: "who", value: "entry", valueType: "INTEGER PRIMARY KEY" };
+var ASKED2 = ["surname_key", "nn4", "id"];
+var SCHEMA3 = `
+CREATE TABLE entry(entry INTEGER PRIMARY KEY, source TEXT NOT NULL, clrg INTEGER, judge_id INTEGER, print TEXT NOT NULL);
+CREATE TABLE staff(school_id TEXT NOT NULL, name TEXT NOT NULL, clrg INTEGER, role TEXT, credentials TEXT NOT NULL,
+  years TEXT NOT NULL, y_from INTEGER, y_to INTEGER, former INTEGER NOT NULL, provisional INTEGER NOT NULL, entry INTEGER NOT NULL);
+CREATE TABLE td(school_id TEXT NOT NULL, clrg INTEGER NOT NULL, via TEXT NOT NULL, captured TEXT NOT NULL);
+CREATE TABLE register(clrg INTEGER NOT NULL, year INTEGER NOT NULL, cat TEXT NOT NULL, name_printed TEXT NOT NULL,
+  region TEXT NOT NULL, region_code TEXT, country TEXT NOT NULL);
+CREATE TABLE sat(clrg INTEGER, judge_id INTEGER, kind TEXT NOT NULL, event TEXT, year INTEGER, seats INTEGER NOT NULL, comps INTEGER NOT NULL);
+CREATE TABLE school(school_id TEXT PRIMARY KEY, display TEXT NOT NULL);
+`;
+var INDEXES3 = [
+  "CREATE INDEX entry_clrg ON entry(clrg)",
+  "CREATE INDEX entry_judge ON entry(judge_id)",
+  "CREATE INDEX staff_clrg ON staff(clrg)",
+  "CREATE INDEX staff_entry ON staff(entry)",
+  "CREATE INDEX td_clrg ON td(clrg)",
+  "CREATE INDEX register_clrg ON register(clrg)",
+  "CREATE INDEX sat_clrg ON sat(clrg)",
+  "CREATE INDEX sat_judge ON sat(judge_id)"
+];
+var staffIndex = {
+  name: "staff",
+  version: "1",
+  inputs: ["results", "school-staff.jsonl", "school-teachers.jsonl", "school-registry.jsonl"],
+  keyParts: () => [...PACKAGE_KEY_PARTS],
+  says: "teachers and adjudicators by name and TD number: the schools they taught at, the register, the seats they sat",
+  build(rel, out) {
+    const schema = indexSchema2(ENCODER2, WHO);
+    out.run(schema.table);
+    out.run(SCHEMA3);
+    const who = createIndex2(out, ENCODER2, WHO);
+    const putEntry = out.prepare("INSERT INTO entry VALUES (?, ?, ?, ?, ?)");
+    let next = 0;
+    const add = (role, print, clrg, judgeId, schools, source) => {
+      const id = ++next;
+      who.add({ name: roleName(role, print), id: clrg === null ? null : String(clrg), role, schools }, id);
+      putEntry.run(id, source, clrg, judgeId, print);
+      return id;
+    };
+    const putStaff = out.prepare("INSERT INTO staff VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
+    for (const s of readJsonl(rel.path("school-staff.jsonl"))) {
+      const entry = add("teacher", s.name, s.clrg, null, [s.school_id], "staff");
+      putStaff.run(s.school_id, s.name, s.clrg, s.role, JSON.stringify(s.credentials), JSON.stringify(s.years), s.from, s.to, s.former ? 1 : 0, s.provisional ? 1 : 0, entry);
+    }
+    const putTd = out.prepare("INSERT INTO td VALUES (?, ?, ?, ?)");
+    for (const t of readJsonl(rel.path("school-teachers.jsonl")))
+      putTd.run(t.school_id, t.clrg, t.via, t.captured);
+    const putSchool = out.prepare("INSERT OR REPLACE INTO school VALUES (?, ?)");
+    for (const r of readJsonl(rel.path("school-registry.jsonl")))
+      putSchool.run(r.school_id, r.display);
+    const src = rel.db("results");
+    const putReg = out.prepare("INSERT INTO register VALUES (?, ?, ?, ?, ?, ?, ?)");
+    const regNames = new Set;
+    for (const r of src.query("SELECT judge_clrg, year, cat, name_printed, region, region_code, country FROM adjudicators ORDER BY judge_clrg, year").all()) {
+      putReg.run(r.judge_clrg, r.year, r.cat, r.name_printed, r.region, r.region_code, r.country);
+      const k = `${r.judge_clrg}\x00${r.name_printed}`;
+      if (regNames.has(k))
+        continue;
+      regNames.add(k);
+      add("adjudicator", r.name_printed, r.judge_clrg, null, [], "register");
+    }
+    const seatPrints = src.query(`SELECT judge_name_printed AS p, judge_clrg AS c, judge_id AS j FROM panels WHERE judge_name_printed IS NOT NULL
+				 UNION SELECT judge_name_printed, judge_clrg, judge_id FROM feis_panels ORDER BY 1, 2, 3`).all();
+    for (const s of seatPrints)
+      if (s.c !== null || s.j !== null)
+        add("adjudicator", s.p, s.c, s.j, [], "seat");
+    const comps = new Map;
+    for (const c of src.query("SELECT DISTINCT competition, event, year FROM competitions").all())
+      comps.set(c.competition, { event: c.event, year: c.year });
+    const sat = new Map;
+    const seat = (kind, comp, c, j) => {
+      if (c === null && j === null)
+        return;
+      const at = comps.get(comp);
+      const k = `${c ?? ""}\x00${j ?? ""}\x00${kind}\x00${at?.event ?? ""}\x00${at?.year ?? ""}`;
+      const e = sat.get(k) ?? {
+        c,
+        j,
+        kind,
+        event: at?.event ?? null,
+        year: at?.year ?? null,
+        seats: 0,
+        comps: new Set
+      };
+      e.seats++;
+      e.comps.add(comp);
+      sat.set(k, e);
+    };
+    for (const r of src.query("SELECT slug, judge_clrg, judge_id FROM panels").all())
+      seat("majors", r.slug, r.judge_clrg, r.judge_id);
+    for (const r of src.query("SELECT address, judge_clrg, judge_id FROM feis_panels").all())
+      seat("feis", r.address, r.judge_clrg, r.judge_id);
+    const putSat = out.prepare("INSERT INTO sat VALUES (?, ?, ?, ?, ?, ?, ?)");
+    for (const e of sat.values())
+      putSat.run(e.c, e.j, e.kind, e.event, e.year, e.seats, e.comps.size);
+    for (const s of schema.indexes)
+      if (ASKED2.some((c) => s.endsWith(`(${c})`)))
+        out.run(s);
+    for (const s of INDEXES3)
+      out.run(s);
+  }
+};
+
+class StaffFinder2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  teacher(asked) {
+    return this.find(asked, "teacher");
+  }
+  adjudicator(asked) {
+    return this.find(asked, "adjudicator");
+  }
+  async find(asked, role) {
+    const db = await this.rel.indexDb("staff");
+    const a = asked.trim();
+    const sources = role === "teacher" ? ["staff"] : ["register", "seat"];
+    const entries = new Map;
+    const eq = db.query("SELECT * FROM entry WHERE entry = ?");
+    let refused;
+    if (/^\d+$/.test(a)) {
+      for (const r of db.query("SELECT entry FROM entry WHERE clrg = ?").all(Number(a)))
+        entries.set(r.entry, "id");
+    } else {
+      const q = roleName(role, a);
+      if (!q.isPerson())
+        refused = "the print reads as no person";
+      else {
+        const who = createIndex2(db, ENCODER2, WHO);
+        for (const { value, row } of who.rows({ surname_key: [q.surnameKey()], nn4: [q.nn4] })) {
+          const p = ENCODER2.decode(row);
+          if (p.role !== role)
+            continue;
+          const e = eq.get(value);
+          if (e === null || !sources.includes(e.source))
+            continue;
+          const level = nameLevel2(q, p.name);
+          if (level !== null)
+            entries.set(value, level);
+        }
+      }
+    }
+    const people = new Map;
+    for (const [id, level] of entries) {
+      const e = eq.get(id);
+      const k = e.clrg !== null ? `c${e.clrg}` : e.judge_id !== null ? `j${e.judge_id}` : `p${e.print}`;
+      const p = people.get(k) ?? {
+        clrg: e.clrg,
+        judge: e.judge_id,
+        level,
+        prints: new Set
+      };
+      p.level = p.level === "id" || level === "id" ? "id" : finer(p.level, level);
+      if (p.judge === null && e.judge_id !== null)
+        p.judge = e.judge_id;
+      p.prints.add(e.print);
+      people.set(k, p);
+    }
+    const out = [...people.values()].map((p) => this.person(db, p.clrg, p.judge, p.level, p.prints));
+    const rank = (l) => l === "id" ? -1 : ["nn0", "nn1", "nn2", "nn3", "nn4", "initial", "middle"].indexOf(l);
+    out.sort((x, y) => rank(x.nameLevel) - rank(y.nameLevel) || y.taught.length + y.sat.length - (x.taught.length + x.sat.length) || (x.clrg ?? Number.MAX_SAFE_INTEGER) - (y.clrg ?? Number.MAX_SAFE_INTEGER));
+    return {
+      tag: this.rel.tag,
+      asked: a,
+      role,
+      arm: out.length === 0 ? "none" : out.length === 1 ? "unique" : "ambiguous",
+      people: out,
+      ...refused !== undefined ? { refused } : {}
+    };
+  }
+  person(db, clrg, judge, level, prints) {
+    const school = db.query("SELECT display FROM school WHERE school_id = ?");
+    const display = (id) => school.get(id)?.display ?? null;
+    const names = new Set(prints);
+    let taught = [];
+    let td = [];
+    let register = [];
+    let satRows = [];
+    if (clrg !== null) {
+      judge ??= db.query("SELECT judge_id FROM entry WHERE clrg = ? AND judge_id IS NOT NULL ORDER BY judge_id LIMIT 1").get(clrg)?.judge_id ?? null;
+      for (const r of db.query("SELECT print FROM entry WHERE clrg = ?").all(clrg))
+        names.add(r.print);
+      taught = this.taughtWhere(db, "clrg = ?", clrg, display);
+      td = db.query("SELECT school_id, via, captured FROM td WHERE clrg = ? ORDER BY captured, school_id").all(clrg).map((t) => ({ ...t, school: display(t.school_id) }));
+      register = db.query("SELECT year, cat, name_printed, region, region_code, country FROM register WHERE clrg = ? ORDER BY year").all(clrg);
+      satRows = db.query("SELECT kind, event, year, seats, comps FROM sat WHERE clrg = ? ORDER BY year, kind, event").all(clrg);
+    } else if (judge !== null) {
+      satRows = db.query("SELECT kind, event, year, seats, comps FROM sat WHERE judge_id = ? ORDER BY year, kind, event").all(judge);
+    } else {
+      for (const p of prints)
+        taught.push(...this.taughtWhere(db, "clrg IS NULL AND name = ?", p, display));
+    }
+    return {
+      clrg,
+      judge_id: judge,
+      nameLevel: level,
+      names: [...names].sort(),
+      taught,
+      td_links: td,
+      register,
+      sat: satRows.map((s) => ({
+        kind: s.kind,
+        event: s.event,
+        year: s.year,
+        seats: s.seats,
+        competitions: s.comps
+      }))
+    };
+  }
+  taughtWhere(db, where, arg, display) {
+    return db.query(`SELECT school_id, name, role, credentials, years, y_from, y_to, former, provisional FROM staff WHERE ${where} ORDER BY school_id`).all(arg).map((s) => ({
+      school_id: s.school_id,
+      school: display(s.school_id),
+      name: s.name,
+      role: s.role,
+      credentials: JSON.parse(s.credentials),
+      years: JSON.parse(s.years),
+      from: s.y_from,
+      to: s.y_to,
+      former: s.former !== 0,
+      provisional: s.provisional !== 0
+    }));
+  }
+}
+
+import { createIndex as createIndex3, indexSchema as indexSchema3 } from "@finbheara/domain/noun-index";
+import {
+  DEFAULT_SCHOOL_NAME_READER,
+  schoolEncoder
+} from "@finbheara/domain/school";
+var GENERIC_SCHOOL_READER = {
+  id: "generic",
+  reader: DEFAULT_SCHOOL_NAME_READER
+};
+var encoderOf = (r) => schoolEncoder({ reader: r.reader });
+var TABLE = "school_name";
+var schoolsIndex = {
+  name: "schools",
+  version: "1",
+  inputs: ["results", "school-registry.jsonl", "school-redirects.jsonl"],
+  says: "every published school print and its ids, read at the school reader's slots",
+  keyParts: (rel) => [`reader=${rel.schoolReader().id}`],
+  build(rel, out) {
+    const choice = rel.schoolReader();
+    const encoder = encoderOf(choice);
+    out.run("CREATE TABLE print_id(print TEXT NOT NULL, school_id TEXT NOT NULL, rows INTEGER NOT NULL, PRIMARY KEY(print, school_id)) WITHOUT ROWID");
+    out.run("CREATE TABLE registry(school_id TEXT PRIMARY KEY, display TEXT NOT NULL, regions TEXT NOT NULL, places TEXT NOT NULL)");
+    out.run("CREATE TABLE redirect(old_id TEXT PRIMARY KEY, new_id TEXT NOT NULL, kind TEXT NOT NULL)");
+    const schema = indexSchema3(encoder, { table: TABLE });
+    out.run(schema.table);
+    const pairs = rel.db("results").query("SELECT trim(school_printed) AS p, school_id AS s, count(*) AS n FROM results WHERE school_id IS NOT NULL GROUP BY 1, 2 ORDER BY 1, 2").all();
+    const putPair = out.prepare("INSERT INTO print_id VALUES (?, ?, ?)");
+    for (const r of pairs)
+      putPair.run(r.p, r.s, r.n);
+    const names = createIndex3(out, encoder, {
+      table: TABLE
+    });
+    let last = null;
+    for (const r of pairs) {
+      if (r.p === last)
+        continue;
+      last = r.p;
+      names.add(choice.reader.schoolName(r.p), r.p);
+    }
+    for (const s of schema.indexes)
+      out.run(s);
+    const putReg = out.prepare("INSERT OR REPLACE INTO registry VALUES (?, ?, ?, ?)");
+    for (const r of readJsonl(rel.path("school-registry.jsonl")))
+      putReg.run(r.school_id, r.display, JSON.stringify([...new Set(r.regions.map((x) => x.region))]), JSON.stringify([...new Set(r.locations.map((x) => x.place))]));
+    const putRed = out.prepare("INSERT OR REPLACE INTO redirect VALUES (?, ?, ?)");
+    for (const r of readJsonl(rel.path("school-redirects.jsonl")))
+      putRed.run(r.old_id, r.new_id, r.kind);
+  }
+};
+
+class SchoolResolver2 {
+  rel;
+  constructor(rel) {
+    this.rel = rel;
+  }
+  async resolve(asked, q = {}) {
+    const db = await this.rel.indexDb("schools");
+    const reg = db.query("SELECT display, regions, places FROM registry WHERE school_id = ?");
+    const candidate = (id, by, rows, prints) => {
+      const r = reg.get(id);
+      return {
+        school_id: id,
+        display: r?.display ?? null,
+        rows,
+        by,
+        prints,
+        regions: r === null ? [] : JSON.parse(r.regions),
+        places: r === null ? [] : JSON.parse(r.places)
+      };
+    };
+    const answer = (candidates, extra = {}) => {
+      let cs = candidates.sort((a, b) => b.rows - a.rows || (a.school_id < b.school_id ? -1 : 1));
+      let region;
+      if (q.region !== undefined) {
+        const kept = cs.filter((c) => c.regions.length === 0 || c.regions.includes(q.region));
+        region = { asked: q.region, narrowed: kept.length > 0 && kept.length < cs.length };
+        if (kept.length > 0)
+          cs = kept;
+      }
+      return {
+        tag: this.rel.tag,
+        asked,
+        arm: cs.length === 0 ? "none" : cs.length === 1 ? "unique" : "ambiguous",
+        candidates: cs,
+        ...region !== undefined ? { region } : {},
+        ...extra
+      };
+    };
+    const a = asked.trim();
+    if (reg.get(a) !== null)
+      return answer([candidate(a, "id", 0, [])]);
+    let live = a;
+    const seen = new Set;
+    for (;; ) {
+      const r = db.query("SELECT new_id FROM redirect WHERE old_id = ?").get(live);
+      if (r === null || seen.has(r.new_id))
+        break;
+      seen.add(live);
+      live = r.new_id;
+    }
+    if (live !== a)
+      return answer([candidate(live, "redirect", 0, [])], { redirected: { from: a, to: live } });
+    const byPrints = (prints, by) => {
+      const ids = new Map;
+      const q2 = db.query("SELECT school_id, rows FROM print_id WHERE print = ?");
+      for (const p of prints)
+        for (const r of q2.all(p)) {
+          const e = ids.get(r.school_id) ?? { rows: 0, prints: new Set };
+          e.rows += r.rows;
+          e.prints.add(p);
+          ids.set(r.school_id, e);
+        }
+      return [...ids].map(([id, e]) => candidate(id, by, e.rows, [...e.prints].sort()));
+    };
+    const exact = byPrints([a], "print");
+    if (exact.length > 0)
+      return answer(exact);
+    const choice = this.rel.schoolReader();
+    const read = choice.reader.schoolName(a);
+    if (!read.isSchool())
+      return answer([], {
+        refused: read.refusal?.reason ?? (read.isEmpty() ? "empty" : "not a school")
+      });
+    const names = createIndex3(db, encoderOf(choice), {
+      table: TABLE
+    });
+    for (const level of ["sn3", "realWords"]) {
+      const prints = names.get(read, level);
+      if (prints.length > 0)
+        return answer(byPrints(prints, level));
+    }
+    return answer([]);
+  }
+}
+
+function defaultBuilders2() {
+  return [schoolsIndex, feisesIndex, compsIndex, dancersIndex, staffIndex];
+}
+var indexDir = (rel) => join(rel.dir, "index");
+var indexPath2 = (rel, name) => join(indexDir(rel), `${name}.sqlite`);
+function indexKey2(rel, b) {
+  const files = rel.receipt().files;
+  const parts = [b.name, b.version, ...b.keyParts?.(rel) ?? []];
+  for (const input of b.inputs) {
+    const local = rel.plan(input).local;
+    parts.push(`${local}=${files[local]?.sha256 ?? "?"}`);
+  }
+  return createHash2("sha256").update(parts.join("\x00")).digest("hex");
+}
+function keyOf(path) {
+  if (!existsSync(path))
+    return null;
+  try {
+    const db = new Database(path, { readonly: true });
+    try {
+      const r = db.query("SELECT v FROM meta WHERE k = 'key'").get();
+      return r?.v ?? null;
+    } finally {
+      db.close();
+    }
+  } catch {
+    return null;
+  }
+}
+function isCurrent2(rel, b) {
+  return keyOf(indexPath2(rel, b.name)) === indexKey2(rel, b);
+}
+function buildIndex2(rel, b, o) {
+  const out = indexPath2(rel, b.name);
+  const key = indexKey2(rel, b);
+  if (!o.force && keyOf(out) === key)
+    return out;
+  mkdirSync(indexDir(rel), { recursive: true });
+  const tmp = `${out}.building.${process.pid}`;
+  rmSync(tmp, { force: true });
+  const t0 = performance.now();
+  const db = new Database(tmp, { create: true });
+  try {
+    db.run("PRAGMA journal_mode = OFF");
+    db.run("PRAGMA synchronous = OFF");
+    db.run("CREATE TABLE meta(k TEXT PRIMARY KEY, v TEXT NOT NULL)");
+    db.transaction(() => b.build(rel, db))();
+    const put = db.prepare("INSERT INTO meta(k, v) VALUES (?, ?)");
+    put.run("key", key);
+    put.run("builder", b.name);
+    put.run("version", b.version);
+    put.run("tag", rel.tag);
+    db.run("VACUUM");
+  } catch (e) {
+    db.close();
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+  db.close();
+  renameSync(tmp, out);
+  o.log?.(`index ${rel.tag} ${b.name}: built in ${((performance.now() - t0) / 1000).toFixed(1)} s`);
+  return out;
+}
+function listIndexes2(rel) {
+  const dir = indexDir(rel);
+  if (!existsSync(dir))
+    return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".sqlite")).sort().map((f) => {
+    const name = f.slice(0, -".sqlite".length);
+    const path = join(dir, f);
+    const b = rel.builders().find((x) => x.name === name);
+    return {
+      name,
+      path,
+      bytes: statSync(path).size,
+      current: b === undefined ? null : keyOf(path) === indexKey2(rel, b)
+    };
+  });
+}
+
+import {
+  copyFileSync,
+  existsSync as existsSync5,
+  linkSync,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
+  rmSync as rmSync4,
+  statSync as statSync3
+} from "fs";
+import { isAbsolute, join as join4, relative, resolve, sep } from "path";
+
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
+import { join as join2 } from "path";
+var pinPath = (root) => join2(root, "PINNED.json");
+function readPin2(root) {
+  const p = pinPath(root);
+  if (!existsSync2(p))
+    return null;
+  try {
+    const v = JSON.parse(readFileSync2(p, "utf8"));
+    return typeof v.tag === "string" && parseArchiveTag2(v.tag) !== null ? { tag: v.tag, source: typeof v.source === "string" ? v.source : "unknown" } : null;
+  } catch {
+    return null;
+  }
+}
+function writePin(root, pin) {
+  if (parseArchiveTag2(pin.tag) === null)
+    throw new Error(`pin: "${pin.tag}" is not a release tag`);
+  writeJsonAtomic2(pinPath(root), pin);
+}
+function clearPin(root) {
+  const p = pinPath(root);
+  if (!existsSync2(p))
+    return false;
+  rmSync2(p);
+  return true;
+}
+
+import { Database as Database2 } from "bun:sqlite";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
+  statSync as statSync2
+} from "fs";
+import { join as join3 } from "path";
+
+import { Age as Age3 } from "@finbheara/domain/age";
+import { compTitle as compTitle2 } from "@finbheara/domain/title";
+function youngest2(answers) {
+  const key = (a) => {
+    const iv = Age3.from(a.age, { year: null }).interval();
+    return iv === null ? [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY] : [iv.hi, iv.lo];
+  };
+  let best;
+  let bk = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];
+  for (const a of answers) {
+    const k = key(a);
+    if (best === undefined || k[0] < bk[0] || k[0] === bk[0] && k[1] > bk[1]) {
+      best = a;
+      bk = k;
+    }
+  }
+  return best;
+}
+function dancerResolverOf2(rel) {
+  return rel.dancers;
+}
+
+class RegistrationResolver2 {
+  rel;
+  comps;
+  dancers;
+  constructor(rel, comps, dancers) {
+    this.rel = rel;
+    this.comps = comps;
+    this.dancers = dancers;
+  }
+  async dancer(q) {
+    const dancers = this.dancers === undefined ? dancerResolverOf2(this.rel) : this.dancers;
+    let put = q;
+    let comp;
+    const age = q.age;
+    if (age !== undefined && "comp" in age) {
+      const slash = age.comp.lastIndexOf("/");
+      if (slash > 0) {
+        comp = await this.comps.resolve({
+          feis: age.comp.slice(0, slash),
+          code: age.comp.slice(slash + 1),
+          ...age.year !== undefined ? { year: age.year } : {}
+        });
+        if (comp.arm === "unique" && comp.age !== null)
+          put = { ...q, age: { band: comp.age, year: comp.feis.year } };
+      }
+    }
+    return {
+      tag: this.rel.tag,
+      asked: q,
+      put,
+      ...comp !== undefined ? { comp } : {},
+      dancer: dancers === null ? { arm: "unavailable", why: "this release opens no dancer resolver" } : await dancers.resolve(put)
+    };
+  }
+  async resolve(rows) {
+    const seen = new Map;
+    const out = [];
+    for (const row of rows) {
+      const comps = [];
+      for (const code of row.codes) {
+        const title = row.titles?.[code];
+        const key = JSON.stringify([row.feis, code, row.year ?? null, title ?? null]);
+        let a = seen.get(key);
+        if (a === undefined) {
+          a = await this.comps.resolve({
+            feis: row.feis,
+            code,
+            ...row.year !== undefined ? { year: row.year } : {},
+            ...title !== undefined ? { title } : {}
+          });
+          seen.set(key, a);
+        }
+        comps.push(a);
+      }
+      const read = comps.filter((c) => c.arm === "unique" && c.age !== null);
+      const first = youngest2(read);
+      const printed = first !== undefined ? [] : comps.flatMap((c, i) => {
+        const code = row.codes[i];
+        const t = row.titles?.[code];
+        const a = t === undefined ? null : compTitle2(t).age;
+        return a?.isAge() === true && a.kind !== "yob" ? [{ age: a.ag1, year: c.feis.year, code }] : [];
+      });
+      const byTitle = youngest2(printed);
+      const age = first !== undefined ? {
+        band: first.age,
+        year: first.feis.year,
+        code: first.asked.code,
+        from: "comp"
+      } : byTitle !== undefined ? { band: byTitle.age, year: byTitle.year, code: byTitle.code, from: "title" } : null;
+      const bands = [...new Set((first !== undefined ? read : printed).map((c) => c.age))];
+      const order = nameOrderOf(row.order);
+      const asked = {
+        name: row.name,
+        ...order !== undefined ? { order } : {},
+        ...row.school !== undefined ? { school: row.school } : {},
+        ...age !== null ? { age: { band: age.band, year: age.year } } : {},
+        ...row.asOf !== undefined ? { asOf: row.asOf } : {}
+      };
+      const { dancer } = await this.dancer(asked);
+      out.push({
+        tag: this.rel.tag,
+        row,
+        comps,
+        age,
+        ...bands.length > 1 ? { bands } : {},
+        dancer,
+        asked
+      });
+    }
+    return out;
+  }
+}
+
+import { spawn } from "child_process";
+import { createWriteStream as createWriteStream2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+import { Readable } from "stream";
+import { pipeline as pipeline2 } from "stream/promises";
+function run(cmd, args) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let child;
+    try {
+      child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      resolve({ status: null, stdout, stderr: e.message });
+      return;
+    }
+    child.stdout?.on("data", (d) => {
+      stdout += String(d);
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += String(d);
+    });
+    child.on("error", (e) => resolve({ status: null, stdout, stderr: e.message }));
+    child.on("close", (status) => resolve({ status, stdout, stderr }));
+  });
+}
+var firstLine = (s) => s.trim().split(`
+`)[0] ?? "";
+var ghRemote2 = {
+  name: "gh",
+  async tags(repo) {
+    const r = await run("gh", [
+      "release",
+      "list",
+      "-R",
+      repo,
+      "--limit",
+      "500",
+      "--exclude-drafts",
+      "--json",
+      "tagName",
+      "--jq",
+      ".[].tagName"
+    ]);
+    if (r.status !== 0)
+      throw new Error(`gh release list -R ${repo}: ${firstLine(r.stderr)}`);
+    return r.stdout.split(`
+`).map((t) => t.trim()).filter((t) => t !== "");
+  },
+  async assets(repo, tag) {
+    const r = await run("gh", ["release", "view", tag, "-R", repo, "--json", "assets"]);
+    if (r.status !== 0)
+      throw new Error(`gh release view ${tag} -R ${repo}: ${firstLine(r.stderr)}`);
+    const v = JSON.parse(r.stdout);
+    return (v.assets ?? []).map((a) => ({ name: a.name, size: a.size, digest: a.digest ?? null }));
+  },
+  async download(repo, tag, name, dest) {
+    const r = await run("gh", [
+      "release",
+      "download",
+      tag,
+      "-R",
+      repo,
+      "-p",
+      name,
+      "-O",
+      dest,
+      "--clobber"
+    ]);
+    if (r.status !== 0 || !existsSync3(dest))
+      throw new Error(`gh release download ${tag} -p ${name}: ${firstLine(r.stderr)}`);
+  }
+};
+var API = "https://api.github.com";
+function nodeWebStream(body) {
+  return body;
+}
+function headers(env, accept) {
+  const token = env.GITHUB_TOKEN ?? env.GH_TOKEN;
+  return {
+    accept,
+    "user-agent": "archive-client",
+    "x-github-api-version": "2022-11-28",
+    ...token !== undefined && token !== "" ? { authorization: `Bearer ${token}` } : {}
+  };
+}
+function httpsRemote2(env = process.env, fetchImpl = fetch) {
+  const json = async (url) => {
+    const res = await fetchImpl(url, { headers: headers(env, "application/vnd.github+json") });
+    if (!res.ok)
+      throw new Error(`GET ${url}: ${res.status} ${res.statusText}`);
+    return await res.json();
+  };
+  const release = (repo, tag) => json(`${API}/repos/${repo}/releases/tags/${encodeURIComponent(tag)}`);
+  return {
+    name: "https",
+    async tags(repo) {
+      const out = [];
+      for (let page = 1;page <= 10; page++) {
+        const rows = await json(`${API}/repos/${repo}/releases?per_page=100&page=${page}`);
+        for (const r of rows)
+          if (!r.draft)
+            out.push(r.tag_name);
+        if (rows.length < 100)
+          break;
+      }
+      return out;
+    },
+    async assets(repo, tag) {
+      return (await release(repo, tag)).assets.map((a) => ({
+        name: a.name,
+        size: a.size,
+        digest: a.digest ?? null
+      }));
+    },
+    async download(repo, tag, name, dest) {
+      const a = (await release(repo, tag)).assets.find((x) => x.name === name);
+      if (a === undefined)
+        throw new Error(`${tag} has no asset ${name}`);
+      const res = await fetchImpl(a.url, { headers: headers(env, "application/octet-stream") });
+      if (!res.ok || res.body === null)
+        throw new Error(`GET ${a.url}: ${res.status} ${res.statusText}`);
+      mkdirSync2(dirname(dest), { recursive: true });
+      await pipeline2(Readable.fromWeb(nodeWebStream(res.body)), createWriteStream2(dest));
+    }
+  };
+}
+function fallbackRemote2(first, second) {
+  const both = (f) => async (...a) => {
+    try {
+      return await f(first)(...a);
+    } catch (e1) {
+      try {
+        return await f(second)(...a);
+      } catch (e2) {
+        throw new Error(`${first.name}: ${e1.message}; ${second.name}: ${e2.message}`);
+      }
+    }
+  };
+  return {
+    name: `${first.name}+${second.name}`,
+    tags: both((r) => r.tags.bind(r)),
+    assets: both((r) => r.assets.bind(r)),
+    download: both((r) => r.download.bind(r))
+  };
+}
+var installed = null;
+function setRemote2(r) {
+  const was = installed;
+  installed = r;
+  return was;
+}
+function defaultRemote() {
+  return installed ?? fallbackRemote2(ghRemote2, httpsRemote2());
+}
+
+function tagDir(root, tag) {
+  if (parseArchiveTag2(tag) === null)
+    throw new Error(`archive-client: "${tag}" is not a release tag (archive-YYYY.MM.DD[-N[.k]])`);
+  return join3(root, tag);
+}
+var receiptPath = (dir) => join3(dir, ".client.json");
+function readReceipt(dir) {
+  const p = receiptPath(dir);
+  if (!existsSync4(p))
+    return null;
+  try {
+    return JSON.parse(readFileSync3(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function resolveTag2(spec, opts = {}) {
+  const s = typeof spec === "object" ? spec : parseReleaseSpec2(spec);
+  if (typeof s === "string")
+    throw new Error(s);
+  const root = cacheRoot2(opts);
+  if (s.kind === "pinned") {
+    const pin = readPin2(root);
+    return resolveTag2(pin === null ? { kind: "latest" } : { kind: "tag", tag: pin.tag }, opts);
+  }
+  if (s.kind === "tag" && existsSync4(join3(tagDir(root, s.tag), "MANIFEST.json")))
+    return s.tag;
+  const repo = requireRepo2(opts);
+  const tags = await (opts.remote ?? defaultRemote()).tags(repo);
+  const tag = pickTag2(tags, s);
+  if (tag === null)
+    throw new Error(`archive-client: ${repo} publishes no release ${s.kind === "tag" ? s.tag : s.kind === "cut" ? `of cut ${s.cut}${s.fraction > 0 ? `.${s.fraction}` : ""}` : "at all"}`);
+  return tag;
+}
+function dropIfEmpty(dir) {
+  if (existsSync4(dir) && readdirSync2(dir).length === 0)
+    rmSync3(dir, { recursive: true });
+}
+
+class Release2 {
+  tag;
+  cut;
+  fraction;
+  dir;
+  root;
+  manifest;
+  feises;
+  schools;
+  dancers;
+  results;
+  majors;
+  staff;
+  comps;
+  registrations;
+  opts;
+  handles = new Map;
+  remoteAssets = null;
+  constructor(tag, root, manifest, opts) {
+    const t = parseArchiveTag2(tag);
+    this.tag = tag;
+    this.cut = t?.cut;
+    this.fraction = t?.fraction ?? 0;
+    this.root = root;
+    this.dir = tagDir(root, tag);
+    this.manifest = manifest;
+    this.opts = opts;
+    this.feises = new FeisFinder2(this);
+    this.schools = new SchoolResolver2(this);
+    this.dancers = new DancerResolver2(this);
+    this.results = new ResultFinder2(this);
+    this.majors = new MajorsFinder2(this);
+    this.staff = new StaffFinder2(this);
+    this.comps = new CompResolver2(this);
+    this.registrations = new RegistrationResolver2(this, this.comps, opts.dancerResolver);
+  }
+  receipt() {
+    return readReceipt(this.dir) ?? { tag: this.tag, source: "unknown", files: {} };
+  }
+  plan(asset) {
+    return planAsset2(asset, this.manifest);
+  }
+  has(asset) {
+    return existsSync4(join3(this.dir, this.plan(asset).local));
+  }
+  path(asset) {
+    const p = join3(this.dir, this.plan(asset).local);
+    if (!existsSync4(p))
+      throw new Error(`archive-client: ${this.tag} has no ${asset} in the cache: fetch it first (\`await rel.fetch("${asset}")\`, or \`fetch --release ${this.tag} --assets ${asset}\`)`);
+    return p;
+  }
+  async fetch(...assets) {
+    const out = [];
+    for (const a of assets)
+      out.push(await this.fetchOne(a));
+    return out;
+  }
+  async listed() {
+    if (this.remoteAssets === null)
+      this.remoteAssets = await (this.opts.remote ?? defaultRemote()).assets(requireRepo2(this.opts), this.tag);
+    return this.remoteAssets;
+  }
+  async fetchOne(asset) {
+    const plan = this.plan(asset);
+    const dest = join3(this.dir, plan.local);
+    const have = this.receipt().files[plan.local];
+    if (existsSync4(dest) && have !== undefined)
+      return have;
+    const log = this.opts.log ?? (() => {});
+    if (existsSync4(dest) && plan.contentSha256 !== null) {
+      const sha = await sha256File2(dest);
+      if (sha === plan.contentSha256) {
+        const adopted = {
+          from: plan.local,
+          sha256: sha,
+          bytes: statSync2(dest).size,
+          verified: ["manifest"]
+        };
+        log(`adopt ${this.tag} ${plan.local} (the manifest's sha256)`);
+        this.record(plan.local, adopted);
+        return adopted;
+      }
+    }
+    const listed = await this.listed();
+    const pub = plan.published.map((n) => listed.find((a) => a.name === n)).find((a) => a !== undefined);
+    if (pub === undefined)
+      throw new Error(`archive-client: ${this.tag} publishes no ${plan.published.join(" or ")} (asked: ${asset})`);
+    const part = join3(this.dir, ".part");
+    mkdirSync3(part, { recursive: true });
+    const raw = join3(part, pub.name);
+    log(`fetch ${this.tag} ${pub.name} (${pub.size} bytes)`);
+    await (this.opts.remote ?? defaultRemote()).download(requireRepo2(this.opts), this.tag, pub.name, raw);
+    const landed = await land(raw, pub, plan, dest, this.opts, log);
+    this.record(plan.local, landed);
+    dropIfEmpty(part);
+    return landed;
+  }
+  record(local, f) {
+    const r = this.receipt();
+    r.files[local] = f;
+    writeJsonAtomic2(receiptPath(this.dir), r);
+  }
+  db(asset) {
+    let h = this.handles.get(asset);
+    if (h === undefined) {
+      h = new Database2(this.path(asset), { readonly: true });
+      this.handles.set(asset, h);
+    }
+    return h;
+  }
+  schoolReader() {
+    return this.opts.schoolReader ?? GENERIC_SCHOOL_READER;
+  }
+  builders() {
+    return this.opts.builders ?? defaultBuilders2();
+  }
+  async index(name, o = {}) {
+    const b = this.builders().find((x) => x.name === name);
+    if (b === undefined)
+      throw new Error(`archive-client: no index "${name}" (known: ${this.builders().map((x) => x.name).join(", ")})`);
+    await this.fetch(...b.inputs);
+    return buildIndex2(this, b, { force: o.force ?? false, log: this.opts.log });
+  }
+  async indexDb(name) {
+    const key = `index:${name}`;
+    const open = this.handles.get(key);
+    if (open !== undefined)
+      return open;
+    const h = new Database2(await this.index(name), { readonly: true });
+    this.handles.set(key, h);
+    return h;
+  }
+  close() {
+    for (const h of this.handles.values())
+      h.close();
+    this.handles.clear();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+}
+async function land(raw, pub, plan, dest, opts, log) {
+  const verified = [];
+  const host = sha256OfDigest(pub.digest);
+  if (host !== null) {
+    const got = await sha256File2(raw);
+    if (got !== host) {
+      rmSync3(raw, { force: true });
+      throw new Error(`archive-client: ${pub.name} does not match the host's digest (sha256 ${got}, the host says ${host})`);
+    }
+    verified.push("host-digest");
+  }
+  let landedAt = raw;
+  let sha;
+  if (plan.decompress && pub.name.endsWith(".zst")) {
+    landedAt = `${raw.slice(0, -".zst".length)}.plain`;
+    log(`decompress ${pub.name}`);
+    sha = await unzstdTo2(raw, landedAt);
+  } else
+    sha = await sha256File2(raw);
+  if (plan.contentSha256 !== null) {
+    if (sha !== plan.contentSha256) {
+      rmSync3(landedAt, { force: true });
+      throw new Error(`archive-client: ${plan.local} does not match MANIFEST.json (sha256 ${sha}, the manifest says ${plan.contentSha256})`);
+    }
+    verified.push("manifest");
+  }
+  if (verified.length === 0 && opts.strict === true) {
+    rmSync3(landedAt, { force: true });
+    throw new Error(`archive-client: nothing verifies ${pub.name} (no host digest, no manifest hash) and strict is set`);
+  }
+  renameSync2(landedAt, dest);
+  if (landedAt !== raw) {
+    if (opts.keepCompressed === true)
+      renameSync2(raw, `${dest}.zst`);
+    else
+      rmSync3(raw, { force: true });
+  }
+  return { from: pub.name, sha256: sha, bytes: statSync2(dest).size, verified };
+}
+async function openRelease2(spec = "pinned", opts = {}) {
+  const root = cacheRoot2(opts);
+  const tag = await resolveTag2(spec, opts);
+  const dir = tagDir(root, tag);
+  const manifestPath = join3(dir, "MANIFEST.json");
+  if (!existsSync4(manifestPath)) {
+    const remote = opts.remote ?? defaultRemote();
+    const repo = requireRepo2(opts);
+    const listed = await remote.assets(repo, tag);
+    const pub = listed.find((a) => a.name === "MANIFEST.json");
+    if (pub === undefined)
+      throw new Error(`archive-client: ${tag} publishes no MANIFEST.json`);
+    const part = join3(dir, ".part");
+    mkdirSync3(part, { recursive: true });
+    const raw = join3(part, "MANIFEST.json");
+    await remote.download(repo, tag, "MANIFEST.json", raw);
+    const landed = await land(raw, pub, planAsset2("MANIFEST.json", null), manifestPath, opts, () => {});
+    writeJsonAtomic2(receiptPath(dir), {
+      tag,
+      source: repo,
+      files: { "MANIFEST.json": landed }
+    });
+    dropIfEmpty(part);
+  }
+  const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
+  const rel = new Release2(tag, root, manifest, opts);
+  await rel.fetch(...opts.assets ?? ["results"]);
+  return rel;
+}
+function openCached2(tag, opts = {}) {
+  const root = cacheRoot2(opts);
+  const p = join3(tagDir(root, tag), "MANIFEST.json");
+  if (!existsSync4(p))
+    return null;
+  return new Release2(tag, root, JSON.parse(readFileSync3(p, "utf8")), opts);
+}
+
+function duBytes(p) {
+  if (!existsSync5(p))
+    return 0;
+  const s = statSync3(p);
+  if (!s.isDirectory())
+    return s.size;
+  let n = 0;
+  for (const e of readdirSync3(p))
+    n += duBytes(join4(p, e));
+  return n;
+}
+
+class ReleaseManager2 {
+  opts;
+  root;
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.root = cacheRoot2(opts);
+  }
+  cachedTags() {
+    if (!existsSync5(this.root))
+      return [];
+    return readdirSync3(this.root).filter((t) => parseArchiveTag2(t) !== null && existsSync5(join4(this.root, t, "MANIFEST.json"))).sort(compareTagsNewestFirst2);
+  }
+  cached(tag) {
+    const r = openCached2(tag, this.opts);
+    if (r === null)
+      throw new Error(`archive-client: ${tag} is not in the cache (${this.root})`);
+    return r;
+  }
+  async list(o = {}) {
+    const pin = readPin2(this.root);
+    const cached = this.cachedTags().map((tag) => {
+      const rel = this.cached(tag);
+      const receipt = rel.receipt();
+      return {
+        tag,
+        cut: rel.cut,
+        source: receipt.source,
+        pinned: pin?.tag === tag,
+        bytes: duBytes(rel.dir),
+        files: Object.entries(receipt.files).map(([name, f]) => ({ name, bytes: f.bytes, verified: f.verified })).sort((a, b) => a.name < b.name ? -1 : 1),
+        indexes: listIndexes2(rel)
+      };
+    });
+    const out = { root: this.root, repo: repoOf2(this.opts), pin, cached };
+    if (o.remote === true)
+      out.published = (await (this.opts.remote ?? defaultRemote()).tags(requireRepo2(this.opts))).filter((t) => parseArchiveTag2(t) !== null).sort(compareTagsNewestFirst2);
+    return out;
+  }
+  fetch(spec, o = {}) {
+    return openRelease2(spec, { ...this.opts, assets: o.assets ?? ["results"] });
+  }
+  async pin(spec) {
+    const rel = await openRelease2(spec, { ...this.opts, assets: [] });
+    const pin = { tag: rel.tag, source: rel.receipt().source };
+    writePin(this.root, pin);
+    return pin;
+  }
+  unpin() {
+    return clearPin(this.root);
+  }
+  current() {
+    const pin = readPin2(this.root);
+    return { pin, cached: pin !== null && openCached2(pin.tag, this.opts) !== null };
+  }
+  config(patch) {
+    if (patch.repo !== undefined)
+      repoOf2({ ...this.opts, repo: patch.repo });
+    return writeConfig2(this.root, patch);
+  }
+  readConfig() {
+    return readConfig2(this.root);
+  }
+  async add(dir, tag) {
+    if (parseArchiveTag2(tag) === null)
+      throw new Error(`add: "${tag}" is not a release tag`);
+    const mf = join4(dir, "MANIFEST.json");
+    if (!existsSync5(mf))
+      throw new Error(`add: ${dir} holds no MANIFEST.json`);
+    const dest = tagDir(this.root, tag);
+    if (existsSync5(join4(dest, "MANIFEST.json")))
+      throw new Error(`add: ${tag} is already in the cache (${dest}); \`rm ${tag}\` first`);
+    const manifest = JSON.parse(readFileSync4(mf, "utf8"));
+    const part = join4(dest, ".part");
+    mkdirSync4(part, { recursive: true });
+    const receipt = { tag, source: `local:${dir}`, files: {} };
+    const log = this.opts.log ?? (() => {});
+    for (const name of readdirSync3(dir).sort()) {
+      const src = join4(dir, name);
+      if (!statSync3(src).isFile())
+        continue;
+      const raw = join4(part, name);
+      try {
+        linkSync(src, raw);
+      } catch {
+        copyFileSync(src, raw);
+      }
+      const base = name.replace(/\.sqlite(\.zst)?$/, "");
+      const asked = base !== name && isDatabase(base) ? base : name;
+      const plan = planAsset2(asked, manifest);
+      const landed = await land(raw, { name, digest: null }, plan, join4(dest, plan.local), this.opts, log);
+      receipt.files[plan.local] = landed;
+    }
+    rmSync4(part, { recursive: true, force: true });
+    writeJsonAtomic2(receiptPath(dest), receipt);
+    const rel = openCached2(tag, this.opts);
+    if (rel === null)
+      throw new Error(`add: ${tag} did not land`);
+    return rel;
+  }
+  async index(spec, names = [], o = {}) {
+    const rel = await openRelease2(spec, { ...this.opts, assets: [] });
+    const want = names.length > 0 ? names : rel.builders().map((b) => b.name);
+    const built = [];
+    for (const name of want) {
+      const b = rel.builders().find((x) => x.name === name);
+      if (b === undefined)
+        throw new Error(`index: no index "${name}"`);
+      await rel.fetch(...b.inputs);
+      built.push({
+        name,
+        path: buildIndex2(rel, b, { force: o.force ?? false, log: this.opts.log })
+      });
+    }
+    rel.close();
+    return { tag: rel.tag, built };
+  }
+  plan(dryRun) {
+    return { dryRun, remove: [], keep: [], bytes: 0 };
+  }
+  planRemove(p, path, why) {
+    const rel = relative(resolve(this.root), resolve(path));
+    if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+      throw new Error(`archive-client: refusing to remove ${path}: not inside ${this.root}`);
+    p.remove.push({ path: resolve(path), bytes: duBytes(path), why });
+  }
+  apply(p) {
+    p.bytes = p.remove.reduce((n, r) => n + r.bytes, 0);
+    if (!p.dryRun)
+      for (const r of p.remove)
+        rmSync4(r.path, { recursive: true, force: true });
+    return p;
+  }
+  prune(o = {}) {
+    const keep = o.keep ?? 1;
+    if (!Number.isInteger(keep) || keep < 0)
+      throw new Error(`prune: --keep ${keep} is not a count`);
+    const pin = readPin2(this.root);
+    const p = this.plan(o.dryRun ?? false);
+    this.cachedTags().forEach((tag, i) => {
+      if (tag === pin?.tag)
+        p.keep.push({ tag, why: "pinned" });
+      else if (i < keep)
+        p.keep.push({ tag, why: `among the ${keep} newest` });
+      else
+        this.planRemove(p, tagDir(this.root, tag), `older than the ${keep} newest`);
+    });
+    return this.apply(p);
+  }
+  remove(tag, o = {}) {
+    const path = tagDir(this.root, tag);
+    if (!existsSync5(path))
+      throw new Error(`${tag} is not in the cache`);
+    if (readPin2(this.root)?.tag === tag)
+      throw new Error(`${tag} is pinned: \`unpin\` first`);
+    const p = this.plan(o.dryRun ?? false);
+    this.planRemove(p, path, "asked");
+    return this.apply(p);
+  }
+  dropIndexes(tag, o = {}) {
+    const p = this.plan(o.dryRun ?? false);
+    for (const t of tag === undefined ? this.cachedTags() : [tag]) {
+      const path = indexDir({ dir: tagDir(this.root, t) });
+      if (existsSync5(path))
+        this.planRemove(p, path, `${t}'s indexes`);
+    }
+    return this.apply(p);
+  }
+  async verify(tag) {
+    const rel = this.cached(tag);
+    const bad = [];
+    for (const [name, f] of Object.entries(rel.receipt().files)) {
+      const p = join4(rel.dir, name);
+      const got = existsSync5(p) ? await sha256File2(p) : "missing";
+      if (got !== f.sha256)
+        bad.push({ file: name, want: f.sha256, got });
+    }
+    return bad;
+  }
+}
+function releases2(opts = {}) {
+  return new ReleaseManager2(opts);
+}
+
+export { DATABASES2, planAsset2, sha256File2, unzstdTo2, NAME_LEVELS2, nameLevel2, FEIS_LOCAL_ID_FLOOR2, ResultFinder2, MajorsFinder2, nameOrderOf, DancerResolver2, canonicalOf2, CompResolver2, NO_CALENDAR2, FeisFinder2, StaffFinder2, SchoolResolver2, defaultBuilders2, indexPath2, indexKey2, isCurrent2, buildIndex2, listIndexes2, readPin2, youngest2, dancerResolverOf2, RegistrationResolver2, ghRemote2, httpsRemote2, fallbackRemote2, setRemote2, resolveTag2, Release2, openRelease2, openCached2, ReleaseManager2, releases2 };