@finbheara/archive-client 0.39.0 → 0.42.0

package/dist/chunks/{index-hdr8qvwf.js → index-0xdcttqf.js}

@@ -51,7 +51,7 @@ function planAsset2(name, manifest) {
 
 import { createHash } from "crypto";
 import { createReadStream, createWriteStream } from "fs";
-import { Transform } from "stream";
+import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 import { createZstdDecompress } from "zlib";
 async function sha256File2(path) {
@@ -79,6 +79,55 @@ function sha256OfDigest(digest) {
   const m = /^sha256:([0-9a-f]{64})$/i.exec(digest.trim());
   return m === null ? null : m[1].toLowerCase();
 }
+async function streamTo2(source, dest, o) {
+  const rawHash = createHash("sha256");
+  const outHash = o.decompress ? createHash("sha256") : rawHash;
+  let received = 0;
+  let written = 0;
+  const keep = o.raw === undefined ? null : createWriteStream(o.raw);
+  const tell = () => o.onBytes?.(received, o.decompress ? written : received);
+  const inTap = new Transform({
+    transform(chunk, _enc, cb) {
+      rawHash.update(chunk);
+      received += chunk.length;
+      if (!o.decompress)
+        tell();
+      if (keep !== null && !keep.write(chunk))
+        keep.once("drain", () => cb(null, chunk));
+      else
+        cb(null, chunk);
+    }
+  });
+  const outTap = new Transform({
+    transform(chunk, _enc, cb) {
+      outHash.update(chunk);
+      written += chunk.length;
+      tell();
+      cb(null, chunk);
+    }
+  });
+  const chain = [
+    Readable.from(source),
+    inTap,
+    ...o.decompress ? [createZstdDecompress(), outTap] : [],
+    createWriteStream(dest)
+  ];
+  try {
+    await pipeline(chain, o.signal !== undefined ? { signal: o.signal } : {});
+  } catch (e) {
+    keep?.destroy();
+    throw e;
+  }
+  if (keep !== null)
+    await new Promise((res, rej) => keep.end((e) => e ? rej(e) : res()));
+  const rawSha256 = rawHash.digest("hex");
+  return {
+    rawSha256,
+    rawBytes: received,
+    sha256: o.decompress ? outHash.digest("hex") : rawSha256,
+    bytes: o.decompress ? written : received
+  };
+}
 
 import { Age, DANCE_UP_YEARS, birthYearsMeet } from "@finbheara/domain/age";
 import { createIndex as createIndex2, indexSchema as indexSchema2, personEncoder } from "@finbheara/domain/noun-index";
@@ -491,6 +540,30 @@ var FEATURES2 = [
     since: 270,
     calls: "the same competition fields on a row of results.stream and results.entries (scope majors): absent, never refused, on a release without them"
   },
+  {
+    feature: "results.stream.competitors_printed",
+    needs: ["results:competitions.competitors_printed"],
+    since: 345,
+    calls: "the `competitors_printed` a row of results.stream and results.entries carries (the competed count the page printed): absent, never refused, on a release without it"
+  },
+  {
+    feature: "majors.stream.competitors_printed",
+    needs: ["majors:competitions.competitors_printed"],
+    since: 345,
+    calls: "the same on a row of results.stream and results.entries (scope majors)"
+  },
+  {
+    feature: "results.attach_basis",
+    needs: ["results:results.attach_basis"],
+    since: 345,
+    calls: "the `attach_basis` a row of results.query, results.stream and results.entries carries (how its dancer_id was answered, or why not): absent, never refused, on a release without it"
+  },
+  {
+    feature: "majors.attach_basis",
+    needs: ["majors:results.attach_basis"],
+    since: 345,
+    calls: "the same on a row of majors.results, and of results.stream and results.entries (scope majors)"
+  },
   {
     feature: "majors.tabs",
     needs: ["majors:tabs.address", "majors:tabs.true_round"],
@@ -1402,7 +1475,7 @@ function streamSql(q, shape = {}) {
   if (q.primary === true)
     where.push("(r.primary_source IS NULL OR r.primary_source = '')");
   return {
-    sql: `SELECT ${COLUMNS}${shape.competition === true ? COMPETITION_COLUMNS : ""} FROM results r JOIN competitions c ON c.file = r.file AND c.line = r.competition_line${where.length === 0 ? "" : ` WHERE ${where.join(" AND ")}`} ORDER BY r.file, r.line`,
+    sql: `SELECT ${COLUMNS}${shape.competition === true ? COMPETITION_COLUMNS : ""}${shape.competitorsPrinted === true ? ", c.competitors_printed AS competitors_printed" : ""}${shape.attachBasis === true ? ", r.attach_basis AS attach_basis" : ""} FROM results r JOIN competitions c ON c.file = r.file AND c.line = r.competition_line${where.length === 0 ? "" : ` WHERE ${where.join(" AND ")}`} ORDER BY r.file, r.line`,
     args
   };
 }
@@ -1483,7 +1556,7 @@ var COLUMNS2 = `r.address AS address, r.competition AS competition, c.event AS e
 	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) {
+function queryResults(rel, db, q, basis = false) {
   const where = [];
   const args = [];
   if (q.dancer_id !== undefined) {
@@ -1509,7 +1582,7 @@ function queryResults(rel, db, q) {
     args.push(q.year);
   }
   const asked = q.limit ?? 500;
-  const all = rel.db(db).query(`SELECT ${COLUMNS2} FROM results r JOIN competitions c ON c.file = r.file AND c.line = r.competition_line
+  const all = rel.db(db).query(`SELECT ${COLUMNS2}${basis ? ", r.attach_basis AS attach_basis" : ""} 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 {
@@ -1532,7 +1605,8 @@ class ResultFinder2 {
   async query(q) {
     await this.rel.fetch("results");
     await this.rel.require("results.level");
-    return queryResults(this.rel, "results", q);
+    const basis = (await this.rel.capability("results.attach_basis")).state === "full";
+    return queryResults(this.rel, "results", q, basis);
   }
   async dancerLevel(q) {
     await this.rel.fetch("results");
@@ -1544,7 +1618,9 @@ class ResultFinder2 {
     await this.rel.fetch(db);
     await this.rel.require(db === "majors" ? "majors.stream" : "results.stream");
     const competition = (await this.rel.capability(`${db}.stream.competition`)).state === "full";
-    return { db: this.rel.db(db), shape: { competition } };
+    const competitorsPrinted = (await this.rel.capability(`${db}.stream.competitors_printed`)).state === "full";
+    const attachBasis = (await this.rel.capability(`${db}.attach_basis`)).state === "full";
+    return { db: this.rel.db(db), shape: { competition, competitorsPrinted, attachBasis } };
   }
   async* stream(q) {
     const { db, shape } = await this.streamDb(q);
@@ -1608,7 +1684,8 @@ class MajorsFinder2 {
   async results(q) {
     await this.db();
     await this.rel.require("results.level");
-    return queryResults(this.rel, "majors", q);
+    const basis = (await this.rel.capability("majors.attach_basis")).state === "full";
+    return queryResults(this.rel, "majors", q, basis);
   }
 }
 
@@ -3293,8 +3370,8 @@ class CompResolver2 {
 
 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 { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, renameSync, rmSync as rmSync2, statSync } from "fs";
+import { join as join2 } from "path";
 
 import {
   createIndex as createIndex3,
@@ -3534,6 +3611,34 @@ class StaffFinder2 {
   }
 }
 
+import { existsSync, readdirSync, rmSync } from "fs";
+import { join } from "path";
+function pidAlive(pid) {
+  if (pid === process.pid)
+    return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+var PART_FILE = /^\..+\.(\d+)-[0-9a-f]{8}\.part(?:\.zst|\.dl)?$/;
+var BUILDING_FILE = /^.+\.sqlite\.building\.(\d+)$/;
+function sweepDead(dir, re) {
+  if (!existsSync(dir))
+    return [];
+  const gone = [];
+  for (const f of readdirSync(dir)) {
+    const m = re.exec(f);
+    if (m === null || pidAlive(Number(m[1])))
+      continue;
+    rmSync(join(dir, f), { force: true });
+    gone.push(f);
+  }
+  return gone.sort();
+}
+
 import { parquetMetadata, parquetReadObjects, parquetSchema } from "hyparquet";
 var COMPRESSORS = {
   ZSTD: (input) => new Uint8Array(Bun.zstdDecompressSync(input))
@@ -3780,8 +3885,8 @@ class EventFinder2 {
 function defaultBuilders2() {
   return [schoolsIndex, feisesIndex, compsIndex, dancersIndex, staffIndex, teamsIndex, eventsIndex];
 }
-var indexDir = (rel) => join(rel.dir, "index");
-var indexPath2 = (rel, name) => join(indexDir(rel), `${name}.sqlite`);
+var indexDir = (rel) => join2(rel.dir, "index");
+var indexPath2 = (rel, name) => join2(indexDir(rel), `${name}.sqlite`);
 function indexKey2(rel, b) {
   const files = rel.receipt().files;
   const parts = [b.name, b.version, ...b.keyParts?.(rel) ?? []];
@@ -3792,7 +3897,7 @@ function indexKey2(rel, b) {
   return createHash2("sha256").update(parts.join("\x00")).digest("hex");
 }
 function keyOf(path) {
-  if (!existsSync(path))
+  if (!existsSync2(path))
     return null;
   try {
     const db = new Database(path, { readonly: true });
@@ -3817,8 +3922,9 @@ function buildIndex2(rel, b, o) {
   if (b.load !== undefined && o.loaded === undefined)
     throw new Error(`archive-client: index "${b.name}" reads its inputs first: build it with ensureIndex (or rel.index)`);
   mkdirSync(indexDir(rel), { recursive: true });
+  sweepDead(indexDir(rel), BUILDING_FILE);
   const tmp = `${out}.building.${process.pid}`;
-  rmSync(tmp, { force: true });
+  rmSync2(tmp, { force: true });
   const t0 = performance.now();
   const db = new Database(tmp, { create: true });
   try {
@@ -3834,7 +3940,7 @@ function buildIndex2(rel, b, o) {
     db.run("VACUUM");
   } catch (e) {
     db.close();
-    rmSync(tmp, { force: true });
+    rmSync2(tmp, { force: true });
     throw e;
   }
   db.close();
@@ -3845,16 +3951,42 @@ function buildIndex2(rel, b, o) {
 async function ensureIndex2(rel, b, o) {
   if (!o.force && isCurrent2(rel, b))
     return indexPath2(rel, b.name);
-  const loaded = b.load === undefined ? undefined : await b.load(rel);
-  return buildIndex2(rel, b, { ...o, loaded });
+  const t0 = performance.now();
+  const tell = (state, error) => o.progress?.({
+    tag: rel.tag,
+    kind: "index",
+    item: b.name,
+    state,
+    bytes: 0,
+    total: null,
+    unpacked: 0,
+    ms: performance.now() - t0,
+    ...error !== undefined ? { error } : {}
+  });
+  tell("indexing");
+  try {
+    const loaded = b.load === undefined ? undefined : await b.load(rel);
+    if (o.progress !== undefined)
+      await new Promise((r) => setTimeout(r, 0));
+    const path = buildIndex2(rel, b, {
+      force: o.force,
+      loaded,
+      ...o.progress === undefined && o.log !== undefined ? { log: o.log } : {}
+    });
+    tell("done");
+    return path;
+  } catch (e) {
+    tell("failed", e.message);
+    throw e;
+  }
 }
 function listIndexes2(rel) {
   const dir = indexDir(rel);
-  if (!existsSync(dir))
+  if (!existsSync2(dir))
     return [];
-  return readdirSync(dir).filter((f) => f.endsWith(".sqlite")).sort().map((f) => {
+  return readdirSync2(dir).filter((f) => f.endsWith(".sqlite")).sort().map((f) => {
     const name = f.slice(0, -".sqlite".length);
-    const path = join(dir, f);
+    const path = join2(dir, f);
     const b = rel.builders().find((x) => x.name === name);
     return {
       name,
@@ -3868,35 +4000,35 @@ function listIndexes2(rel) {
 import { createHash as createHash3 } from "crypto";
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   linkSync as linkSync2,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync5,
   readdirSync as readdirSync4,
   renameSync as renameSync3,
-  rmSync as rmSync5,
+  rmSync as rmSync6,
   statSync as statSync4
 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 import {
   copyFileSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   linkSync,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync4,
   readdirSync as readdirSync3,
-  rmSync as rmSync4,
+  rmSync as rmSync5,
   statSync as statSync3
 } from "fs";
-import { isAbsolute, join as join4, relative, resolve, sep } from "path";
+import { isAbsolute, join as join5, 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");
+import { existsSync as existsSync3, readFileSync as readFileSync2, rmSync as rmSync3 } from "fs";
+import { join as join3 } from "path";
+var pinPath = (root) => join3(root, "PINNED.json");
 function readPin2(root) {
   const p = pinPath(root);
-  if (!existsSync2(p))
+  if (!existsSync3(p))
     return null;
   try {
     const v = JSON.parse(readFileSync2(p, "utf8"));
@@ -3912,23 +4044,24 @@ function writePin(root, pin) {
 }
 function clearPin(root) {
   const p = pinPath(root);
-  if (!existsSync2(p))
+  if (!existsSync3(p))
     return false;
-  rmSync2(p);
+  rmSync3(p);
   return true;
 }
 
 import { Database as Database2 } from "bun:sqlite";
+import { randomBytes } from "crypto";
 import {
-  existsSync as existsSync4,
+  createReadStream as createReadStream2,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync3,
-  readdirSync as readdirSync2,
   renameSync as renameSync2,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   statSync as statSync2
 } from "fs";
-import { join as join3 } from "path";
+import { basename, dirname as dirname2, join as join4 } from "path";
 
 var CALENDAR_STAGES2 = [
   "announced",
@@ -4264,9 +4397,9 @@ class RegistrationResolver2 {
 }
 
 import { spawn } from "child_process";
-import { createWriteStream as createWriteStream2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import { createWriteStream as createWriteStream2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
-import { Readable } from "stream";
+import { Readable as Readable2 } from "stream";
 import { pipeline as pipeline2 } from "stream/promises";
 function run(cmd, args) {
   return new Promise((resolve) => {
@@ -4332,8 +4465,59 @@ var ghRemote2 = {
       dest,
       "--clobber"
     ]);
-    if (r.status !== 0 || !existsSync3(dest))
+    if (r.status !== 0 || !existsSync4(dest))
       throw new Error(`gh release download ${tag} -p ${name}: ${firstLine(r.stderr)}`);
+  },
+  async bytes(repo, tag, name, signal) {
+    const what = `gh release download ${tag} -p ${name}`;
+    let child;
+    try {
+      child = spawn("gh", ["release", "download", tag, "-R", repo, "-p", name, "-O", "-"], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (e) {
+      throw new Error(`${what}: ${e.message}`);
+    }
+    let stderr = "";
+    child.stderr?.on("data", (d) => {
+      stderr += String(d);
+    });
+    const closed = new Promise((resolve) => {
+      child.on("error", (e) => {
+        stderr += e.message;
+        resolve(null);
+      });
+      child.on("close", (status) => resolve(status));
+    });
+    const kill = () => {
+      child.kill("SIGTERM");
+    };
+    signal?.addEventListener("abort", kill, { once: true });
+    const out = child.stdout;
+    if (out === null || out === undefined)
+      throw new Error(`${what}: no stdout`);
+    const it = out[Symbol.asyncIterator]();
+    const failed = async () => {
+      const status = await closed;
+      signal?.removeEventListener("abort", kill);
+      if (status !== 0)
+        throw new Error(`${what}: ${firstLine(stderr) || `exit ${status}`}`);
+    };
+    const head = await it.next();
+    if (head.done === true) {
+      await failed();
+      return async function* () {}();
+    }
+    return async function* () {
+      yield head.value;
+      for (;; ) {
+        const n = await it.next();
+        if (n.done === true)
+          break;
+        yield n.value;
+      }
+      await failed();
+    }();
   }
 };
 var API = "https://api.github.com";
@@ -4386,7 +4570,19 @@ function httpsRemote2(env = process.env, fetchImpl = fetch) {
       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));
+      await pipeline2(Readable2.fromWeb(nodeWebStream(res.body)), createWriteStream2(dest));
+    },
+    async bytes(repo, tag, name, signal) {
+      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"),
+        ...signal !== undefined ? { signal } : {}
+      });
+      if (!res.ok || res.body === null)
+        throw new Error(`GET ${a.url}: ${res.status} ${res.statusText}`);
+      return Readable2.fromWeb(nodeWebStream(res.body));
     }
   };
 }
@@ -4406,7 +4602,10 @@ function fallbackRemote2(first, second) {
     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))
+    download: both((r) => r.download.bind(r)),
+    ...first.bytes !== undefined && second.bytes !== undefined ? {
+      bytes: both((r) => r.bytes.bind(r))
+    } : {}
   };
 }
 var installed = null;
@@ -4645,12 +4844,12 @@ class UpcomingFinder2 {
 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);
+  return join4(root, tag);
 }
-var receiptPath = (dir) => join3(dir, ".client.json");
+var receiptPath = (dir) => join4(dir, ".client.json");
 function readReceipt(dir) {
   const p = receiptPath(dir);
-  if (!existsSync4(p))
+  if (!existsSync5(p))
     return null;
   try {
     return JSON.parse(readFileSync3(p, "utf8"));
@@ -4667,7 +4866,7 @@ async function resolveTag2(spec, opts = {}) {
     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")))
+  if (s.kind === "tag" && existsSync5(join4(tagDir(root, s.tag), "MANIFEST.json")))
     return s.tag;
   const repo = requireRepo2(opts);
   const tags = await (opts.remote ?? defaultRemote()).tags(repo);
@@ -4676,9 +4875,30 @@ async function resolveTag2(spec, opts = {}) {
     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 });
+var DEFAULT_CONCURRENCY2 = 4;
+function partPath(dest) {
+  return join4(dirname2(dest), `.${basename(dest)}.${process.pid}-${randomBytes(4).toString("hex")}.part`);
+}
+
+class Slots {
+  n;
+  running = 0;
+  waiting = [];
+  constructor(n) {
+    this.n = n;
+  }
+  async run(job, signal) {
+    if (this.running >= this.n)
+      await new Promise((r) => this.waiting.push(r));
+    this.running++;
+    try {
+      signal.throwIfAborted();
+      return await job();
+    } finally {
+      this.running--;
+      this.waiting.shift()?.();
+    }
+  }
 }
 
 class Release2 {
@@ -4705,7 +4925,7 @@ class Release2 {
   feisPanels;
   opts;
   handles = new Map;
-  remoteAssets = null;
+  listing = null;
   constructor(tag, root, manifest, opts) {
     const t = parseArchiveTag2(tag);
     this.tag = tag;
@@ -4738,19 +4958,65 @@ class Release2 {
     return planAsset2(asset, this.manifest);
   }
   has(asset) {
-    return existsSync4(join3(this.dir, this.plan(asset).local));
+    return existsSync5(join4(this.dir, this.plan(asset).local));
   }
   path(asset) {
-    const p = join3(this.dir, this.plan(asset).local);
-    if (!existsSync4(p))
+    const p = join4(this.dir, this.plan(asset).local);
+    if (!existsSync5(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;
+    return this.fetching(assets).all;
+  }
+  inflight = new Map;
+  slots = null;
+  swept = false;
+  fetching(assets) {
+    this.slots ??= new Slots(Math.max(1, this.opts.concurrency ?? DEFAULT_CONCURRENCY2));
+    const slots = this.slots;
+    const ac = new AbortController;
+    const mine = new Map;
+    let first = null;
+    for (const a of assets) {
+      if (mine.has(a))
+        continue;
+      const local = this.plan(a).local;
+      let p = this.inflight.get(local);
+      if (p === undefined) {
+        p = slots.run(() => this.fetchOne(a, ac.signal), ac.signal);
+        this.inflight.set(local, p);
+        const started = p;
+        started.then(() => this.inflight.delete(local), () => this.inflight.delete(local));
+      }
+      p.catch((e) => {
+        first ??= { e };
+        ac.abort();
+      });
+      mine.set(a, p);
+    }
+    const all = (async () => {
+      const settled = await Promise.allSettled([...mine.values()]);
+      if (first !== null)
+        throw first.e;
+      return assets.map((a) => {
+        const s = settled[[...mine.keys()].indexOf(a)];
+        return s.value;
+      });
+    })();
+    return {
+      each: (asset) => {
+        const p = mine.get(asset);
+        if (p === undefined)
+          throw new Error(`archive-client: ${asset} was not asked of this fetch`);
+        return p;
+      },
+      all,
+      cancel: () => {
+        first ??= { e: new Error("archive-client: the fetch was cancelled") };
+        ac.abort();
+      }
+    };
   }
   async publishes(asset) {
     const plan = this.plan(asset);
@@ -4806,25 +5072,29 @@ class Release2 {
     if (c.state === "missing")
       throw needsRelease2(this.tag, c);
   }
-  async listed() {
-    if (this.remoteAssets === null) {
-      this.remoteAssets = await (this.opts.remote ?? defaultRemote()).assets(requireRepo2(this.opts), this.tag);
-      if (existsSync4(this.dir)) {
+  listed() {
+    this.listing ??= (async () => {
+      const assets = await (this.opts.remote ?? defaultRemote()).assets(requireRepo2(this.opts), this.tag);
+      if (existsSync5(this.dir)) {
         const r = this.receipt();
-        r.published = this.remoteAssets.map((a) => a.name).sort();
+        r.published = assets.map((a) => a.name).sort();
         writeJsonAtomic2(receiptPath(this.dir), r);
       }
-    }
-    return this.remoteAssets;
+      return assets;
+    })();
+    this.listing.catch(() => {
+      this.listing = null;
+    });
+    return this.listing;
   }
-  async fetchOne(asset) {
+  async fetchOne(asset, signal) {
     const plan = this.plan(asset);
-    const dest = join3(this.dir, plan.local);
+    const dest = join4(this.dir, plan.local);
     const have = this.receipt().files[plan.local];
-    if (existsSync4(dest) && have !== undefined)
+    if (existsSync5(dest) && have !== undefined)
       return have;
     const log = this.opts.log ?? (() => {});
-    if (existsSync4(dest) && plan.contentSha256 !== null) {
+    if (existsSync5(dest) && plan.contentSha256 !== null) {
       const sha = await sha256File2(dest);
       if (sha === plan.contentSha256) {
         const adopted = {
@@ -4833,7 +5103,8 @@ class Release2 {
           bytes: statSync2(dest).size,
           verified: ["manifest"]
         };
-        log(`adopt ${this.tag} ${plan.local} (the manifest's sha256)`);
+        if (this.opts.progress === undefined)
+          log(`adopt ${this.tag} ${plan.local} (the manifest's sha256)`);
         this.record(plan.local, adopted);
         return adopted;
       }
@@ -4842,14 +5113,24 @@ class Release2 {
     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);
+    mkdirSync3(this.dir, { recursive: true });
+    if (!this.swept) {
+      sweepDead(this.dir, PART_FILE);
+      this.swept = true;
+    }
+    const landed = await fetchAsset({
+      remote: this.opts.remote ?? defaultRemote(),
+      repo: requireRepo2(this.opts),
+      tag: this.tag,
+      pub,
+      plan,
+      dest,
+      opts: this.opts,
+      log,
+      ...this.opts.progress !== undefined ? { progress: this.opts.progress } : {},
+      ...signal !== undefined ? { signal } : {}
+    });
     this.record(plan.local, landed);
-    dropIfEmpty(part);
     return landed;
   }
   record(local, f) {
@@ -4878,7 +5159,11 @@ class Release2 {
     if (FEATURES2.some((f) => f.feature === b.name))
       await this.require(b.name);
     await this.fetch(...b.inputs);
-    return ensureIndex2(this, b, { force: o.force ?? false, log: this.opts.log });
+    return ensureIndex2(this, b, {
+      force: o.force ?? false,
+      log: this.opts.log,
+      ...this.opts.progress !== undefined ? { progress: this.opts.progress } : {}
+    });
   }
   async indexDb(name) {
     const key = `index:${name}`;
@@ -4898,69 +5183,172 @@ class Release2 {
     this.close();
   }
 }
-async function land(raw, pub, plan, dest, opts, log) {
+function verifyLanded(got, pub, plan, strict) {
   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})`);
-    }
+    if (got.rawSha256 !== host)
+      throw new Error(`archive-client: ${pub.name} does not match the host's digest (sha256 ${got.rawSha256}, 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})`);
-    }
+    if (got.sha256 !== plan.contentSha256)
+      throw new Error(`archive-client: ${plan.local} does not match MANIFEST.json (sha256 ${got.sha256}, the manifest says ${plan.contentSha256})`);
     verified.push("manifest");
   }
-  if (verified.length === 0 && opts.strict === true) {
-    rmSync3(landedAt, { force: true });
+  if (verified.length === 0 && strict)
     throw new Error(`archive-client: nothing verifies ${pub.name} (no host digest, no manifest hash) and strict is set`);
+  return verified;
+}
+async function fetchAsset(j) {
+  const t0 = performance.now();
+  const { pub, plan, tag } = j;
+  const decompress = plan.decompress && pub.name.endsWith(".zst");
+  const tmp = partPath(j.dest);
+  const raw = decompress && j.opts.keepCompressed === true ? `${tmp}.zst` : undefined;
+  let dl = null;
+  let bytes = 0;
+  let unpacked = 0;
+  let state = "downloading";
+  const total = Number.isFinite(pub.size) ? pub.size : null;
+  const tell = (s, error) => j.progress?.({
+    tag,
+    kind: "asset",
+    item: pub.name,
+    state: s,
+    bytes,
+    total,
+    unpacked,
+    ms: performance.now() - t0,
+    ...error !== undefined ? { error } : {}
+  });
+  const onBytes = (received, written) => {
+    if (state === "downloading")
+      bytes = received;
+    unpacked = decompress ? written : 0;
+    tell(state);
+  };
+  if (j.progress === undefined)
+    j.log(`fetch ${tag} ${pub.name} (${pub.size} bytes)`);
+  tell("downloading");
+  try {
+    let got;
+    if (j.remote.bytes !== undefined) {
+      const body = await j.remote.bytes(j.repo, tag, pub.name, j.signal);
+      if (decompress && j.progress === undefined)
+        j.log(`decompress ${pub.name}`);
+      got = await streamTo2(body, tmp, {
+        decompress,
+        ...raw !== undefined ? { raw } : {},
+        onBytes,
+        ...j.signal !== undefined ? { signal: j.signal } : {}
+      });
+    } else {
+      dl = `${tmp}.dl`;
+      await j.remote.download(j.repo, tag, pub.name, dl);
+      j.signal?.throwIfAborted();
+      bytes = statSync2(dl).size;
+      if (decompress) {
+        if (j.progress === undefined)
+          j.log(`decompress ${pub.name}`);
+        state = "unpacking";
+        tell(state);
+        got = await streamTo2(createReadStream2(dl), tmp, {
+          decompress,
+          onBytes,
+          ...j.signal !== undefined ? { signal: j.signal } : {}
+        });
+        if (raw !== undefined)
+          renameSync2(dl, raw);
+        else
+          rmSync4(dl, { force: true });
+      } else {
+        state = "verifying";
+        tell(state);
+        const sha = await sha256File2(dl);
+        got = { rawSha256: sha, rawBytes: bytes, sha256: sha, bytes };
+        renameSync2(dl, tmp);
+      }
+      dl = null;
+    }
+    state = "verifying";
+    tell(state);
+    const verified = verifyLanded(got, pub, plan, j.opts.strict === true);
+    renameSync2(tmp, j.dest);
+    if (raw !== undefined)
+      renameSync2(raw, `${j.dest}.zst`);
+    tell("done");
+    return { from: pub.name, sha256: got.sha256, bytes: got.bytes, verified };
+  } catch (e) {
+    for (const f of [tmp, raw, dl])
+      if (f !== undefined && f !== null)
+        rmSync4(f, { force: true });
+    const cancelled = j.signal?.aborted === true;
+    tell(cancelled ? "cancelled" : "failed", cancelled ? undefined : e.message);
+    throw e;
+  }
+}
+async function land(raw, pub, plan, dest, opts, log) {
+  const decompress = plan.decompress && pub.name.endsWith(".zst");
+  let got;
+  let landedAt = raw;
+  if (decompress) {
+    landedAt = partPath(dest);
+    log(`decompress ${pub.name}`);
+    got = await streamTo2(createReadStream2(raw), landedAt, { decompress: true });
+  } else {
+    const sha = await sha256File2(raw);
+    const n = statSync2(raw).size;
+    got = { rawSha256: sha, rawBytes: n, sha256: sha, bytes: n };
+  }
+  let verified;
+  try {
+    verified = verifyLanded(got, pub, plan, opts.strict === true);
+  } catch (e) {
+    rmSync4(landedAt, { force: true });
+    if (landedAt !== raw)
+      rmSync4(raw, { force: true });
+    throw e;
   }
   renameSync2(landedAt, dest);
   if (landedAt !== raw) {
     if (opts.keepCompressed === true)
       renameSync2(raw, `${dest}.zst`);
     else
-      rmSync3(raw, { force: true });
+      rmSync4(raw, { force: true });
   }
-  return { from: pub.name, sha256: sha, bytes: statSync2(dest).size, verified };
+  return { from: pub.name, sha256: got.sha256, 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 manifestPath = join4(dir, "MANIFEST.json");
+  if (!existsSync5(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, () => {});
+    mkdirSync3(dir, { recursive: true });
+    const landed = await fetchAsset({
+      remote,
+      repo,
+      tag,
+      pub,
+      plan: planAsset2("MANIFEST.json", null),
+      dest: manifestPath,
+      opts,
+      log: () => {},
+      ...opts.progress !== undefined ? { progress: opts.progress } : {}
+    });
     writeJsonAtomic2(receiptPath(dir), {
       tag,
       source: repo,
       files: { "MANIFEST.json": landed },
       published: listed.map((a) => a.name).sort()
     });
-    dropIfEmpty(part);
   }
   const manifest = JSON.parse(readFileSync3(manifestPath, "utf8"));
   const rel = new Release2(tag, root, manifest, opts);
@@ -4969,8 +5357,8 @@ async function openRelease2(spec = "pinned", opts = {}) {
 }
 function openCached2(tag, opts = {}) {
   const root = cacheRoot2(opts);
-  const p = join3(tagDir(root, tag), "MANIFEST.json");
-  if (!existsSync4(p))
+  const p = join4(tagDir(root, tag), "MANIFEST.json");
+  if (!existsSync5(p))
     return null;
   return new Release2(tag, root, JSON.parse(readFileSync3(p, "utf8")), opts);
 }
@@ -4982,14 +5370,14 @@ function checkKeep(keep) {
   return keep;
 }
 function duBytes(p) {
-  if (!existsSync5(p))
+  if (!existsSync6(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));
+    n += duBytes(join5(p, e));
   return n;
 }
 
@@ -5001,9 +5389,9 @@ class ReleaseManager2 {
     this.root = cacheRoot2(opts);
   }
   cachedTags() {
-    if (!existsSync5(this.root))
+    if (!existsSync6(this.root))
       return [];
-    return readdirSync3(this.root).filter((t) => parseArchiveTag2(t) !== null && existsSync5(join4(this.root, t, "MANIFEST.json"))).sort(compareTagsNewestFirst2);
+    return readdirSync3(this.root).filter((t) => parseArchiveTag2(t) !== null && existsSync6(join5(this.root, t, "MANIFEST.json"))).sort(compareTagsNewestFirst2);
   }
   cached(tag) {
     const r = openCached2(tag, this.opts);
@@ -5043,10 +5431,14 @@ class ReleaseManager2 {
   async use(spec, o = {}) {
     const keep = o.prune === false ? null : this.keepCount(o.keep);
     const was = readPin2(this.root)?.tag ?? null;
-    const rel = await this.fetch(spec, o);
+    const rel = await openRelease2(spec, { ...this.opts, assets: [] });
     const tag = rel.tag;
-    rel.close();
-    const { built } = await this.index(tag);
+    let built;
+    try {
+      built = await this.buildAsLanded(rel, [], o.assets ?? ["results"], false);
+    } finally {
+      rel.close();
+    }
     const pin = await this.pin(tag);
     if (keep === null)
       return { tag, was, pin, built, pruned: null };
@@ -5080,22 +5472,22 @@ class ReleaseManager2 {
   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))
+    const mf = join5(dir, "MANIFEST.json");
+    if (!existsSync6(mf))
       throw new Error(`add: ${dir} holds no MANIFEST.json`);
     const dest = tagDir(this.root, tag);
-    if (existsSync5(join4(dest, "MANIFEST.json")))
+    if (existsSync6(join5(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");
+    const part = join5(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);
+      const src = join5(dir, name);
       if (!statSync3(src).isFile())
         continue;
-      const raw = join4(part, name);
+      const raw = join5(part, name);
       try {
         linkSync(src, raw);
       } catch {
@@ -5105,10 +5497,10 @@ class ReleaseManager2 {
       const side = Object.entries(manifest.sideFiles ?? {}).find(([k, f]) => (f.file ?? `${k}.zst`) === name)?.[0];
       const asked = base !== name && isDatabase(base) ? base : side ?? name;
       const plan = planAsset2(asked, manifest);
-      const landed = await land(raw, { name, digest: null }, plan, join4(dest, plan.local), this.opts, log);
+      const landed = await land(raw, { name, digest: null }, plan, join5(dest, plan.local), this.opts, log);
       receipt.files[plan.local] = landed;
     }
-    rmSync4(part, { recursive: true, force: true });
+    rmSync5(part, { recursive: true, force: true });
     writeJsonAtomic2(receiptPath(dest), receipt);
     const rel = openCached2(tag, this.opts);
     if (rel === null)
@@ -5117,20 +5509,51 @@ class ReleaseManager2 {
   }
   async index(spec, names = [], o = {}) {
     const rel = await openRelease2(spec, { ...this.opts, assets: [] });
+    try {
+      return { tag: rel.tag, built: await this.buildAsLanded(rel, names, [], o.force ?? false) };
+    } finally {
+      rel.close();
+    }
+  }
+  async buildAsLanded(rel, names, extra, force) {
     const want = names.length > 0 ? names : rel.builders().map((b) => b.name);
-    const built = [];
-    for (const name of want) {
+    const builders = want.map((name) => {
       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: await ensureIndex2(rel, b, { force: o.force ?? false, log: this.opts.log })
-      });
+      return b;
+    });
+    const assets = [...new Set([...extra, ...builders.flatMap((b) => b.inputs)])];
+    const f = rel.fetching(assets);
+    f.all.catch(() => {});
+    const waiting = new Map(builders.map((b) => [b.name, Promise.all(b.inputs.map((a) => f.each(a))).then(() => b.name)]));
+    for (const p of waiting.values())
+      p.catch(() => {});
+    const paths = new Map;
+    while (waiting.size > 0) {
+      let name;
+      try {
+        name = await Promise.race(waiting.values());
+      } catch {
+        await f.all;
+        throw new Error("archive-client: a fetch failed and said nothing");
+      }
+      waiting.delete(name);
+      const b = builders.find((x) => x.name === name);
+      try {
+        paths.set(name, await ensureIndex2(rel, b, {
+          force,
+          ...this.opts.log !== undefined ? { log: this.opts.log } : {},
+          ...this.opts.progress !== undefined ? { progress: this.opts.progress } : {}
+        }));
+      } catch (e) {
+        f.cancel();
+        await f.all.catch(() => {});
+        throw e;
+      }
     }
-    rel.close();
-    return { tag: rel.tag, built };
+    await f.all;
+    return want.map((name) => ({ name, path: paths.get(name) }));
   }
   plan(dryRun) {
     return { dryRun, remove: [], keep: [], bytes: 0 };
@@ -5145,7 +5568,7 @@ class ReleaseManager2 {
     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 });
+        rmSync5(r.path, { recursive: true, force: true });
     return p;
   }
   prune(o = {}) {
@@ -5167,7 +5590,7 @@ class ReleaseManager2 {
   }
   remove(tag, o = {}) {
     const path = tagDir(this.root, tag);
-    if (!existsSync5(path))
+    if (!existsSync6(path))
       throw new Error(`${tag} is not in the cache`);
     if (readPin2(this.root)?.tag === tag)
       throw new Error(`${tag} is pinned: \`unpin\` first`);
@@ -5179,7 +5602,7 @@ class ReleaseManager2 {
     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))
+      if (existsSync6(path))
         this.planRemove(p, path, `${t}'s indexes`);
     }
     return this.apply(p);
@@ -5188,8 +5611,8 @@ class ReleaseManager2 {
     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";
+      const p = join5(rel.dir, name);
+      const got = existsSync6(p) ? await sha256File2(p) : "missing";
       if (got !== f.sha256)
         bad.push({ file: name, want: f.sha256, got });
     }
@@ -5201,11 +5624,11 @@ function releases2(opts = {}) {
 }
 
 var LOCAL_DIR2 = "local";
-var localRoot2 = (root) => join5(root, LOCAL_DIR2);
+var localRoot2 = (root) => join6(root, LOCAL_DIR2);
 var newerThan2 = (a, b) => a.cut > b.cut || a.cut === b.cut && a.fraction > b.fraction;
 function readManifest(dir) {
-  const p = join5(dir, "MANIFEST.json");
-  if (!existsSync6(p))
+  const p = join6(dir, "MANIFEST.json");
+  if (!existsSync7(p))
     return null;
   try {
     const v = JSON.parse(readFileSync5(p, "utf8"));
@@ -5227,8 +5650,8 @@ function incomplete2(dir) {
     const d = dbs[name];
     if (d === undefined)
       continue;
-    const p = join5(dir, d.file ?? `${name}.sqlite`);
-    if (!existsSync6(p))
+    const p = join6(dir, d.file ?? `${name}.sqlite`);
+    if (!existsSync7(p))
       return `no ${d.file ?? `${name}.sqlite`}`;
     if (d.bytes !== undefined && statSync4(p).size !== d.bytes)
       return `${d.file ?? `${name}.sqlite`} is ${statSync4(p).size} bytes, the manifest says ${d.bytes}`;
@@ -5261,18 +5684,18 @@ function pickBuild2(builds, base) {
   return best;
 }
 function buildTag2(p) {
-  const at = typeof p.manifest.emittedAt === "string" && !Number.isNaN(Date.parse(p.manifest.emittedAt)) ? new Date(p.manifest.emittedAt) : statSync4(join5(p.build.dir, "MANIFEST.json")).mtime;
+  const at = typeof p.manifest.emittedAt === "string" && !Number.isNaN(Date.parse(p.manifest.emittedAt)) ? new Date(p.manifest.emittedAt) : statSync4(join6(p.build.dir, "MANIFEST.json")).mtime;
   const date = at.toISOString().slice(0, 10).replaceAll("-", ".");
   return renderArchiveTag2({ date, cut: p.version.cut, fraction: p.version.fraction });
 }
 function buildFiles(dir) {
-  return readdirSync4(dir).filter((n) => statSync4(join5(dir, n)).isFile()).filter((n) => {
+  return readdirSync4(dir).filter((n) => statSync4(join6(dir, n)).isFile()).filter((n) => {
     const m = /^(.*)\.sqlite(\.zst)?$/.exec(n);
     return m === null || isDatabase(m[1]);
   }).sort();
 }
 function lacks(b, manifest, inputs) {
-  return inputs.filter((a) => !planAsset2(a, manifest).published.some((n) => existsSync6(join5(b.dir, n))));
+  return inputs.filter((a) => !planAsset2(a, manifest).published.some((n) => existsSync7(join6(b.dir, n))));
 }
 function buildRemote(label) {
   const refuse = async () => {
@@ -5289,7 +5712,7 @@ async function openBuild2(root, p, opts) {
   const o = buildOptions(root, p.build.label, opts);
   const local = localRoot2(root);
   const tag = buildTag2(p);
-  const want = sha256Of(join5(p.build.dir, "MANIFEST.json"));
+  const want = sha256Of(join6(p.build.dir, "MANIFEST.json"));
   const current = () => {
     const rel = openCached2(tag, o);
     return rel !== null && rel.receipt().files["MANIFEST.json"]?.sha256 === want ? rel : null;
@@ -5298,33 +5721,33 @@ async function openBuild2(root, p, opts) {
   if (have !== null)
     return have;
   mkdirSync5(local, { recursive: true });
-  const work = join5(local, scratchName("add"));
+  const work = join6(local, scratchName("add"));
   try {
-    const stage = join5(work, "stage");
+    const stage = join6(work, "stage");
     mkdirSync5(stage, { recursive: true });
     for (const f of buildFiles(p.build.dir)) {
       try {
-        linkSync2(join5(p.build.dir, f), join5(stage, f));
+        linkSync2(join6(p.build.dir, f), join6(stage, f));
       } catch {
-        copyFileSync2(join5(p.build.dir, f), join5(stage, f));
+        copyFileSync2(join6(p.build.dir, f), join6(stage, f));
       }
     }
-    const added = await new ReleaseManager2({ ...o, cache: join5(work, "cache") }).add(stage, tag);
+    const added = await new ReleaseManager2({ ...o, cache: join6(work, "cache") }).add(stage, tag);
     const receipt = added.receipt();
     receipt.source = `local:${p.build.dir}`;
     writeJsonAtomic2(receiptPath(added.dir), receipt);
     added.close();
-    const dest = join5(local, tag);
-    if (existsSync6(dest) && current() === null) {
+    const dest = join6(local, tag);
+    if (existsSync7(dest) && current() === null) {
       try {
-        renameSync3(dest, join5(local, scratchName("old")));
+        renameSync3(dest, join6(local, scratchName("old")));
       } catch {}
     }
     try {
       renameSync3(added.dir, dest);
     } catch {}
   } finally {
-    rmSync5(work, { recursive: true, force: true });
+    rmSync6(work, { recursive: true, force: true });
   }
   const rel = current();
   if (rel === null)
@@ -5341,7 +5764,7 @@ function alive(pid) {
 }
 function sweepBuilds2(root, keep) {
   const local = localRoot2(root);
-  if (!existsSync6(local))
+  if (!existsSync7(local))
     return [];
   const gone = [];
   for (const name of readdirSync4(local).sort()) {
@@ -5352,23 +5775,23 @@ function sweepBuilds2(root, keep) {
       continue;
     if (m === null && parseArchiveTag2(name) === null)
       continue;
-    const path = join5(local, name);
+    const path = join6(local, name);
     try {
-      rmSync5(path, { recursive: true, force: true });
+      rmSync6(path, { recursive: true, force: true });
       gone.push(path);
     } catch {}
   }
   return gone;
 }
 
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
 var LATEST_CHECK_MS2 = 60 * 60 * 1000;
 var LATEST_CHECK_BUDGET_MS2 = 1500;
-var latestCheckPath2 = (root) => join6(root, "LATEST.json");
+var latestCheckPath2 = (root) => join7(root, "LATEST.json");
 function readLatestCheck2(root) {
   const p = latestCheckPath2(root);
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return null;
   try {
     const v = JSON.parse(readFileSync6(p, "utf8"));
@@ -5450,4 +5873,126 @@ function staleWarning2(answered, latest, floor, tags = [], command = "idq") {
   return `answered from ${answered}. ${floorTag ?? `cut ${floor.cut}`} is required${why}: run \`${command} use ${floor.cut}\` to get it`;
 }
 
-export { DATABASES2, planAsset2, sha256File2, unzstdTo2, NAME_LEVELS2, nameLevel2, TabFinder2, PanelFinder2, FeisPanelFinder2, columnsOf2, FEATURES2, capabilityOf2, needsRelease2, rosterOf2, NO_CALENDAR2, NO_UPCOMING2, FeisFinder2, ADVANCEMENT_DANCES2, entryRank2, FEIS_LOCAL_ID_FLOOR2, ResultFinder2, MajorsFinder2, LINEAGE_FILE2, linksOfLineage2, releaseSchoolGraph2, readsSpanishNames2, SchoolResolver2, initialsOnly2, nameOrderOf, DancerResolver2, readPopulation2, syllabusSourceOf2, canonicalOf2, CompResolver2, StaffFinder2, TeamFinder2, EventFinder2, defaultBuilders2, indexPath2, indexKey2, isCurrent2, buildIndex2, ensureIndex2, listIndexes2, readPin2, CALENDAR_STAGES2, CALENDAR_STAGE_STATES2, CALENDAR_TERMINALS2, CalendarFinder2, youngest2, dancerResolverOf2, RegistrationResolver2, ghRemote2, httpsRemote2, fallbackRemote2, setRemote2, defaultRemote, FIELD_STATES2, DEPARTURE_REASONS2, UpcomingFinder2, resolveTag2, Release2, openRelease2, openCached2, DEFAULT_KEEP2, ReleaseManager2, releases2, LOCAL_DIR2, localRoot2, newerThan2, incomplete2, releaseVersion2, pickBuild2, buildTag2, lacks, openBuild2, sweepBuilds2, LATEST_CHECK_MS2, LATEST_CHECK_BUDGET_MS2, latestCheckPath2, readLatestCheck2, latestCheck2, within, staleWarning2 };
+var PROGRESS_MODES2 = ["tty", "plain", "none"];
+function progressMode2(flag, env, isTTY) {
+  for (const [v, from] of [
+    [flag, "--progress"],
+    [env.IDQ_PROGRESS, "IDQ_PROGRESS"]
+  ]) {
+    if (v === undefined || v === "")
+      continue;
+    if (PROGRESS_MODES2.includes(v))
+      return v;
+    throw new Error(`${from} ${v}: expected ${PROGRESS_MODES2.join(", ")}`);
+  }
+  return isTTY ? "tty" : "plain";
+}
+var ENDS = new Set(["done", "failed", "cancelled"]);
+function bytesText(n) {
+  if (n >= 1e9)
+    return `${(n / 1e9).toFixed(2)} GB`;
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)} MB`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)} kB`;
+  return `${n} B`;
+}
+var secs = (ms) => `${(ms / 1000).toFixed(1)} s`;
+function plainLine(e, started) {
+  const what = e.kind === "index" ? `${e.tag} index ${e.item}` : `${e.tag} ${e.item}`;
+  if (e.state === "done") {
+    if (e.kind === "index")
+      return `done    ${what} in ${secs(e.ms)}`;
+    const size = e.unpacked > 0 ? `${bytesText(e.bytes)} -> ${bytesText(e.unpacked)}` : bytesText(e.bytes);
+    return `done    ${what} ${size} in ${secs(e.ms)}`;
+  }
+  if (e.state === "failed")
+    return `failed  ${what} after ${secs(e.ms)}: ${e.error ?? "failed"}`;
+  if (e.state === "cancelled")
+    return `cancelled ${what} after ${secs(e.ms)}`;
+  if (started)
+    return null;
+  return `start   ${what}${e.total !== null ? ` (${bytesText(e.total)})` : ""}`;
+}
+function ttyLine(e, width) {
+  const name = e.kind === "index" ? `index ${e.item}` : e.item;
+  let amount = "";
+  if (e.kind === "asset") {
+    amount = e.total !== null ? `${bytesText(e.bytes)} / ${bytesText(e.total)}` : bytesText(e.bytes);
+    if (e.unpacked > 0)
+      amount += `  unpacked ${bytesText(e.unpacked)}`;
+    if (!ENDS.has(e.state) && e.ms > 0)
+      amount += `  ${bytesText(e.bytes * 1000 / e.ms)}/s`;
+  }
+  const state = e.state === "failed" ? `failed: ${e.error ?? ""}` : ENDS.has(e.state) ? `${e.state} in ${secs(e.ms)}` : e.state;
+  const line = `${name.padEnd(34)} ${amount.padEnd(44)} ${state}`;
+  return line.length > width ? line.slice(0, Math.max(0, width - 1)) : line;
+}
+function progressRenderer2(mode, io) {
+  if (mode === "none")
+    return { mode, sink: () => {}, close: () => {} };
+  if (mode === "plain") {
+    const started = new Set;
+    return {
+      mode,
+      sink: (e) => {
+        const key = `${e.tag}\x00${e.kind}\x00${e.item}`;
+        const l = plainLine(e, started.has(key));
+        started.add(key);
+        if (ENDS.has(e.state))
+          started.delete(key);
+        if (l !== null)
+          io.line(l);
+      },
+      close: () => {}
+    };
+  }
+  const write = io.write ?? ((s) => process.stderr.write(s));
+  const columns = io.columns ?? (() => process.stderr.columns ?? 0);
+  const interval = io.intervalMs ?? 100;
+  const items = new Map;
+  let drawn = 0;
+  let timer = null;
+  let dirty = false;
+  const draw = () => {
+    timer = null;
+    if (!dirty)
+      return;
+    dirty = false;
+    const width = Math.max(40, columns() || 120);
+    let out = drawn > 0 ? `\x1B[${drawn}A` : "";
+    for (const e of items.values())
+      out += `\r\x1B[2K${ttyLine(e, width)}
+`;
+    drawn = items.size;
+    write(out);
+    if ([...items.values()].every((e) => ENDS.has(e.state))) {
+      items.clear();
+      drawn = 0;
+    }
+  };
+  return {
+    mode,
+    sink: (e) => {
+      const key = `${e.tag}\x00${e.kind}\x00${e.item}`;
+      const moved = items.get(key)?.state !== e.state;
+      items.set(key, e);
+      dirty = true;
+      if (moved) {
+        if (timer !== null)
+          clearTimeout(timer);
+        draw();
+      } else if (timer === null) {
+        timer = setTimeout(draw, interval);
+        timer.unref?.();
+      }
+    },
+    close: () => {
+      if (timer !== null)
+        clearTimeout(timer);
+      draw();
+    }
+  };
+}
+
+export { DATABASES2, planAsset2, sha256File2, unzstdTo2, streamTo2, NAME_LEVELS2, nameLevel2, TabFinder2, PanelFinder2, FeisPanelFinder2, columnsOf2, FEATURES2, capabilityOf2, needsRelease2, rosterOf2, NO_CALENDAR2, NO_UPCOMING2, FeisFinder2, ADVANCEMENT_DANCES2, entryRank2, FEIS_LOCAL_ID_FLOOR2, ResultFinder2, MajorsFinder2, LINEAGE_FILE2, linksOfLineage2, releaseSchoolGraph2, readsSpanishNames2, SchoolResolver2, initialsOnly2, nameOrderOf, DancerResolver2, readPopulation2, syllabusSourceOf2, canonicalOf2, CompResolver2, StaffFinder2, TeamFinder2, EventFinder2, defaultBuilders2, indexPath2, indexKey2, isCurrent2, buildIndex2, ensureIndex2, listIndexes2, readPin2, CALENDAR_STAGES2, CALENDAR_STAGE_STATES2, CALENDAR_TERMINALS2, CalendarFinder2, youngest2, dancerResolverOf2, RegistrationResolver2, ghRemote2, httpsRemote2, fallbackRemote2, setRemote2, defaultRemote, FIELD_STATES2, DEPARTURE_REASONS2, UpcomingFinder2, resolveTag2, DEFAULT_CONCURRENCY2, Release2, openRelease2, openCached2, DEFAULT_KEEP2, ReleaseManager2, releases2, LOCAL_DIR2, localRoot2, newerThan2, incomplete2, releaseVersion2, pickBuild2, buildTag2, lacks, openBuild2, sweepBuilds2, LATEST_CHECK_MS2, LATEST_CHECK_BUDGET_MS2, latestCheckPath2, readLatestCheck2, latestCheck2, within, staleWarning2, PROGRESS_MODES2, progressMode2, progressRenderer2 };