// Checksums of text and files against the ones given, and of this site against its manifest; Node runs all above page()
// DIGITS hex digits by algorithm · STRENGTH weakest to strongest · LENGTHS algorithm by digits · HEX hex of a byte
// LIMIT bytes "compare with" or a list file may hold · MOST files a manifest or a choice may hold · utf8 encoder
// no throw an Error with the properties of its second argument · num en-US number · plural "3 bytes"
// which the algorithm a tag names, or null · NEITHER a refusal · GNU TAGGED checksum line forms · entry one line read
// VARIANTS the slips a text is tried with · pause a turn for the page · unsafe what sitePath refuses
// createHash selfTest from sha.js
export {toHex, digest, algorithmFor, groups, formatBytes, formatSize, displayName, parseDigest, digestText, parseList,
 parseExpected, isListFileName, parseSidecar, mergeLists, comparePaths, formatList, matchFiles, compareDigests,
 otherAlgorithms, invisibles, textVariants, findVariant, hashSource, sitePath, decodeManifest, parseManifest,
 checkEntries, parseColophon, ledgerVerdict, checkSite, sameBytes};
import {createHash, selfTest} from "./sha.js";

const DIGITS = {"SHA-1": 40, "SHA-256": 64, "SHA-384": 96, "SHA-512": 128}, STRENGTH = Object.keys(DIGITS);
const LENGTHS = Object.fromEntries(Object.entries(DIGITS).map(([k, n]) => [n, k]));
const HEX = Array.from({length: 2 ** 8}, (_, i) => i.toString(16).padStart(2, "0"));
const LIMIT = 1e6, MOST = 1e4, utf8 = new TextEncoder();
const no = (s, o) => { throw Object.assign(new Error(s), o) };
const num = n => String(n).replace(/\B(?=(\d{3})+$)/g, ","), plural = (n, s) => `${num(n)} ${n === 1 ? s : s + "s"}`;

function toHex(buffer) {
 let s = "";
 for (const x of new Uint8Array(buffer)) s += HEX[x];
 return s }

async function digest(algorithm, data) {
 return toHex(await crypto.subtle.digest(algorithm, typeof data === "string" ? utf8.encode(data) : data)) }

function algorithmFor(hex) {
 return LENGTHS[hex.length] || no(hex.length === 32 ? "32 digits is usually MD5, which this page doesn't compute."
  : `No algorithm here has ${hex.length}-digit digests.`) }

function which(s) {
 const k = s.toUpperCase().replace(/^SHA2?-?(?=\d{3}$)/, "SHA-").replace(/^SHA-?1$/, "SHA-1");
 return DIGITS[k] ? k : null }

const groups = hex => hex.match(/.{1,8}/g) ?? [];
const formatBytes = n => plural(n, "byte");

// inv: the unit is picked after rounding: 999,999 bytes is 1.0 MB, not 1000 kB
function formatSize(n) {
 if (n < 1e3) return formatBytes(n);
 const f = j => { const x = n / 1e3**j; return x < 99.95 ? x.toFixed(1) : String(Math.round(x)) };
 let i = Math.min(Math.floor(Math.log10(n) / 3), 4);
 if (i < 4 && +f(i) >= 1e3) i++;
 return `${f(i)} ${["", "kB", "MB", "GB", "TB"][i]}` }

// Unicode: "invoice\u202Efdp.exe" displays as invoiceexe.pdf
const displayName = name => name.replace(/[\0-\x1f\x7f-\x9f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, c => `\\u{${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}}`);

const NEITHER = "That's neither a digest nor a checksum list.";

function parseDigest(text) {
 const t = text.trim(), m = /^([a-z0-9-]+):([0-9a-f]+)$/i.exec(t);
 if (m) {
  const algorithm = which(m[1]), n = m[2].length;
  algorithm || no(`That's ${m[1]}, which this page doesn't compute.`);
  n !== DIGITS[algorithm] && no(`A ${algorithm} digest has ${DIGITS[algorithm]} digits; this one has ${n}.`);
  return {algorithm, hexes: [m[2].toLowerCase()], notation: "oci", named: true} }
 const a = t.split(/\s+/);
 if (a.every(s => /^[0-9a-f]+$/i.test(s))) {
  const s = a.join("").toLowerCase();
  return {algorithm: algorithmFor(s), hexes: [s], notation: "hex", named: false} }
 a.every(s => /^[a-z]+\d*-/i.test(s)) || no(NEITHER);
 // SRI: the strongest algorithm present counts and any of its values may match; options after "?" are printable ASCII
 // guard: one optional ?-group covers "?a?b"; a repeated one backtracks over every split of a run of "?"
 const r = a.flatMap(x => {
  const [, k, v] = /^([a-z0-9]+)-([A-Za-z0-9+/]+={0,2})(?:\?[\x21-\x7e]*)?$/i.exec(x) ?? [];
  k || no(NEITHER);
  const algorithm = /^sha(256|384|512)$/i.test(k) && which(k);
  if (!algorithm) { a.length === 1 && no(`SRI values use sha256, sha384 or sha512, not ${k}.`); return [] }
  let s = "";
  try { s = atob(v) } catch {}
  s.length !== DIGITS[algorithm] / 2 && no(`An SRI ${k} value holds ${DIGITS[algorithm] / 2} bytes; this one holds ${s.length}.`);
  return [{algorithm, hex: Array.from(s, c => HEX[c.charCodeAt(0)]).join("")}] });
 const algorithm = STRENGTH.findLast(k => r.some(x => x.algorithm === k));
 algorithm || no("SRI values use sha256, sha384 or sha512.");
 return {algorithm, hexes: r.filter(x => x.algorithm === algorithm).map(x => x.hex), notation: "sri", named: true} }

// guard: written from the parse; text riding along in a link never shows beside a digest that isn't the one in use
function digestText({algorithm, hexes, notation}) {
 const k = algorithm.replace("-", "").toLowerCase();
 const f = s => btoa(String.fromCharCode(...s.match(/../g).map(x => parseInt(x, 16))));
 return notation === "sri" ? hexes.map(s => `${k}-${f(s)}`).join(" ")
  : notation === "oci" ? `${k}:${hexes[0]}` : hexes[0] }

const GNU = /^(\\?)([0-9a-f]+) [ *]?(.+)$/is, TAGGED = /^(\\?)([a-z][\w/-]*) ?\((.*)\) ?= ?([0-9a-f]+)$/is;

function entry(s, n) {
 const o = {line: n};
 let m = GNU.exec(s), q, k, hex, p, algorithm;
 if (m) [, q, hex, p] = m;
 else if ((m = TAGGED.exec(s))) [, q, k, p, hex] = m;
 else no(`Line ${n} isn't a checksum line.`, o);
 hex = hex.toLowerCase();
 if (k) {
  algorithm = which(k);
  algorithm || no(`Line ${n} uses ${k}, which this page doesn't compute.`, o);
  hex.length !== DIGITS[algorithm] && no(`Line ${n} has a ${hex.length}-digit digest; ${algorithm} has ${DIGITS[algorithm]}.`, o) }
 else try { algorithm = algorithmFor(hex) } catch (w) { no(`Line ${n}: ${w.message}`, o) }
 // GNU coreutils: a name holding a backslash or a line break is escaped, and its line starts with a backslash
 const path = q ? p.replace(/\\(.?)/gs, (_, c) => ({"\\": "\\", n: "\n", r: "\r"})[c] ?? no(`Line ${n} isn't a checksum line.`, o)) : p;
 return {algorithm, hex, path, line: n, named: !!k} }

function parseList(text) {
 const a = text.replace(/^\uFEFF/, "").split("\n").map(s => s.replace(/\r$/, "")), j = a.findIndex(s => s.trim());
 let i = 0, n = a.length, signed = false;
 // OpenPGP: armor headers end at the first blank line; signed means a signature follows, which nothing here checks
 if (a[j]?.trim() === "-----BEGIN PGP SIGNED MESSAGE-----") {
  i = j + 1;
  while (i < n && a[i] !== "") i++;
  n = a.indexOf("-----BEGIN PGP SIGNATURE-----", i);
  n < 0 && no("The list has a PGP header but no signature.", {line: j + 1});
  signed = true }
 const entries = [], seen = new Map();
 for (; i < n; i++) {
  const s = signed && a[i].startsWith("- ") ? a[i].slice(2) : a[i];
  if (!s.trim() || /^\s*#/.test(s)) continue;
  const r = entry(s, i + 1), k = `${r.algorithm}\0${r.path}`, y = seen.get(k);
  if (!y) { seen.set(k, r); entries.push(r) }
  else y.hex !== r.hex && no(`Lines ${y.line} and ${r.line} give ${displayName(r.path)} two different digests.`, {line: r.line}) }
 entries.length || no("The list names no files.");
 return {entries, signed} }

function parseExpected(text) {
 // UTF-8: a UTF-16 unit takes 1 to 3 bytes
 (text.length > LIMIT || (text.length > LIMIT / 3 && utf8.encode(text).length > LIMIT)) && no("That's longer than any checksum list this page reads (1 MB).");
 const t = text.replace(/^\uFEFF/, "").trim();
 if (!t) return {kind: "none"};
 if (!/[\r\n]/.test(t)) {
  const a = t.split(/\s+/), q = a.every(s => /^[0-9a-f]+$/i.test(s)) && !(a.length > 1 && LENGTHS[a[0].length]);
  if (a.length === 1 || q || a.every(s => /^[a-z]+\d*-\S+$/i.test(s))) return {kind: "digest", ...parseDigest(t)} }
 const o = parseList(text), [r] = o.entries;
 // GNU coreutils, OpenSSL: sha256sum and openssl dgst name standard input - or stdin, and one such line is a digest
 return o.entries.length === 1 && (r.path === "-" || r.path === "stdin") && !o.signed
  ? {kind: "digest", algorithm: r.algorithm, hexes: [r.hex], notation: "hex", named: r.named} : {kind: "list", ...o} }

const isListFileName = name => /^(?:sha(?:1|256|384|512)sums?(?:\.txt)?|shasums(?:1|256|384|512)?(?:\.txt)?|checksums?(?:\.txt)?|manifest\.txt|.+-checksum|.+\.sha(?:1|256|384|512)(?:sum)?)(?:\.asc)?$/i.test(name);

function parseSidecar(fileName, text) {
 const p = /^(.+)\.sha(?:1|256|384|512)(?:sum)?$/i.exec(fileName)?.[1], s = text.replace(/^\uFEFF/, "").trim();
 return p && /^[0-9a-f]+$/i.test(s) ? [{algorithm: algorithmFor(s), hex: s.toLowerCase(), path: p, line: 1, named: false}]
  : parseList(text).entries }

// guard: list files chosen together are one list, and a path two of them give two digests refuses with both named
function mergeLists(lists) {
 const entries = [], seen = new Map();
 for (const x of lists) for (const r of x.entries) {
  const k = `${r.algorithm}\0${r.path}`, y = seen.get(k);
  if (!y) { seen.set(k, {r, name: x.name}); entries.push(r) }
  else y.r.hex !== r.hex && no(`${y.name} and ${x.name} give ${displayName(r.path)} two different digests.`) }
 return {entries, signed: lists.some(x => x.signed)} }

// JS: sort() compares UTF-16 units; build.py and LC_ALL=C sort compare code points
function comparePaths(a, b) {
 const x = [...a], y = [...b];
 for (let i = 0; i < x.length && i < y.length; i++) if (x[i] !== y[i]) return x[i].codePointAt(0) - y[i].codePointAt(0);
 return x.length - y.length }

function formatList(items) {
 return [...items].sort((x, y) => comparePaths(x.path, y.path)).map(({hex, path}) => /[\\\n\r]/.test(path)
  ? `\\${hex}  ${path.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r")}\n` : `${hex}  ${path}\n`).join("") }

function matchFiles(entries, files) {
 const rest = new Map();
 for (const r of entries) {
  const y = rest.get(r.path);
  if (!y || STRENGTH.indexOf(r.algorithm) > STRENGTH.indexOf(y.algorithm)) rest.set(r.path, r) }
 const bare = p => p.replace(/^(\.\/)+/, ""), nfc = p => bare(p).normalize("NFC");
 const rel = x => x.folder && x.path.startsWith(x.folder + "/") ? x.path.slice(x.folder.length + 1) : x.path;
 const base = p => p.slice(p.lastIndexOf("/") + 1).normalize("NFC");
 const pairs = [], ambiguous = [], left = new Set(files), dup = new Set();
 for (const [how, f, g] of [
  ["exact",     r => r.path,       x => [x.path]],
  ["dot-slash", r => bare(r.path), x => [bare(x.path)]],
  ["folder",    r => bare(r.path), x => [bare(rel(x))]],
  ["nfc",       r => nfc(r.path),  x => [nfc(x.path), nfc(rel(x))]],
  ["basename",  r => base(r.path), x => [base(x.path)]]]) {
  const by = new Map(), own = new Map();
  for (const r of rest.values()) { const k = f(r); by.set(k, by.has(k) ? null : r) }
  for (const x of left) {
   const r = g(x).map(k => by.get(k)).find(Boolean);
   if (r) own.set(r, [...(own.get(r) ?? []), x]) }
  for (const [r, a] of own) {
   rest.delete(r.path);
   for (const x of a) left.delete(x);
   if (a.length === 1) pairs.push({entry: r, file: a[0], how});
   else { ambiguous.push({entry: r, files: a}); for (const x of a) dup.add(x) } } }
 return {pairs, missing: [...rest.values()], unlisted: [...left].filter(x => !dup.has(x)), ambiguous} }

function compareDigests(expectedHex, actualHex) {
 const x = expectedHex.toLowerCase(), y = actualHex.toLowerCase(), positions = [];
 if (x.length !== y.length) return {verdict: "differs", differing: Math.max(x.length, y.length), positions};
 for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) positions.push(i);
 const n = positions.length;
 return {verdict: n === 0 ? "match" : n <= 4 ? "typo" : "differs", differing: n, positions} }

const otherAlgorithms = length => ({64: ["SHA3-256", "BLAKE3"], 96: ["SHA3-384"], 128: ["SHA3-512", "BLAKE2b"]})[length] ?? [];

function invisibles(text) {
 let breaks = 0;
 while (text[text.length-1-breaks] === "\n") breaks++;
 const f = re => text.match(re)?.length ?? 0, bom = text.startsWith("\uFEFF");
 const nbsp = f(/[\u00a0\u2007\u202f]/g);
 // Unicode: a Default_Ignorable_Code_Point draws as nothing; the direction marks among them have a count of their own
 const zero = f(/(?![\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069])\p{Default_Ignorable_Code_Point}/gu) - (bom ? 1 : 0);
 const marks = f(/[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g);
 const lone = f(/[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g);
 const start = text.startsWith(" "), end = text.endsWith(" "), spaces = f(/ /g);
 return [
  breaks && (breaks === 1 ? "ends with a line break" : `ends with ${breaks} line breaks`),
  bom && "starts with a byte order mark",
  nbsp && plural(nbsp, "non-breaking space"),
  zero && plural(zero, "zero-width character"),
  marks && plural(marks, "direction mark"),
  text.normalize("NFC") !== text && "not in NFC form",
  lone && `${plural(lone, "unpaired surrogate")}, hashed as U+FFFD`,
  !text.trim() ? spaces && (spaces === text.length ? `${plural(spaces, "space")} and nothing else` : plural(spaces, "space"))
   : start && end ? "spaces at both ends" : start ? "a space at the start" : end && "a space at the end"].filter(Boolean) }

const VARIANTS = [
 ["a line break added at the end, the way echo adds one", s => s + "\n"],
 ["the line break at the end removed",                    s => s.replace(/\n$/, "")],
 ["Windows line breaks (CRLF)",                           s => s.replace(/\n/g, "\r\n")],
 ["Windows line breaks and one at the end",               s => s.replace(/\n?$/, "\n").replace(/\n/g, "\r\n")],
 ["its accents composed (Unicode NFC)",                   s => s.normalize("NFC")],
 ["its accents decomposed (Unicode NFD)",                 s => s.normalize("NFD")],
 ["the spaces and line breaks at either end trimmed",     s => s.trim()],
 ["a byte order mark at the start",                       s => "\uFEFF" + s]];

// inv: variants are told apart by their UTF-8, where a lone surrogate is U+FFFD
function textVariants(text) {
 if (text.length > 2 ** 20) return [];
 const back = new TextDecoder("utf-8", {ignoreBOM: true}), seen = new Set([back.decode(utf8.encode(text))]);
 return VARIANTS.flatMap(([label, f]) => {
  const bytes = utf8.encode(f(text)), k = back.decode(bytes);
  if (seen.has(k)) return [];
  seen.add(k);
  return [{label, bytes}] }) }

async function findVariant(text, {algorithm, hexes}) {
 for (const {label, bytes} of textVariants(text)) if (hexes.includes(await digest(algorithm, bytes))) return {label};
 return null }

const pause = () => globalThis.scheduler?.yield?.() ?? new Promise(f => setTimeout(f, 0));

async function hashSource(source, algorithms, {chunk = 2 ** 20, signal, onProgress} = {}) {
 const a = algorithms.map(createHash), {size} = source;
 const abort = () => new DOMException("Hashing was stopped.", "AbortError");
 if (signal?.aborted) throw abort();
 let done = 0, t = Date.now(), next = size ? source.read(0, Math.min(chunk, size)) : null;
 while (done < size) {
  const b = await next;
  if (signal?.aborted) throw abort();
  b.length !== Math.min(chunk, size - done) && no("The file changed while it was read.");
  done += b.length;
  next = done < size ? source.read(done, Math.min(done + chunk, size)) : null;
  for (const x of a) x.update(b);
  onProgress?.(done, size);
  if (Date.now() - t >= 4) { await pause(); t = Date.now() } }
 if (!size) onProgress?.(0, 0);
 return Object.fromEntries(algorithms.map((k, i) => [k, toHex(a[i].digest())])) }

const unsafe = p => !p || /[\0-\x1f\x7f-\x9f]/.test(p) || p.split("/").some(s => s === "" || s === "." || s === "..");

function sitePath(path) {
 unsafe(path) && no(`${displayName(path)} isn't a safe path.`);
 return "/" + path.split("/").map(encodeURIComponent).join("/") }

function decodeManifest(bytes) {
 try { return new TextDecoder("utf-8", {fatal: true}).decode(bytes) } catch { no("manifest.txt isn't valid UTF-8.") } }

// guard: an unreadable line refuses the list; skipping it would pass nonsense as zero files, all matching
function parseManifest(text) {
 const o = [], seen = new Map(), a = text.split("\n");
 for (let i = 0; i < a.length; i++) {
  const n = i + 1, at = {line: n};
  if (a[i].trim() === "") continue;
  const [, digest, path] = /^([0-9a-f]+) [ *](.+)$/s.exec(a[i]) ?? [];
  digest || no(`Line ${n} isn't a checksum line.`, at);
  try { algorithmFor(digest) } catch (w) { no(`Line ${n}: ${w.message}`, at) }
  unsafe(path) && no(`Line ${n} names an unsafe path.`, at);
  seen.has(path) && no(`Lines ${seen.get(path)} and ${n} both name ${displayName(path)}.`, at);
  seen.set(path, n);
  o.push({digest, path, line: n}) > MOST && no(`It lists more than ${num(MOST)} files.`, at) }
 o.length || no("The manifest lists no files.");
 return o }

async function checkEntries(entries, load, {concurrency = 6, onProgress} = {}) {
 const o = [];
 let next = 0, done = 0;
 await Promise.all(Array.from({length: Math.min(concurrency, entries.length)}, async () => {
  while (next < entries.length) {
   const i = next++, r = entries[i];
   try {
    const b = await load(r.path), actual = await digest(algorithmFor(r.digest), b), ok = actual === r.digest;
    o[i] = {...r, actual, size: b.byteLength, ok, status: ok ? "ok" : "changed"} }
   catch (w) {
    o[i] = {...r, actual: null, ok: false, status: w?.status === 404 ? "missing" : "unreadable", error: String(w)} }
   onProgress?.(++done, entries.length) } }));
 return o }

function parseColophon(html) {
 const m = /<li>digest <span class="summary"><code>([0-9a-f]{64})<\/code><\/span><\/li>/.exec(html);
 const releases = [...html.matchAll(/<li><time datetime="(\d{4}-\d\d-\d\d)">\1<\/time> <code>([0-9a-f]{64})<\/code><\/li>/g)]
  .map(([, date, hex]) => ({date, hex}));
 (!m || (!releases.length && !html.includes("Nothing has been released yet."))) && no("The colophon couldn't be read.");
 return {build: m[1], releases} }

function ledgerVerdict(manifestHex, {build, releases}) {
 const i = releases.findIndex(r => r.hex === manifestHex);
 const o = {releases: releases.length, buildDiffers: build !== manifestHex};
 return i === 0 ? {kind: "newest", date: releases[0].date, ...o}
  : i > 0 ? {kind: "earlier", date: releases[i].date, below: i, ...o}
  : {kind: build === manifestHex ? "unreleased" : "absent", ...o} }

async function checkSite(fetchBytes, {onProgress} = {}) {
 async function pull() {
  try { const b = await fetchBytes("/manifest.txt"); return {b, hex: await digest("SHA-256", b)} }
  catch (w) { no(w?.status ? `manifest.txt couldn't be fetched (${w.status}).` : "The site couldn't be reached.") } }
 const r = await pull(), s = decodeManifest(r.b);
 let entries, colophon = null, colophonError = null, ledger = null;
 try { entries = parseManifest(s) } catch (w) { no(`manifest.txt couldn't be read. ${w.message}`, {line: w.line}) }
 onProgress?.(0, entries.length);
 const results = await checkEntries(entries, p => fetchBytes(sitePath(p)), {onProgress});
 const moved = (await pull()).hex !== r.hex;
 try {
  colophon = parseColophon(new TextDecoder().decode(await fetchBytes("/colophon/")));
  ledger = ledgerVerdict(r.hex, colophon) }
 catch { colophonError = "The colophon couldn't be read." }
 const manifest = {hex: r.hex, size: r.b.byteLength, count: entries.length};
 return {manifest, entries, results, moved, colophon, colophonError, ledger} }

function sameBytes(results, path) {
 const s = results.find(r => r.path === path)?.actual;
 return s ? results.filter(r => r.actual === s && r.path !== path).map(r => r.path) : [] }

if (typeof document !== "undefined") page();

// guard: text from outside reaches the page as text nodes, .value and attributes, never parsed as markup
function page() {
 // mode the selected algorithm · want "compare with" as parsed · why its refusal · from where its text came
 // auto whether it picked mode · sole the one algorithm it names · ls out bad list files read into it, left out,
 // refused · fill what they wrote there · era counts clears · text the text's digest · test the self-test
 // jobs keys adds the files chosen · memo them matched to the list · lost rows for its missing entries
 // laid when rows were last placed · turn lap slow wait the text's races and timers · idle the typing timer
 // run quit busy held the files' run · off no hashing here · lock site the site check · frag the address
 // $ h note say hear tell ink word goal flip hide the page · copy clip the clipboard · live bulk duel real bare
 // pair uses got rate dir due shas fold sums what stands · nth and typo kin few gist side hint book glue link li
 // the sentences · take pick hash plan rule add scan feed work end halt tick the work
 // view draw sync put lay deem the rows · drag calm the drop · grab cite post the site check
 const $ = id => document.getElementById(id);
 function h(tag, props, ...kids) {
  const node = document.createElement(tag);
  for (const [k, v] of Object.entries(props ?? {})) if (k.includes("-")) node.setAttribute(k, v); else node[k] = v;
  node.append(...kids.filter(x => x != null && x !== ""));
  return node }
 const note = (id, s, q) => { hear(id, s); $(id).classList.toggle("error", !!q) };

 if (!globalThis.crypto?.subtle) {
  const main = document.querySelector("main");
  for (const x of [...main.children].slice(2)) x.remove();
  main.append(h("p", {className: "notice"}, "This browser doesn't offer hashing here."));
  return }

 const test = selfTest(), text = {value: "", hex: "", algorithm: ""}, jobs = [], keys = new Map();
 const ls = new Map(), out = new Set(), bad = new Map();
 let mode = "SHA-256", want = {kind: "none"}, why = "", from = "", auto = false, sole = null, fill = "", era = 0;
 let memo = null, lost = new Map(), adds = 0, laid = 0, turn = 0, lap = 0, slow = 0, wait = 0, idle = 0;
 let run = 0, quit = null, busy = false, held = false, off = false, lock = false, site = null;

 function ink(hex, marks = [], code = h("code", {className: "digest"})) {
  const marked = new Set(marks);
  code.replaceChildren(...groups(hex).flatMap((s, i) => {
   const x = h("span");
   for (let j = 0; j < s.length;) {
    const q = marked.has(i*8 + j);
    let k = j + 1;
    while (k < s.length && marked.has(i*8 + k) === q) k++;
    x.append(q ? h("mark", {}, s.slice(j, k)) : s.slice(j, k));
    j = k }
   return i ? [h("wbr"), x] : [x] }));
  return code }

 const say = s => { $("announce").textContent = ""; setTimeout(() => { $("announce").textContent = s }, 50) };
 // a11y: what is heard is kept apart from what shows; a status repaints on every change and speaks only news
 const hear = (id, s) => { if ($(id).textContent !== s) $(id).textContent = s };
 const tell = (s, q) => { note("files-status", s, q); hear("files-said", $("files-status").textContent) };

 async function copy(button, s, f, what = "digest") {
  try {
   await navigator.clipboard.writeText(s);
   button.dataset.copied = "";
   clearTimeout(button.timer); button.timer = setTimeout(() => { delete button.dataset.copied }, 2e3);
   say("Copied.") }
  catch {
   const x = f();
   x.hidden = false;
   getSelection().selectAllChildren(x);
   say(`Couldn't copy, so the ${what} is selected instead.`) } }
 function clip(s, f, g) {
  const x = h("button", {type: "button", className: "quiet copy", "aria-label": s},
   h("span", {}, "copy"), h("span", {"aria-hidden": "true"}, "copied"));
  x.addEventListener("click", () => { copy(x, f(), g) });
  return x }

 const live = () => want.kind !== "none" && (!sole || sole === mode), bulk = () => live() && want.kind === "list";
 const duel = () => want.kind === "digest" && text.value && text.algorithm === mode;
 const real = () => jobs.filter(x => x.file), bare = () => real().filter(x => !ls.has(x));

 function pair() {
  if (!memo) {
   const r = matchFiles(want.entries, bare().map(x => ({path: x.path, folder: x.folder, item: x})));
   memo = {of: new Map(r.pairs.map(x => [x.file.item, x])),
    ambiguous: new Map(r.ambiguous.flatMap(x => x.files.map(y => [y.item, x]))), missing: r.missing} }
  return memo }
 const uses = x => (bulk() && pair().of.get(x)?.entry.algorithm) || mode, got = x => x.digests[uses(x)];

 function rate(item, hex) {
  if (!live() || !hex) return null;
  if (want.kind === "digest") {
   const a = want.hexes.map(s => ({want: s, ...compareDigests(s, hex)}));
   return {...a.sort((x, y) => x.differing - y.differing)[0], named: want.named} }
  const r = pair().of.get(item);
  return r && {...compareDigests(r.entry.hex, hex), want: r.entry.hex, named: r.entry.named, how: r.how} }

 const nth = n => n + (n % 100 > 10 && n % 100 < 14 ? "th" : ["th", "st", "nd", "rd"][n%10] ?? "th");
 const and = a => a.length > 1 ? `${a.slice(0, -1).join(", ")} and ${a.at(-1)}` : a[0];
 const typo = r => `${r.differing} of ${r.want.length} digits ${r.differing === 1 ? "differs" : "differ"}, the ${and(r.positions.map(i => nth(i + 1)))}. Digests of different inputs differ in about ${Math.floor(r.want.length * 15 / 16)}, so the expected value was probably copied wrong.`;
 const kin = n => { const a = otherAlgorithms(n); return a.length ? `A ${n}-digit digest can also come from ${a.join(" or ")}, which this page doesn't compute.` : "" };
 const few = a => a.length > 3 ? `${a.slice(0, 3).join(", ")} and ${num(a.length - 3)} more` : and(a);
 const word = (s, k) => h("span", {className: k}, s);
 const goal = (s, a) => h("div", {className: "expected"}, h("span", {className: "meta"}, "expected"), ink(s, a));

 function take() {
  try {
   want = ls.size > 1 && $("expected").value === fill ? {kind: "list", ...mergeLists([...ls.values()])}
    : parseExpected($("expected").value);
   why = "" }
  catch (w) { want = {kind: "none"}; why = w.message }
  $("expected").setAttribute("aria-invalid", String(!!why));
  memo = null;
  const a = new Set(want.kind === "list" ? want.entries.map(r => r.algorithm) : [want.algorithm]);
  sole = a.size === 1 ? [...a][0] ?? null : null;
  auto = !!sole && sole !== mode;
  if (auto) pick(sole);
  else if (!busy && !held && jobs.some(due)) work();
  deem();
  hear("expected-said", $("expected-status").textContent) }

 function gist() {
  if (!live()) return want.kind === "none" ? "" : `${mode} is selected, so nothing is compared with it.`;
  const a = bare(), all = [...(duel() ? [null] : []), ...a];
  if (!all.length) return "Nothing to compare it with yet.";
  if (a.some(x => !x.error && !got(x))) return "";
  const f = x => rate(x, x ? got(x) : text.hex)?.verdict === "match";
  if (want.kind === "digest") {
   const hits = all.filter(f), names = hits.filter(Boolean).map(x => x.name);
   if (!hits.length) return "Nothing here matches it.";
   if (hits.length === 1) return `${hits[0] ? names[0] : "The text"} matches.`;
   const s = names.length > 3 ? `${names.slice(0, 3).join(", ")} and ${num(names.length - 3)} more` : names.join(", ");
   return hits.includes(null) ? `The text and ${plural(names.length, "file")} match: ${s}.` : `${num(names.length)} files match: ${s}.` }
  const n = a.filter(f).length, left = pair().missing.length;
  return `${num(n)} of ${num(a.length)} chosen files ${n === 1 ? "matches" : "match"} the list.` + (!left ? ""
   : dir() ? ` ${plural(left, "file")} in the list ${left === 1 ? "is" : "are"} missing.`
   : ` ${num(left)} other ${left === 1 ? "file in the list wasn't" : "files in the list weren't"} chosen.`) }

 function side() {
  const a = [...out].map(x => x.name), r = [...bad], q = a.length === 1;
  return [r.length === 1 ? `${r[0][0].name} couldn't be read as a list. ${r[0][1]}`
   : r.length && `${few(r.map(([x]) => x.name))} couldn't be read as lists.`,
   a.length && `${few(a)} ${q ? "wasn't" : "weren't"} used as the list, because the “compare with” field already had something in it. To use ${q ? "it" : "them"}, empty that field and choose the ${q ? "file" : "files"} again.`]
   .filter(Boolean).join(" ") }

 function hint() {
  const more = side(), also = more ? ` ${more}` : "";
  if (why) return note("expected-status", why + also, true);
  if (want.kind === "none") return note("expected-status", more || "One digest, or a whole checksum file such as SHA256SUMS.", !!bad.size);
  const a = new Set((want.entries ?? [want]).map(r => r.algorithm));
  const whence = ls.size ? few([...ls.values()].map(x => x.name)) : from;
  const signed = [...ls.values()].filter(x => x.signed).map(x => x.name), one = signed.length === 1;
  let s = whence ? `Read from ${whence}. ` : "";
  s += want.kind === "list" ? `A checksum list: ${plural(want.entries.length, "file")}, ${STRENGTH.filter(k => a.has(k)).join(" and ")}`
   : want.notation === "sri" ? `An SRI value, ${want.algorithm}` : `A ${want.algorithm} digest`;
  s += auto ? `, so ${mode} is selected above.` : ".";
  s += ls.size > 1 && signed.length ? ` ${few(signed)} ${one ? "is" : "are"} signed, but this page doesn't check signatures, so check ${one ? "it" : "them"} with gpg first.`
   : want.signed ? " It's signed, but this page doesn't check signatures, so check it with gpg first." : "";
  const r = gist();
  note("expected-status", (r ? `${s} ${r}` : s) + also) }

 $("expected").addEventListener("input", e => {
  from = ""; ls.clear(); fill = "";
  clearTimeout(idle); idle = setTimeout(take, e.inputType?.startsWith("insertFrom") ? 0 : 400) });

 function pick(s) {
  mode = s;
  for (const x of document.querySelectorAll("#algorithm input")) x.checked = x.value === s;
  $("text-copy").setAttribute("aria-label", `Copy the ${s} of the text`);
  $("files-copy").firstElementChild.textContent = `copy as ${s.replace("-", "")}SUMS`;
  hash(false);
  if (real().length) work() }
 $("algorithm").addEventListener("change", e => {
  auto = false;
  pick(e.target.value);
  deem() });
 // Safari: focus moved by arrow keys between radios is not :focus-visible; data-keys stands in
 $("algorithm").addEventListener("keydown", () => { $("algorithm").dataset.keys = "" });
 $("algorithm").addEventListener("pointerdown", () => { delete $("algorithm").dataset.keys });

 function hash(q) {
  const s = $("text").value, b = utf8.encode(s), me = ++turn, k = mode, big = b.length > 2 ** 20;
  clearTimeout(slow);
  if (big) {
   $("text-meta").textContent = `${k} of ${formatBytes(b.length)} · hashing…`;
   $("text-digest").classList.add("stale") }
  async function go() {
   const hex = await digest(k, b);
   if (me !== turn) return;
   Object.assign(text, {value: s, hex, algorithm: k});
   $("text-meta").textContent = [`${k} of ${formatBytes(b.length)}`, ...invisibles(s)].join(" · ");
   ink(hex, [], $("text-digest"));
   $("text-digest").classList.remove("stale");
   plan(q ? 750 : 0) }
  if (big) slow = setTimeout(go, 150);
  else go() }
 $("text").addEventListener("input", e => { hash(!e.inputType?.startsWith("insertFrom")) });

 function plan(ms) {
  clearTimeout(wait);
  if (ms) $("text-verdict").classList.add("stale");
  wait = setTimeout(rule, ms) }

 async function rule() {
  const me = turn, call = ++lap, a = [], v = duel() ? rate(null, text.hex) : null;
  let marks = [];
  if (v?.verdict === "match") a.push(h("p", {className: "verdict"}, word("= matches", "ok")));
  else if (v?.verdict === "typo") {
   marks = v.positions;
   a.push(h("p", {className: "verdict"}, word("≠ doesn't match", "bad")), goal(v.want, marks),
    h("p", {className: "note"}, typo(v))) }
  else if (v) {
   const r = await findVariant(text.value, want);
   if (me !== turn || call !== lap) return;
   if (r) a.push(h("p", {className: "verdict"}, word("≠ doesn't match", "bad"), ` as typed. It does with ${r.label}.`));
   else if (!adds) {
    a.push(h("p", {className: "verdict"}, word("≠ doesn't match", "bad")));
    const s = !v.named && !invisibles(text.value).length && kin(v.want.length);
    if (s) a.push(h("p", {className: "note"}, s)) } }
  ink(text.hex, marks, $("text-digest"));
  $("text-verdict").classList.remove("stale");
  const k = a.map(x => x.textContent).join("\n");
  if ($("text-verdict").dataset.said !== k) {
   $("text-verdict").dataset.said = k;
   $("text-verdict").replaceChildren(...a);
   // a11y: the expected digest is shown, not read out; the sentence names the digits that differ
   const said = a.filter(x => !x.classList.contains("expected")).map(x => x.textContent);
   hear("text-said", said.map((x, i) => i < said.length - 1 && !x.endsWith(".") ? `${x}.` : x).join(" ")) }
  hint() }

 const dir = () => jobs.some(x => x.folder);
 $("folder-choose").hidden = !("webkitdirectory" in HTMLInputElement.prototype);

 function add(list, kind = "") {
  if (off) return;
  const a = [...list].sort((x, y) => comparePaths(x.webkitRelativePath || x.name, y.webkitRelativePath || y.name));
  const n = real().length + a.length, r = [];
  if (n > MOST) return tell(kind === "folder" ? `This folder has ${num(a.length)} files; ${num(MOST)} is the most this page hashes.`
   : `That would make ${num(n)} files; ${num(MOST)} is the most this page hashes.`, true);
  for (const file of a) {
   const path = file.webkitRelativePath || file.name, k = `${path}\0${file.size}\0${file.lastModified}`, y = keys.get(k);
   if (y) { if (out.has(y)) r.push(y); continue }
   const x = {file, path, name: displayName(path), digests: {}};
   keys.set(k, x);
   if (file.webkitRelativePath) x.folder = path.split("/")[0];
   jobs.push(x);
   adds++;
   if (isListFileName(file.name) && file.size <= LIMIT) r.push(x) }
  if (r.length) scan(r);
  memo = null;
  deem();
  work() }

 async function scan(batch) {
  const n = era, a = await Promise.all(batch.map(async x => {
   try {
    const s = await x.file.text(), q = /^[0-9a-f]+$/i.test(s.replace(/^\uFEFF/, "").trim());
    const r = q ? {entries: parseSidecar(x.file.name, s), signed: false} : parseList(s);
    return {item: x, name: x.name, ...r, content: q ? formatList(r.entries) : s} }
   catch (w) { return {item: x, error: w.message} } }));
  if (n !== era) return;
  const good = a.filter(r => !r.error);
  for (const r of a) { out.delete(r.item); bad.delete(r.item); if (r.error) bad.set(r.item, r.error) }
  // inv: what the visitor wrote in the field is never replaced
  if (good.length && (!$("expected").value.trim() || (ls.size && $("expected").value === fill))) {
   for (const r of good) ls.set(r.item, r);
   const all = [...ls.values()];
   $("expected").value = all.length === 1 ? all[0].content
    : formatList(new Map(all.flatMap(x => x.entries).map(r => [`${r.hex}\0${r.path}`, r])).values());
   fill = $("expected").value;
   from = "" }
  else for (const r of good) out.add(r.item);
  take() }

 const feed = f => ({size: f.size, read: (i, j) => f.slice(i, j).arrayBuffer().then(b => new Uint8Array(b))});
 const due = x => x.file && !x.error && !got(x);
 const hide = id => { if ($(id).contains(document.activeElement)) $("files-choose").focus(); $(id).hidden = true };
 const flip = (q, id) => { if (q) $(id).hidden = false; else hide(id) };

 async function work() {
  const me = ++run;
  quit?.abort();
  quit = new AbortController();
  const {signal} = quit;
  if (!(await test) || me !== run) return;
  held = false;
  const a = jobs.filter(due);
  if (!a.length) return end();
  busy = true;
  $("files-stop").textContent = "stop";
  $("files-stop").hidden = false;
  for (const x of a) x.state = "waiting";
  tell(`Hashing ${plural(a.length, "file")}, ${shas()}.`);
  deem();
  let j = 0;
  function next() {
   for (let i = j; i < jobs.length; i++) if (due(jobs[i])) { j = i; return jobs[i] }
   return jobs.find(due) }
  for (let x; (x = next());) {
   Object.assign(x, {state: "hashing", started: performance.now(), progress: "", painted: 0});
   sync(x);
   try {
    Object.assign(x.digests, await hashSource(feed(x.file), [uses(x)], {signal, onProgress: (i, n) => tick(x, i, n)})) }
   catch {
    if (me !== run) return;
    x.error = "This file couldn't be read; it may have changed while it was being read." }
   if (me !== run) return;
   x.state = "";
   sync(x);
   if (adds > 50 && performance.now() - laid > 250) lay() }
  busy = false;
  end() }

 function end() {
  busy = false;
  hide("files-stop");
  deem();
  // a11y: the end of a run is spoken once, with what it found, and "compare with" stays quiet about it
  const s = want.kind === "digest" && real().length ? gist() : "";
  hear("files-said", s ? `${$("files-status").textContent} ${s}` : $("files-status").textContent) }

 function halt() {
  if (!busy) return;
  run++;
  quit.abort();
  busy = false;
  held = true;
  $("files-stop").textContent = "continue";
  for (const x of jobs) if (x.state) x.state = "stopped";
  tell("Stopped.");
  deem() }
 $("files-stop").addEventListener("click", () => { if (busy) halt(); else work() });
 document.addEventListener("keydown", e => { if (e.key === "Escape" && busy && e.target.tagName !== "SELECT") halt() });

 function tick(x, i, n) {
  const t = performance.now();
  if (t - x.painted < 100 && i < n) return;
  x.painted = t;
  const ms = t - x.started, left = ms > 2e3 && i ? (n - i) * ms / i / 1e3 : 0;
  x.progress = `${Math.floor(i / n * 100)}% of ${formatSize(n)}` +
   (left > 5 ? ` · about ${left < 60 ? `${Math.max(5, Math.round(left / 5) * 5)} s` : `${Math.round(left / 60)} min`} left` : "");
  if (x.row) { x.row.state.textContent = x.progress; if (x.row.bar) x.row.bar.value = i } }

 const shas = () => STRENGTH.filter(k => real().some(x => uses(x) === k)).join(" and ") || mode;

 function view(x) {
  const k = uses(x), s = x.digests?.[k];
  const o = {facts: [], hex: "", marks: [], state: "", want: "", note: "", error: ""};
  if (x.missing) { o.facts.push(["missing", ""]); return o }
  if (x.file) o.facts.push([formatBytes(x.file.size), ""]);
  if (x.error) { o.error = x.error; return o }
  if (!s) {
   o.state = x.state === "hashing" ? x.progress || `0% of ${formatSize(x.file.size)}` : x.state || "waiting";
   o.bar = x.state === "hashing" && x.file.size > 32 * 2**20;
   return o }
  o.hex = s;
  if (k !== mode) o.facts.push([k, ""]);
  if (ls.has(x)) { o.facts.push(["used as the list", ""]); return o }
  const y = bulk() && pair().ambiguous.get(x);
  if (y) {
   o.error = `${y.files.length} chosen files are named ${displayName(y.files[0].path.split("/").pop())}; choose the folder instead.`;
   return o }
  const r = rate(x, s);
  if (!r) { if (bulk()) o.facts.push(["not in the list", ""]); return o }
  if (r.verdict === "match") {
   o.facts.push(["= matches", "ok"]);
   if (r.how === "nfc") o.note = "Matched after Unicode normalization (NFC)." }
  else if (r.verdict === "typo") {
   o.facts.push(["≠ doesn't match", "bad"]);
   Object.assign(o, {marks: r.positions, want: r.want, note: typo(r)}) }
  // inv: against one digest several things at once, only matches and near misses are marked
  else if (!(want.kind === "digest" && adds + (text.value ? 1 : 0) > 1)) {
   o.facts.push(["≠ doesn't match", "bad"]);
   if (!r.named) o.note = kin(r.want.length) }
  return o }

 function draw(x, v) {
  const code = v.hex ? ink(v.hex, v.marks) : null, o = {state: h("p", {className: "meta state"}, v.state),
   bar: v.bar ? h("progress", {max: x.file.size, value: 0, "aria-label": `Hashing ${x.name}`}) : null};
  o.li = h("li", {},
   h("div", {className: "line"}, h("span", {className: "name"}, x.name),
    h("span", {className: "facts"}, ...v.facts.flatMap(([s, k], i) => [i ? " · " : "", k ? word(s, k) : s])),
    code && clip(`Copy the ${uses(x)} of ${x.name}`, () => v.hex, () => code)),
   code, v.state && o.state, o.bar, v.want && goal(v.want, v.marks),
   v.error && h("p", {className: "note error"}, v.error), v.note && h("p", {className: "note"}, v.note));
  return o }

 const fold = () => adds > 50 && !$("files-all").open;

 function sync(x) {
  const v = view(x), k = JSON.stringify(v);
  if (x.signature === k && (x.row || fold())) return v;
  Object.assign(x, {signature: k, view: v});
  if (fold()) { x.row = null; return v }
  const q = x.row?.li.contains(document.activeElement), o = draw(x, v);
  x.row?.li.replaceWith(o.li);
  x.row = o;
  if (q) o.li.querySelector("button")?.focus();
  return v }

 function put(list, a) {
  const kids = list.children;
  let i = 0;
  while (i < a.length && kids[i] === a[i]) i++;
  while (kids.length > i) kids[kids.length-1].remove();
  list.append(...a.slice(i)) }

 function lay() {
  const gone = bulk() && dir() ? pair().missing : [], big = jobs.length + gone.length > 50;
  const a = [...jobs, ...gone.map(r => {
   if (!lost.has(r)) {
    const x = {missing: true, name: displayName(r.path)};
    lost.set(r, {...x, row: draw(x, view(x))}) }
   return lost.get(r) })];
  put(big ? $("files-all").querySelector("ol") : $("files-list"), big && !$("files-all").open ? [] : a.map(x => x.row.li));
  $("files-all").hidden = !big;
  $("files-all").querySelector("summary").textContent = `all ${plural(a.length, "file")}`;
  // cost: a flagged row rebuilds only when what it shows changes; thousands of mismatches add one row a file
  if (big) put($("files-list"), a.flatMap(x => {
   const v = x.view ?? view(x);
   if (!v.error && !v.facts.some(([s]) => /^(≠|missing|not in)/.test(s))) return [];
   const k = x.signature ?? JSON.stringify(v);
   if (x.flagged?.signature !== k) x.flagged = {signature: k, li: draw(x, v).li};
   return [x.flagged.li] }));
  $("files-progress").textContent = busy && big
   ? `${num(real().filter(x => got(x) || x.error).length)} of ${plural(adds, "file")}` : "";
  laid = performance.now() }

 function deem() {
  for (const x of jobs) sync(x);
  lay();
  flip(jobs.length, "files-actions");
  flip(bare().some(x => x.digests[mode]), "files-copy-part");
  if (!$("files-sums").hidden && $("files-sums").textContent !== sums()) $("files-sums").hidden = true;
  if (!busy && !held && real().length) {
   const done = real().filter(got).length, fail = real().filter(x => x.error).length, r = gist();
   note("files-status", [done && `${plural(done, "file")} hashed, ${shas()}.`,
    fail && `${done ? num(fail) : plural(fail, "file")} couldn't be read.`, want.kind === "list" && r].filter(Boolean).join(" ")) }
  else if (!jobs.length) note("files-status", "");
  hint();
  plan(0) }

 $("files-all").addEventListener("toggle", deem);
 $("files-choose").addEventListener("click", () => { $("files-input").click() });
 $("folder-choose").addEventListener("click", () => { $("folder-input").click() });
 for (const [id, k] of [["files-input", ""], ["folder-input", "folder"]])
  $(id).addEventListener("change", e => { add(e.target.files, k); e.target.value = "" });
 $("files-clear").addEventListener("click", () => {
  run++; era++;
  quit?.abort();
  busy = held = false;
  jobs.length = adds = 0;
  keys.clear(); memo = null; lost = new Map();
  const q = ls.size > 0;
  if (q) $("expected").value = "";
  ls.clear(); out.clear(); bad.clear(); fill = "";
  $("files-sums").hidden = true;
  hide("files-stop");
  if (q) take();
  else deem() });
 function sums() {
  return formatList(bare().filter(x => x.digests[mode])
   .map(x => ({hex: x.digests[mode], path: x.folder ? x.path.slice(x.folder.length + 1) : x.path}))) }
 $("files-copy").addEventListener("click", e => {
  const s = sums();
  if (s) copy(e.currentTarget, s, () => Object.assign($("files-sums"), {textContent: s}), "list") });

 // HTML drag and drop: a drop the page doesn't take opens the file; a drop of files is always taken, even when off
 const drag = e => e.dataTransfer?.types.includes("Files");
 function calm() {
  delete $("files").dataset.dragging;
  const x = $("files-hint").querySelector(".drop-hint");
  if (x) x.textContent = "They can also be dropped anywhere on the page." }
 for (const k of ["dragenter", "dragover"]) document.addEventListener(k, e => {
  if (!drag(e)) return;
  e.preventDefault();
  if (off) { e.dataTransfer.dropEffect = "none"; return }
  e.dataTransfer.dropEffect = "copy";
  $("files").dataset.dragging = "";
  const n = e.dataTransfer.items.length;
  $("files-hint").querySelector(".drop-hint").textContent = n ? `Drop to add ${plural(n, "file")}.` : "Drop to add them." });
 document.addEventListener("dragleave", e => { if (!e.relatedTarget) calm() });
 document.addEventListener("dragend", calm);
 document.addEventListener("drop", e => {
  if (!drag(e)) return;
  e.preventDefault();
  calm();
  if (off) return;
  const a = [];
  for (const x of e.dataTransfer.items) {
   if (x.kind !== "file") continue;
   const y = x.webkitGetAsEntry?.();
   if (y?.isDirectory) jobs.push({name: displayName(y.name),
    error: $("folder-choose").hidden ? "Folders can't be dropped here." : "Folders can't be dropped here; use Choose a folder."});
   else a.push(x.getAsFile()) }
  add(a.filter(Boolean)) });

 test.then(q => {
  if (q) return;
  off = true;
  $("files-choose").parentElement.hidden = true;
  $("files-hint").textContent = "This browser's hashing disagreed with a self-test, so files aren't hashed here." });

 async function grab(u) {
  let r;
  try { r = await fetch(u, {cache: "no-store"}) } catch { no("The site couldn't be reached.") }
  r.ok || no(`${u}: ${r.status}`, {status: r.status});
  return new Uint8Array(await r.arrayBuffer()) }

 function book(r) {
  if (r.colophonError) return "The colophon couldn't be read, so compare the digest below with it by hand.";
  const v = r.ledger, s = {
   newest:     `Its digest is the newest release on the colophon, from ${v.date}.`,
   earlier:    `Its digest is an earlier release on the colophon, from ${v.date}, ${num(v.below)} below the newest, so this site is serving an older build.`,
   unreleased: "The colophon shows it as the current build; it has no release line yet.",
   absent:     v.releases > 1 ? `Its digest isn't the colophon's current build or any of its ${num(v.releases)} releases.`
    : v.releases ? "Its digest isn't the colophon's current build or its one release."
    : "Its digest isn't the colophon's current build, and nothing has been released yet."}[v.kind];
  return v.buildDiffers && v.kind !== "absent" ? `${s} The colophon was built for a different manifest than the one served now.` : s }

 const glue = s => s.split(/(\d{4}-\d\d-\d\d|[\d,]+ bytes?)/).map((x, i) => i % 2 ? h("span", {className: "nowrap"}, x) : x);
 const link = p => h("a", {href: sitePath(p), className: "path"}, displayName(p));
 const li = r => h("li", {}, link(r.path), ": ", r.ok ? "OK" : word(r.status === "changed" ? "FAILED" : "FAILED open or read", "bad"));

 function cite(path) {
  const r = site.results.find(x => x.path === path), list = site.manifest, v = site.ledger;
  function row(s, hex, q, extra) {
   const label = h("p", {className: q ? "meta chain-label bad" : "meta chain-label"}, h("span", {}, ...glue(s)), extra);
   return h("li", {}, label, hex && ink(hex)) }
  const a = [
   row(`${displayName(path)} · ${r.actual ? formatBytes(r.size) : r.status === "missing" ? "not found" : "couldn't be read"}`, r.actual),
   row(!r.actual ? `≠ line ${r.line} of manifest.txt, with no bytes to compare it with` : r.ok ? `= line ${r.line} of manifest.txt`
    : `≠ line ${r.line} of manifest.txt gives a different digest`, r.digest, !r.ok),
   row(`manifest.txt, which holds that line · ${formatBytes(list.size)}`, list.hex, false,
    clip("Copy the SHA-256 of manifest.txt", () => list.hex, () => $("chain").children[2].querySelector("code")))];
  if (v) a.push(v.kind === "absent" ? row("≠ not on the colophon", "", true)
   : v.kind === "unreleased" ? row("= the colophon's current build", site.colophon.build)
   : row(`= the colophon's release of ${v.date}`, list.hex));
  $("chain").replaceChildren(...a);
  const same = sameBytes(site.results, path).map(displayName);
  $("chain-same").textContent = same.length ? `Same bytes as ${and(same)}.` : "" }
 $("chain-file").addEventListener("change", e => { cite(e.target.value) });

 function post(r) {
  site = r;
  if (r.moved) {
   $("check-report").hidden = true;
   return note("check-status", "manifest.txt changed while the check was running, so these results mix two versions of the site. Check again.", true) }
  const a = r.results.filter(x => !x.ok), n = r.results.length, s = book(r);
  const lead = a.length ? `${num(a.length)} of ${plural(n, "file")} ${a.length === 1 ? "doesn't" : "don't"} match manifest.txt.`
   : n === 1 ? "The one file it lists matches manifest.txt." : `All ${num(n)} files match manifest.txt.`;
  $("check-status").classList.remove("error");
  // a11y: with failures, the ledger sentence is spoken with the summary and shown below them, where it is aria-hidden
  $("check-status").replaceChildren(...glue(a.length ? lead : `${lead} ${s}`), a.length ? h("span", {className: "vh"}, ` ${s}`) : "");
  $("check-failures").replaceChildren(...a.map(li));
  $("check-ledger").replaceChildren(...(a.length ? glue(s) : []));
  const keep = $("chain-file").value, paths = r.results.map(x => x.path);
  $("chain-file").replaceChildren(...r.results.map(x => h("option", {value: x.path}, displayName(x.path))));
  $("chain-file").value = paths.includes(keep) ? keep : paths.includes("objects/sum/index.html") ? "objects/sum/index.html" : paths[0];
  cite($("chain-file").value);
  $("check-all").querySelector("summary").textContent = `all ${plural(n, "file")}`;
  $("check-all").querySelector("ol").replaceChildren(...r.results.map(li));
  $("check-report").hidden = false }

 $("check").addEventListener("click", async () => {
  if (lock) return;
  lock = true;
  $("check").setAttribute("aria-disabled", "true");
  $("check").firstElementChild.textContent = "Checking…";
  $("check-report").setAttribute("aria-busy", "true");
  let t = 0;
  try {
   post(await checkSite(grab, {
    onProgress(i, n) {
     if (!i) note("check-status", `Checking ${plural(n, "file")}.`);
     const now = performance.now();
     if (now - t < 100 && i < n) return;
     t = now;
     $("check-progress").textContent = `${num(i)} of ${plural(n, "file")}` } })) }
  catch (w) {
   $("check-report").hidden = true;
   note("check-status", w.message, true) }
  lock = false;
  $("check").removeAttribute("aria-disabled");
  $("check").firstElementChild.textContent = "Check again";
  $("check-progress").textContent = "";
  $("check-report").removeAttribute("aria-busy") });

 $("text-copy").addEventListener("click", e => { copy(e.currentTarget, text.hex, () => $("text-digest")) });
 // guard: a digest in the address, as #sha256:ba78…, fills "compare with" as parsed, never as the address's own text
 const frag = location.hash.slice(1);
 if (frag && frag.length <= 600) try { $("expected").value = digestText(parseDigest(decodeURIComponent(frag))); from = "the address" } catch {}
 pick(mode);
 if ($("expected").value) take() }