@finbheara/archive-client 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,699 @@
+#!/usr/bin/env bun
+// @bun
+import {
+  nameOrderOf,
+  openRelease2,
+  releases2
+} from "./chunks/index-zr8tfjk0.js";
+import"./chunks/index-hne1wadw.js";
+import"./chunks/index-hghdy980.js";
+
+var USAGE = `usage: idq <verb> [--cache <dir>] [--repo <owner/name>] [--json]
+
+  config repo <owner/name>          set the user-local repository the releases come from
+  list [--remote]                   the cached releases (size, files, indexes, the pin), and
+                                    with --remote the published tags
+  fetch [--release <spec>] [--assets results,majors,<file>...]
+                                    download, verify and cache a release (default: results)
+  pin <spec>                        the user-local pin: what a bare open (spec "pinned") opens
+  unpin                             remove the pin (a bare open is then "latest")
+  current                           the pin, and whether it is cached
+  add <dir> --tag <tag>             add a release built locally (its MANIFEST.json and files)
+                                    to the cache under its tag
+  index [--release <spec>] [<name>...] [--force]
+                                    build the per-tag indexes (default: every one)
+  verify [--release <spec>]         re-hash every cached file against its receipt
+  prune [--keep N] [--dry-run]      remove all but the N newest cached releases (default 1)
+                                    and the pinned one
+  rm <tag> [--dry-run]              remove one cached release (not the pinned one)
+  drop-indexes [<tag>] [--dry-run]  remove the index files (of one release, or of every one)
+  feis [--release <spec>] [--platform <p>] [--code <c>] [--id <id>] [--name <glob>] [--year <y>]
+                                    the feises a query names
+  series [--release <spec>] <name|host code|feis id>
+                                    the series a name, a host code (fweb:ABC) or any feis id
+                                    names: its years, hosts, codes and next instance
+  school [--release <spec>] <print|school_id> [--region <code>]
+                                    a school print or id to the published schools
+  dancer [--release <spec>] <name> | --surname <s> | --like <glob> | --id <dancer_id>
+         [--order surname-first|given-first] [--school <print|id>]
+         [--yob <y> | --band <U10> [--year <y>] | --comp <competition>] [--as-of <date>]
+         [--rows]                   the dancers a name reaches, each with its evidence
+                                    (name level, age, school) and the arm; the results of
+                                    the one dancer where one answers (or --rows for each)
+  results [--release <spec>] [--dancer <id>] [--feis <id>] [--comp <competition>]
+          [--school <print|id>] [--year <y>] [--limit <n>]
+                                    the published result rows, prints and ids
+  majors [--release <spec>] [--event <e>] [--year <y>] [--comp <competition>] [--dancer <id>]
+                                    the majors: every event and its years; an event's
+                                    competitions; a competition's, an event's or a dancer's rows
+  teacher [--release <spec>] <name|TD number>
+                                    the staff lists' people: where they taught, the register,
+                                    where they sat
+  adjudicator [--release <spec>] <name|TD number>
+                                    the register's and the panels' people: the same answer
+  comp [--release <spec>] <feis> <code> [--year <y>] [--title <t>]
+                                    a feis's own comp code to the comp it names, through that
+                                    feis's syllabus (or the prior year's)
+  syllabus [--release <spec>] <feis> [year]
+                                    one feis-year's comps, in printed order
+  syllabus [--release <spec>] --for <series> [year]
+                                    a series' syllabus for a year: that year's where held,
+                                    else the newest, saying which and what it is read from
+  resolve comp [<feis> <code>] [--year <y>] [--title <t>]
+  resolve dancer [<name>] [--school <s>] [--comp <feis>/<code> | --yob <y> | --band <b> --year <y>]
+                 [--order <o>] [--as-of <date>]
+  resolve registrations
+                                    JSONL out, one answer per line; with no positional the
+                                    questions are JSONL on stdin, one per line (a comp:
+                                    {feis, code, year?, title?}, a dancer: {name, school?, age?},
+                                    a registration: {name, school?, codes[], feis, year?})
+
+  <spec>: pinned (the default) | latest | a cut (42, 42.1) | a tag (archive-YYYY.MM.DD-N)`;
+var VALUE = new Set([
+  "--cache",
+  "--repo",
+  "--release",
+  "--assets",
+  "--tag",
+  "--keep",
+  "--platform",
+  "--code",
+  "--id",
+  "--name",
+  "--year",
+  "--region",
+  "--order",
+  "--surname",
+  "--like",
+  "--school",
+  "--yob",
+  "--band",
+  "--comp",
+  "--as-of",
+  "--dancer",
+  "--feis",
+  "--limit",
+  "--event",
+  "--title",
+  "--for"
+]);
+function parseArgs(argv) {
+  const positional = [];
+  const flags = new Map;
+  const bools = new Set;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1)
+        flags.set(a.slice(0, eq), a.slice(eq + 1));
+      else if (VALUE.has(a)) {
+        const v = argv[i + 1];
+        if (v === undefined)
+          throw new Error(`${a} takes a value`);
+        flags.set(a, v);
+        i++;
+      } else
+        bools.add(a);
+    } else
+      positional.push(a);
+  }
+  return { positional, flags, bools };
+}
+var mb = (n) => `${(n / 1e6).toFixed(1)} MB`;
+function printPlan(p, say) {
+  for (const k of p.keep)
+    say(`keep    ${k.tag} (${k.why})`);
+  for (const r of p.remove)
+    say(`${p.dryRun ? "would remove" : "removed"} ${r.path} ${mb(r.bytes)} (${r.why})`);
+  say(`${p.dryRun ? "would free" : "freed"} ${mb(p.bytes)}${p.dryRun ? " (dry run: nothing removed)" : ""}`);
+}
+function printCached(c, say) {
+  say(`${c.pinned ? "*" : " "} ${c.tag}  ${mb(c.bytes)}  from ${c.source}`);
+  for (const f of c.files)
+    say(`      ${f.name}  ${mb(f.bytes)}  verified: ${f.verified.length > 0 ? f.verified.join("+") : "none"}`);
+  for (const i of c.indexes)
+    say(`      index/${i.name}.sqlite  ${mb(i.bytes)}  ${i.current === null ? "no builder" : i.current ? "current" : "stale"}`);
+}
+var span = (lo, hi) => lo === null ? "-" : lo === hi ? `${lo}` : `${lo}-${hi ?? "?"}`;
+function printCandidate(c, say, pad = "  ") {
+  say(`${pad}${c.dancer_id}  ${c.display}${c.scope === "per-release" ? "  [per-release id]" : ""}  score ${c.score}  name ${c.evidence.nameLevel}  age ${c.evidence.age}  school ${c.evidence.school}`);
+  say(`${pad}    ${c.rows} rows ${span(c.year_lo, c.year_hi)}  born ${span(c.birth.lo, c.birth.hi)} (${c.birth.source})  school ${c.school === null ? "-" : `${c.school.school_id ?? "(no id)"} "${c.school.print}" ${span(c.school.year_lo, c.school.year_hi)}`}`);
+  say(`${pad}    prints ${c.prints.slice(0, 5).map((p) => `"${p.print}" (${p.rows}, ${p.level})`).join(", ")}${c.prints.length > 5 ? `, +${c.prints.length - 5} more` : ""}`);
+}
+function printDancers(a, say) {
+  say(`${a.arm}  "${a.asked.name}"  in ${a.tag}  ${a.candidates.length} candidate(s)${a.refused !== undefined ? `  (refused: ${a.refused})` : ""}`);
+  if (a.age !== undefined)
+    say(`  age asked: ${a.age.read ?? "(unread)"}${a.age.birth !== null ? ` born ${a.age.birth.from ?? "?"}-${a.age.birth.to ?? "?"}` : ""}${a.age.note !== undefined ? `  (${a.age.note})` : ""}`);
+  if (a.school !== undefined)
+    say(`  school asked: ${a.school.arm} ${a.school.ids.join(", ") || "-"}`);
+  for (const c of a.candidates)
+    printCandidate(c, say);
+  if (a.preferred !== undefined)
+    say(`  preferred (non-binding, the arm stands): ${a.preferred.dancer_id}, ${a.preferred.why}`);
+  for (const x of a.excluded.slice(0, 10)) {
+    const c = x.candidate;
+    say(`  excluded (${x.why}) ${c.dancer_id}  ${c.display}  name ${c.evidence.nameLevel}  born ${span(c.birth.lo, c.birth.hi)}  school ${c.school?.school_id ?? "-"}  ${c.rows} rows`);
+  }
+  if (a.excluded.length > 10)
+    say(`  excluded: ${a.excluded.length - 10} more (--json lists them)`);
+  if (a.unlinked.length > 0)
+    say(`  unlinked rows (no dancer id): ${a.unlinked.slice(0, 5).map((u) => `"${u.print}" (${u.rows})`).join(", ")}`);
+}
+function printResults(a, say) {
+  for (const r of a.rows)
+    say(`  ${r.year ?? "?"}  ${r.event}  ${r.competition}  ${r.title ?? "-"} [${r.age ?? "-"}]  place ${r.place_printed}${r.competitors !== null ? `/${r.competitors}` : ""}  "${r.name_printed}" ${r.dancer_id ?? "-"}${r.dancer_scope === "per-release" ? "*" : ""}  "${r.school_printed}" ${r.school_id ?? "-"}  ${r.address}`);
+  if (a.rows.some((r) => r.dancer_scope === "per-release"))
+    say("  * a feis-local dancer id: valid in this release only");
+  say(`${a.rows.length} row(s) from ${a.db} in ${a.tag}${a.truncated > 0 ? `, ${a.truncated} more past the limit` : ""}`);
+}
+function printStaff(a, say) {
+  say(`${a.arm}  ${a.role} "${a.asked}"  in ${a.tag}${a.refused !== undefined ? `  (refused: ${a.refused})` : ""}`);
+  for (const p of a.people) {
+    say(`  ${[p.clrg !== null ? `TD ${p.clrg}` : null, p.judge_id !== null ? `judge id ${p.judge_id}` : null].filter((x) => x !== null).join(", ") || "(no number)"}  by ${p.nameLevel}  ${p.names.map((n) => `"${n}"`).join(", ")}`);
+    for (const t of p.taught)
+      say(`      taught ${t.school_id} ${t.school ?? "?"}  ${t.role ?? "-"}${t.credentials.length > 0 ? ` ${t.credentials.join("/")}` : ""}  years ${t.years.join(",") || "-"}${t.former ? "  former" : ""}${t.provisional ? "  provisional" : ""}`);
+    for (const t of p.td_links)
+      say(`      TD listed at ${t.school_id} ${t.school ?? "?"} (${t.via}, ${t.captured})`);
+    if (p.register.length > 0) {
+      const last = p.register[p.register.length - 1];
+      say(`      register ${p.register.map((r) => r.year).join(",")}  cat ${last?.cat}  ${last?.region_code ?? last?.region}  "${last?.name_printed}"`);
+    }
+    for (const s of p.sat)
+      say(`      sat ${s.kind} ${s.event ?? "(no rows)"} ${s.year ?? "?"}: ${s.seats} seats, ${s.competitions} competitions`);
+  }
+}
+async function schoolIdOf(rel, school) {
+  const a = await rel.schools.resolve(school);
+  if (a.arm !== "unique")
+    throw new Error(`school "${school}" is ${a.arm} in ${a.tag}${a.candidates.length > 0 ? `: ${a.candidates.map((c) => c.school_id).join(", ")}` : ""}`);
+  return a.candidates[0].school_id;
+}
+function printComp(a, say) {
+  const where = a.from !== undefined ? ` from ${a.from.year} (${a.from.feis_ids.join(", ")})` : "";
+  const check = a.check === undefined ? "" : a.check === "unchecked" ? "  (title unchecked)" : `  (title ${a.check.agrees ? "agrees" : "differs"}: age ${a.check.age}, population ${a.check.population})`;
+  say(`${a.arm}  ${a.asked.feis} ${a.asked.code}  by ${a.source ?? "-"}${where}${a.syllabus_source !== null ? `, syllabus read from ${a.syllabus_source}` : ""}  in ${a.tag}${check}${a.why !== undefined ? `  (${a.why})` : ""}`);
+  for (const c of a.candidates)
+    say(`  ${c.competition}  ${c.kind}  ${c.level ?? "-"}  ${c.age ?? "-"}  ${c.population ?? "-"}  ${c.canonical ?? "-"}  "${c.title ?? ""}"`);
+}
+function jsonLines(text, check) {
+  const out = [];
+  for (const [i, l] of text.split(`
+`).entries()) {
+    if (l.trim() === "")
+      continue;
+    let v;
+    try {
+      v = JSON.parse(l);
+    } catch (e) {
+      out.push({ line: i + 1, error: `not JSON: ${e.message}` });
+      continue;
+    }
+    if (v === null || typeof v !== "object" || Array.isArray(v)) {
+      out.push({ line: i + 1, error: "not a JSON object" });
+      continue;
+    }
+    const why = check(v);
+    out.push(why === null ? { line: i + 1, value: v } : { line: i + 1, error: why });
+  }
+  return out;
+}
+var checkComp = (q) => typeof q.feis !== "string" || q.feis.trim() === "" ? "a comp question needs feis" : q.code === undefined || q.code === null || String(q.code).trim() === "" ? "a comp question needs code" : null;
+var checkDancer = (q) => typeof q.name !== "string" || q.name.trim() === "" ? "a dancer question needs name" : null;
+var checkRegistration = (r) => typeof r.name !== "string" || r.name.trim() === "" ? "a registration row needs name" : typeof r.feis !== "string" || r.feis.trim() === "" ? "a registration row needs feis" : !Array.isArray(r.codes) ? "a registration row needs codes[]" : null;
+async function resolveVerb(rel, what, args, p, say, stdin) {
+  const year = p.flags.has("--year") ? Number(p.flags.get("--year")) : undefined;
+  const emit = (v) => say(JSON.stringify(v));
+  let errors = 0;
+  const each = async (qs, answer) => {
+    for (const q of qs) {
+      if ("error" in q) {
+        errors++;
+        emit({ tag: rel.tag, line: q.line, error: q.error });
+      } else
+        emit(await answer(q.value));
+    }
+  };
+  switch (what) {
+    case "comp": {
+      const qs = args.length > 0 ? [
+        {
+          line: 0,
+          value: {
+            feis: args[0],
+            code: args[1] ?? "",
+            ...year !== undefined ? { year } : {},
+            ...p.flags.has("--title") ? { title: p.flags.get("--title") } : {}
+          }
+        }
+      ] : jsonLines(await stdin(), checkComp);
+      if (args.length > 0 && checkComp(qs[0].value) !== null)
+        throw new Error("resolve comp <feis> <code>");
+      let none = 0;
+      await each(qs, async (q) => {
+        const a = await rel.comps.resolve({ ...q, code: String(q.code) });
+        if (a.arm === "none")
+          none++;
+        return a;
+      });
+      return errors > 0 || args.length > 0 && none === 1 ? 1 : 0;
+    }
+    case "dancer": {
+      let qs;
+      if (args.length > 0) {
+        const comp = p.flags.get("--comp");
+        let age;
+        if (comp !== undefined)
+          age = { comp, ...year !== undefined ? { year } : {} };
+        else if (p.flags.has("--yob"))
+          age = { yob: Number(p.flags.get("--yob")) };
+        else if (p.flags.has("--band"))
+          age = { band: p.flags.get("--band"), year: year ?? null };
+        qs = [
+          {
+            line: 0,
+            value: {
+              name: args.join(" "),
+              ...nameOrderOf(p.flags.get("--order")) !== undefined ? { order: nameOrderOf(p.flags.get("--order")) } : {},
+              ...p.flags.has("--school") ? { school: p.flags.get("--school") } : {},
+              ...age !== undefined ? { age } : {},
+              ...p.flags.has("--as-of") ? { asOf: p.flags.get("--as-of") } : {}
+            }
+          }
+        ];
+      } else
+        qs = jsonLines(await stdin(), checkDancer);
+      let unavailable = 0;
+      await each(qs, async (q) => {
+        const a = await rel.registrations.dancer(q);
+        if (a.dancer.arm === "unavailable")
+          unavailable++;
+        return a;
+      });
+      return errors > 0 || unavailable > 0 ? 1 : 0;
+    }
+    case "registrations": {
+      const lines = jsonLines(await stdin(), checkRegistration);
+      const ok = lines.flatMap((l) => ("value" in l) ? [l.value] : []);
+      const answers = await rel.registrations.resolve(ok.map((r) => ({ ...r, codes: r.codes.map(String) })));
+      let k = 0;
+      await each(lines, async () => answers[k++]);
+      return errors > 0 ? 1 : 0;
+    }
+    default:
+      throw new Error("resolve comp|dancer|registrations");
+  }
+}
+async function main(argv, io = {}) {
+  const say = io.say ?? ((s) => console.log(s));
+  const log = io.log ?? ((s) => console.error(s));
+  let p;
+  try {
+    p = parseArgs(argv);
+  } catch (e) {
+    log(e.message);
+    return 2;
+  }
+  const [verb, ...rest] = p.positional;
+  const json = p.bools.has("--json");
+  const dryRun = p.bools.has("--dry-run");
+  const opts = {
+    ...io.opts,
+    log,
+    ...p.flags.has("--cache") ? { cache: p.flags.get("--cache") } : {},
+    ...p.flags.has("--repo") ? { repo: p.flags.get("--repo") } : {}
+  };
+  const spec = p.flags.get("--release") ?? "pinned";
+  const m = releases2(opts);
+  const out = (v, text) => {
+    if (json)
+      say(JSON.stringify(v, null, 2));
+    else
+      text();
+  };
+  try {
+    switch (verb) {
+      case "config": {
+        if (rest[0] !== "repo" || rest[1] === undefined) {
+          out(m.readConfig(), () => say(JSON.stringify(m.readConfig())));
+          return rest.length === 0 ? 0 : 2;
+        }
+        const c = m.config({ repo: rest[1] });
+        out(c, () => say(`repo ${c.repo}`));
+        return 0;
+      }
+      case "list": {
+        const l = await m.list({ remote: p.bools.has("--remote") });
+        out(l, () => {
+          say(`cache ${l.root}  repo ${l.repo ?? "(none)"}  pin ${l.pin?.tag ?? "(none: latest)"}`);
+          for (const c of l.cached)
+            printCached(c, say);
+          if (l.cached.length === 0)
+            say("  (nothing cached)");
+          if (l.published !== undefined)
+            say(`published: ${l.published.length} tags, newest ${l.published.slice(0, 5).join(", ")}`);
+        });
+        return 0;
+      }
+      case "fetch": {
+        const assets = (p.flags.get("--assets") ?? "results").split(",").filter((a) => a !== "");
+        const rel = await m.fetch(spec, { assets });
+        const files = rel.receipt().files;
+        out({ tag: rel.tag, dir: rel.dir, files }, () => {
+          say(`${rel.tag}  ${rel.dir}`);
+          for (const [name, f] of Object.entries(files))
+            say(`  ${name}  ${mb(f.bytes)}  sha256 ${f.sha256.slice(0, 12)}  verified: ${f.verified.join("+") || "none"}`);
+        });
+        rel.close();
+        return 0;
+      }
+      case "pin": {
+        if (rest[0] === undefined) {
+          log("pin <spec>");
+          return 2;
+        }
+        const pin = await m.pin(rest[0]);
+        out(pin, () => say(`pinned ${pin.tag} (from ${pin.source})`));
+        return 0;
+      }
+      case "unpin": {
+        const was = m.unpin();
+        out({ unpinned: was }, () => say(was ? "unpinned" : "no pin was set"));
+        return 0;
+      }
+      case "current": {
+        const c = m.current();
+        out(c, () => say(c.pin === null ? "no pin: a bare open is latest" : `pinned ${c.pin.tag}${c.cached ? "" : " (not cached)"}`));
+        return 0;
+      }
+      case "add": {
+        const tag = p.flags.get("--tag");
+        if (rest[0] === undefined || tag === undefined) {
+          log("add <dir> --tag <tag>");
+          return 2;
+        }
+        const rel = await m.add(rest[0], tag);
+        out({ tag: rel.tag, dir: rel.dir, files: rel.receipt().files }, () => say(`added ${rel.tag} at ${rel.dir}`));
+        return 0;
+      }
+      case "index": {
+        const r = await m.index(spec, rest, { force: p.bools.has("--force") });
+        out(r, () => {
+          for (const b of r.built)
+            say(`${r.tag} ${b.name}  ${b.path}`);
+        });
+        return 0;
+      }
+      case "verify": {
+        const tag = (await m.fetch(spec, { assets: [] })).tag;
+        const bad = await m.verify(tag);
+        out({ tag, bad }, () => {
+          say(bad.length === 0 ? `${tag}: every cached file matches its receipt` : `${tag}: ${bad.length} differ`);
+          for (const b of bad)
+            say(`  ${b.file}: want ${b.want}, got ${b.got}`);
+        });
+        return bad.length === 0 ? 0 : 1;
+      }
+      case "prune": {
+        const keep = p.flags.has("--keep") ? Number(p.flags.get("--keep")) : undefined;
+        const plan = m.prune({ ...keep !== undefined ? { keep } : {}, dryRun });
+        out(plan, () => printPlan(plan, say));
+        return 0;
+      }
+      case "rm": {
+        if (rest[0] === undefined) {
+          log("rm <tag>");
+          return 2;
+        }
+        const plan = m.remove(rest[0], { dryRun });
+        out(plan, () => printPlan(plan, say));
+        return 0;
+      }
+      case "drop-indexes": {
+        const plan = m.dropIndexes(rest[0], { dryRun });
+        out(plan, () => printPlan(plan, say));
+        return 0;
+      }
+      case "feis": {
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        const year = p.flags.get("--year");
+        const a = await rel.feises.find({
+          ...p.flags.has("--platform") ? { platform: p.flags.get("--platform") } : {},
+          ...p.flags.has("--code") ? { code: p.flags.get("--code") } : {},
+          ...p.flags.has("--id") ? { id: p.flags.get("--id") } : {},
+          ...p.flags.has("--name") ? { name: p.flags.get("--name") } : {},
+          ...year !== undefined ? { year: Number(year) } : {}
+        });
+        out(a, () => {
+          if (a.redirected !== undefined)
+            say(`(${a.redirected.from} is now ${a.redirected.to})`);
+          for (const f of a.feises)
+            say(`${f.feis_id}  ${f.date_lo ?? "?"}  ${f.name}  [${f.regions.join(",") || "-"}]  ${f.competitions} comps, ${f.rows} rows  series ${f.instance_id ?? "-"}`);
+          say(`${a.feises.length} feis(es) in ${a.tag}`);
+        });
+        rel.close();
+        return a.feises.length > 0 ? 0 : 1;
+      }
+      case "series": {
+        if (rest[0] === undefined) {
+          log("series <name|host code|feis id>");
+          return 2;
+        }
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        const a = await rel.feises.series(rest.join(" "));
+        out(a, () => {
+          say(`${a.arm}  "${a.asked}"  via ${a.via ?? "-"}  in ${a.tag}${a.redirected !== undefined ? `  (${a.redirected.from} -> ${a.redirected.to})` : ""}${a.why !== undefined ? `  (${a.why})` : ""}`);
+          for (const c of a.candidates) {
+            say(`  ${c.series_id}  ${c.name}  host ${c.hosts.join(",")}  codes ${c.codes.join(",")}`);
+            for (const i of c.instances)
+              say(`    ${i.year ?? "?"}  ${i.date_lo ?? "?"}  ${i.feis_ids.join(", ")}`);
+          }
+          if (a.arm === "unique")
+            say(`  next: ${a.next === null ? `unknown (${a.next_why ?? ""})` : `${a.next.feis_id ?? "?"} ${a.next.date}`}`);
+        });
+        rel.close();
+        return a.arm === "none" ? 1 : 0;
+      }
+      case "school": {
+        if (rest[0] === undefined) {
+          log("school <print|school_id> [--region <code>]");
+          return 2;
+        }
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        const region = p.flags.get("--region");
+        const a = await rel.schools.resolve(rest.join(" "), region !== undefined ? { region } : {});
+        out(a, () => {
+          say(`${a.arm}  "${a.asked}"  in ${a.tag}${a.refused !== undefined ? `  (refused: ${a.refused})` : ""}${a.redirected !== undefined ? `  (${a.redirected.from} -> ${a.redirected.to})` : ""}${a.region !== undefined ? `  (region ${a.region.asked}${a.region.narrowed ? " narrowed" : " did not narrow"})` : ""}`);
+          for (const c of a.candidates)
+            say(`  ${c.school_id}  ${c.display ?? "?"}  by ${c.by}  ${c.rows} rows  regions ${c.regions.join(",") || "-"}  prints ${c.prints.slice(0, 4).map((x) => `"${x}"`).join(", ")}`);
+        });
+        rel.close();
+        return a.arm === "none" ? 1 : 0;
+      }
+      case "dancer": {
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        try {
+          const id = p.flags.get("--id");
+          if (id !== undefined) {
+            const d = await rel.dancers.get(Number(id));
+            const rows = d === null ? null : await rel.results.query({ dancer_id: d.dancer_id });
+            out({ dancer: d, results: rows }, () => {
+              if (d === null) {
+                say(`no dancer ${id} in ${rel.tag}`);
+                return;
+              }
+              say(`${d.dancer_id}  ${d.display}${d.scope === "per-release" ? "  [per-release id]" : ""}  ${d.kind ?? "-"}  ${d.rows} rows ${span(d.year_lo, d.year_hi)}  born ${span(d.birth.lo, d.birth.hi)} (${d.birth.source}${d.birth.conflict ? ", conflict" : ""})  ${d.genders}  in ${d.tag}`);
+              say(`  prints ${d.prints.map((x) => `"${x.print}" (${x.rows}, ${span(x.year_lo, x.year_hi)})`).join(", ")}`);
+              for (const s of d.schools)
+                say(`  school ${s.school_id ?? "(no id)"} "${s.print}" ${s.rows} rows ${span(s.year_lo, s.year_hi)}`);
+              if (rows !== null)
+                printResults(rows, say);
+            });
+            return d === null ? 1 : 0;
+          }
+          const order = p.flags.get("--order");
+          const yob = p.flags.get("--yob");
+          const band = p.flags.get("--band");
+          const comp = p.flags.get("--comp");
+          const year = p.flags.get("--year");
+          const age = yob !== undefined ? { yob: Number(yob) } : band !== undefined ? { band, ...year !== undefined ? { year: Number(year) } : {} } : comp !== undefined ? { comp } : undefined;
+          const facets = {
+            ...order !== undefined ? { order } : {},
+            ...p.flags.has("--school") ? { school: p.flags.get("--school") } : {},
+            ...age !== undefined ? { age } : {},
+            ...p.flags.has("--as-of") ? { asOf: p.flags.get("--as-of") } : {},
+            ...p.flags.has("--limit") ? { limit: Number(p.flags.get("--limit")) } : {}
+          };
+          const surname = p.flags.get("--surname");
+          const like = p.flags.get("--like");
+          if (surname === undefined && like === undefined && rest.length === 0) {
+            log("dancer <name> | --surname <s> | --like <glob> | --id <dancer_id>");
+            return 2;
+          }
+          const a = await rel.dancers.search(surname !== undefined ? { ...facets, surname } : like !== undefined ? { ...facets, like } : { ...facets, name: rest.join(" ") });
+          const each = p.bools.has("--rows") ? a.candidates : a.arm === "unique" ? a.candidates : [];
+          const trajectories = [];
+          for (const c of each)
+            trajectories.push(await rel.results.query({ dancer_id: c.dancer_id }));
+          out({ ...a, results: trajectories }, () => {
+            printDancers(a, say);
+            for (const t of trajectories) {
+              say(`results of ${t.asked.dancer_id}:`);
+              printResults(t, say);
+            }
+          });
+          return a.candidates.length === 0 ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "results": {
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        try {
+          const q = {
+            ...p.flags.has("--dancer") ? { dancer_id: Number(p.flags.get("--dancer")) } : {},
+            ...p.flags.has("--feis") ? { feis: p.flags.get("--feis") } : {},
+            ...p.flags.has("--comp") ? { competition: p.flags.get("--comp") } : {},
+            ...p.flags.has("--school") ? { school_id: await schoolIdOf(rel, p.flags.get("--school")) } : {},
+            ...p.flags.has("--year") ? { year: Number(p.flags.get("--year")) } : {},
+            ...p.flags.has("--limit") ? { limit: Number(p.flags.get("--limit")) } : {}
+          };
+          const a = await rel.results.query(q);
+          out(a, () => printResults(a, say));
+          return a.rows.length === 0 ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "majors": {
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        try {
+          const event = p.flags.get("--event");
+          const year = p.flags.get("--year");
+          const comp = p.flags.get("--comp");
+          const dancer = p.flags.get("--dancer");
+          if (comp !== undefined || dancer !== undefined || event !== undefined && p.bools.has("--rows")) {
+            const a = await rel.majors.results({
+              ...comp !== undefined ? { competition: comp } : {},
+              ...dancer !== undefined ? { dancer_id: Number(dancer) } : {},
+              ...event !== undefined ? { feis: event } : {},
+              ...year !== undefined ? { year: Number(year) } : {},
+              ...p.flags.has("--limit") ? { limit: Number(p.flags.get("--limit")) } : {}
+            });
+            out(a, () => printResults(a, say));
+            return a.rows.length === 0 ? 1 : 0;
+          }
+          if (event !== undefined) {
+            const a = await rel.majors.competitions({
+              event,
+              ...year !== undefined ? { year: Number(year) } : {}
+            });
+            out(a, () => {
+              for (const c of a.competitions)
+                say(`  ${c.year ?? "?"}  ${c.competition}  ${c.comp_no ?? "-"}  ${c.title ?? "-"} [${c.age ?? "-"}] ${c.gender ?? ""}  ${c.rows} rows`);
+              say(`${a.competitions.length} competition(s) in ${a.tag}`);
+            });
+            return a.competitions.length === 0 ? 1 : 0;
+          }
+          const a = await rel.majors.events();
+          out(a, () => {
+            for (const e of a.events)
+              say(`  ${e.event}  ${e.years.length} year(s) ${span(e.years[0] ?? null, e.years[e.years.length - 1] ?? null)}  ${e.competitions} comps  ${e.rows} rows`);
+            say(`${a.events.length} event(s) in ${a.tag}`);
+          });
+          return 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "teacher":
+      case "adjudicator": {
+        if (rest.length === 0) {
+          log(`${verb} <name|TD number>`);
+          return 2;
+        }
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        try {
+          const a = verb === "teacher" ? await rel.staff.teacher(rest.join(" ")) : await rel.staff.adjudicator(rest.join(" "));
+          out(a, () => printStaff(a, say));
+          return a.arm === "none" ? 1 : 0;
+        } finally {
+          rel.close();
+        }
+      }
+      case "comp": {
+        if (rest[0] === undefined || rest[1] === undefined) {
+          log("comp <feis> <code> [--year <y>] [--title <t>]");
+          return 2;
+        }
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        const year = p.flags.get("--year");
+        const a = await rel.comps.resolve({
+          feis: rest[0],
+          code: rest[1],
+          ...year !== undefined ? { year: Number(year) } : {},
+          ...p.flags.has("--title") ? { title: p.flags.get("--title") } : {}
+        });
+        out(a, () => printComp(a, say));
+        rel.close();
+        return a.arm === "none" ? 1 : 0;
+      }
+      case "syllabus": {
+        const of = p.flags.get("--for");
+        if (of !== undefined) {
+          const y = rest[0] ?? p.flags.get("--year");
+          const rel = await openRelease2(spec, { ...opts, assets: [] });
+          const a = await rel.comps.syllabusFor(of, y !== undefined ? Number(y) : undefined);
+          out(a, () => {
+            say(`${a.arm}  ${a.asked.series}  asked ${a.asked.year ?? "-"}  read ${a.year ?? "-"} (${a.held ? "held" : "not held"})  from ${a.source ?? "-"}  series ${a.series_id ?? "-"} (years ${a.years.join(", ") || "-"})  in ${a.tag}`);
+            if (a.why !== undefined)
+              say(`  ${a.why}`);
+            if (a.note !== undefined)
+              say(`  note: ${a.note}`);
+            for (const c of a.entries)
+              say(`  ${c.code}  ${c.kind}  ${c.level ?? "-"}  ${c.age ?? "-"}  ${c.population ?? "-"}  ${c.canonical ?? "-"}  "${c.title ?? ""}"`);
+            say(`${a.entries.length} comp(s), ${a.championships} championship(s)`);
+          });
+          rel.close();
+          return a.entries.length > 0 ? 0 : 1;
+        }
+        if (rest[0] === undefined) {
+          log("syllabus <feis> [year]");
+          return 2;
+        }
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        const a = await rel.comps.syllabus(rest[0], rest[1] !== undefined ? Number(rest[1]) : undefined);
+        out(a, () => {
+          say(`${a.feis.asked}  ${a.year ?? "?"}  ${a.held ? `held: ${a.feis.feis_ids.join(", ")}` : "not held"}  series ${a.feis.brand_id ?? "-"} (years ${a.years.join(", ") || "-"})  in ${a.tag}`);
+          for (const c of a.entries)
+            say(`  ${c.code}  ${c.kind}  ${c.level ?? "-"}  ${c.age ?? "-"}  ${c.population ?? "-"}  "${c.title ?? ""}"`);
+          say(`${a.entries.length} comp(s)`);
+        });
+        rel.close();
+        return a.held ? 0 : 1;
+      }
+      case "resolve": {
+        const rel = await openRelease2(spec, { ...opts, assets: [] });
+        try {
+          return await resolveVerb(rel, rest[0], rest.slice(1), p, say, io.stdin ?? (() => Bun.stdin.text()));
+        } finally {
+          rel.close();
+        }
+      }
+      default:
+        say(USAGE);
+        return verb === undefined || verb === "help" ? 0 : 2;
+    }
+  } catch (e) {
+    log(`idq ${verb}: ${e.message}`);
+    return 1;
+  }
+}
+if (import.meta.main)
+  process.exit(await main(process.argv.slice(2)));
+export {
+  USAGE,
+  jsonLines,
+  main,
+  parseArgs
+};