nixamp 0.24.1 → 0.25.0

package/src/main.ts

@@ -87,6 +87,7 @@ const HELP = `nixamp — it really whips the terminal's ass.
   nixamp transcribe FILE [--translate sv]  a recording or a whole film written down, kept, and in other languages
   nixamp transcript --channel ID [--follow]  what a channel is saying, as it says it; --kept for what nixamp.com keeps
   nixamp translate --to sv TEXT  say it in another language
+  nixamp hash FILE               one address for a file: nixamp.com/hash/<sha256>, with all that is known
   nixamp profile [--handle H] [--voice V] [--profile URL]  who the rooms know you as
   nixamp voices                  the voices a line is read in on the phone
   nixamp opendir list|add|remove  folders found on the web, published for everyone
@@ -274,9 +275,10 @@ posted straight into a trollbox), say a line in a room (trollbox_say), read
 a room (trollbox_read), read what a channel is saying (transcript_read, in
 any language). The transcript tools: a kept transcript by its id or its
 media (transcript_get), what this account has had written down
-(transcripts_list), and text in another language (translate_text). And who
-you are in the rooms and how you sound on the phone (profile_get,
-profile_set, voices_list). It acts as whoever this machine is signed in as,
+(transcripts_list), and text in another language (translate_text). The file
+tools: one address for a file (media_hash) and what nixamp.com knows about
+one (media_get). And who you are in the rooms and how you sound on the
+phone (profile_get, profile_set, voices_list). It acts as whoever this machine is signed in as,
 so \`nixamp login\` (or NIXAMP_TOKEN) comes first.
 
 Point an MCP client at it as a stdio server running \`nixamp mcp\`. The same
@@ -309,6 +311,23 @@ with an open-source model (OPUS-MT), and kept beside the original.
 
 The same ear is behind the microphone button in every nixamp.com trollbox,
 and behind the transcribe_audio tool of \`nixamp mcp\`.
+`,
+  hash: `nixamp hash — one address for a file.
+
+  nixamp hash FILE [FILE...]        sha256, and nixamp.com/hash/<sha256>, kept there with what is known
+  nixamp hash FILE --no-keep        the hash and the address only; nothing sent
+  nixamp hash FILE --json           the record as nixamp.com keeps it
+  nixamp hash --get ID              what nixamp.com knows about a file, by hash or fingerprint
+
+The address is the SHA-256 of the file's bytes, the way OpenFile
+(logicsrc.com/docs/openfile) names a file, so the same file on two machines
+is one page. The page, and /hash/<id>.openfile.json beside it, carry the
+size, the type, when the file last changed, what ffprobe found inside, what
+nichedb.dev says it is, which servers have carried it, and its transcripts
+in every language, as .srt, .vtt or text. \`nixamp transcribe\` and a server
+captioning a file keep the same record. The daemon looks at a kept file
+again on a schedule set by how recently it changed, and a changed file
+gets a new address that points back at the old one.
 `,
   translate: `nixamp translate — say it in another language.
 
@@ -588,6 +607,11 @@ export async function main(): Promise<void> {
     process.exitCode = await translate(rest);
     return;
   }
+  if (first === "hash") {
+    const { hash } = await import("./hash.ts");
+    process.exitCode = await hash(rest);
+    return;
+  }
   if (first === "token" || first === "tokens") {
     const { tokens } = await import("./session.ts");
     process.exitCode = await tokens(rest);

package/src/mcp.ts

@@ -23,7 +23,11 @@ import { clock, type PartyRow } from "./party.ts";
 import { readSession } from "./session.ts";
 import { askToHear, awaitTranscript, hearWhole, rendered, wavOf, type Window } from "./transcribe.ts";
 import { readTranscript } from "./transcript.ts";
-import { fetchTranscript, listTranscripts, translateTexts, type StoredTranscript } from "./transcript-client.ts";
+import { fetchMedia, fetchTranscript, listTranscripts, translateTexts, type StoredTranscript } from "./transcript-client.ts";
+import { detectTools } from "./audio.ts";
+import { Enricher } from "./enrich.ts";
+import { describeRecord } from "./hash.ts";
+import { describeFile, keepFile, type Described } from "./media-local.ts";
 import { fileFingerprint, idFrom, languageCode, mediaOfUrl, transcriptIdOf } from "./transcripts.ts";
 import { personaLines, readPersona, readVoices, writePersona } from "./profile.ts";
 
@@ -134,6 +138,24 @@ export const TOOLS: ToolDefinition[] = [
       required: ["media"],
     },
   },
+  {
+    name: "media_hash",
+    description:
+      "One address for a file on this machine: its SHA-256 and nixamp.com/hash/<sha256>, kept there with what this machine knows (size, type, when it changed, what is inside, what nichedb says it is). The same file anywhere is the same page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { ...STRING, description: "The file's path on this machine." },
+        keep: { type: "boolean", description: "Tell nixamp.com about it (default true)." },
+      },
+      required: ["path"],
+    },
+  },
+  {
+    name: "media_get",
+    description: "What nixamp.com knows about a file, by its SHA-256 (with or without sha256:), its transcript fingerprint, or a transcript id: the OpenFile record with nixamp's facts, holders and transcripts.",
+    inputSchema: { type: "object", properties: { id: { ...STRING, description: "The hash, fingerprint or transcript id." } }, required: ["id"] },
+  },
   {
     name: "transcripts_list",
     description: "What this account has had written down on nixamp.com: each transcript's id, what it is, its language, how many lines, and when.",
@@ -245,6 +267,8 @@ export interface McpOptions {
   sleep?: (ms: number) => Promise<void>;
   /** How many times a translation is asked about before answering with its progress. */
   polls?: number;
+  /** How a file is described for its record; the tests hand in a fake. */
+  describe?: (path: string) => Promise<Described>;
   say?: (line: string) => void;
 }
 
@@ -439,6 +463,30 @@ export async function callTool(name: string, args: Record<string, unknown>, opti
       return text(transcriptText(got.body, typeof args["format"] === "string" ? args["format"] : "lines"));
     }
 
+    if (name === "media_hash") {
+      const path = typeof args["path"] === "string" ? args["path"] : "";
+      if (!path) return failed("Which file? Pass its path.");
+      let described: Described;
+      try {
+        described = await (options.describe ?? ((file: string) => describeFile(file, { tools: detectTools(), enricher: new Enricher() })))(path);
+      } catch (error) {
+        return failed(`${path}: ${(error as Error).message}`);
+      }
+      if (args["keep"] !== false) {
+        const refused = await keepFile({ site, token: session.token }, path, described, { fetcher: send });
+        if (refused) return failed(`hashed, but not kept: ${refused}`);
+      }
+      return text(`sha256:${described.id}\n${site}/hash/${described.id}${args["keep"] === false ? "\n(not kept)" : ""}`);
+    }
+
+    if (name === "media_get") {
+      const id = typeof args["id"] === "string" ? args["id"].trim() : "";
+      if (!id) return failed("Which file? Pass its hash, fingerprint or transcript id.");
+      const got = await fetchMedia(site, id, send);
+      if (!got.ok) return failed(got.error);
+      return text(describeRecord(got.body));
+    }
+
     if (name === "transcripts_list") {
       const got = await listTranscripts({ site, token: session.token }, send);
       if (!got.ok) return failed(got.error);

package/src/media-index.ts

@@ -0,0 +1,145 @@
+/**
+ * The files this machine has told nixamp.com about, and when to look again.
+ *
+ * nixamp.com keeps the record (media.ts); the bytes stay here. So whether a
+ * file has changed is a question only this machine can answer, and it
+ * answers it on a schedule that follows the file: a quarter of the time
+ * since it last changed, never more often than every quarter of an hour
+ * and never less often than monthly (see checkInterval). Looking is one
+ * stat. Only a file whose size or modification time moved is hashed
+ * again, and a new hash is a new record on nixamp.com, with the old one
+ * told what it became.
+ *
+ * The index is a JSON file beside the daemon's other state. The CLI adds
+ * to it when it hashes or transcribes a file, the server when it captions
+ * one, and the server's watcher reads it every few minutes for what is
+ * due. Written whole and renamed into place, so two of them writing at
+ * once lose an entry at worst, never the file.
+ */
+import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { stateDir } from "./daemon.ts";
+import { checkInterval } from "./media.ts";
+
+export interface IndexedFile {
+  /** The SHA-256 hex nixamp.com knows it by. */
+  id: string;
+  fingerprint: string;
+  size: number;
+  mtimeMs: number;
+  checkedAt: number;
+  checkAfter: number;
+}
+
+export interface IndexFile {
+  version: 1;
+  files: Record<string, IndexedFile>;
+}
+
+export function indexPath(): string {
+  return process.env["NIXAMP_MEDIA_INDEX"] ?? join(stateDir(), "media.json");
+}
+
+export function readIndex(path = indexPath()): IndexFile {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as Partial<IndexFile>;
+    if (parsed && parsed.version === 1 && parsed.files && typeof parsed.files === "object") return { version: 1, files: parsed.files };
+  } catch {
+    // No index yet, or one this cannot read: start again.
+  }
+  return { version: 1, files: {} };
+}
+
+export function writeIndex(index: IndexFile, path = indexPath()): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, JSON.stringify(index, null, 2));
+  renameSync(temp, path);
+}
+
+/** Note a file this machine has told nixamp.com about, with when to look at it next. */
+export function remember(file: string, entry: { id: string; fingerprint: string; size: number; mtimeMs: number }, now = Date.now(), path = indexPath()): IndexedFile {
+  const index = readIndex(path);
+  const kept: IndexedFile = { ...entry, checkedAt: now, checkAfter: now + checkInterval(entry.mtimeMs, now) };
+  index.files[file] = kept;
+  writeIndex(index, path);
+  return kept;
+}
+
+/** The files whose turn it is. */
+export function due(index: IndexFile, now = Date.now()): string[] {
+  return Object.entries(index.files).filter(([, one]) => one.checkAfter <= now).map(([file]) => file);
+}
+
+export type Looked =
+  | { state: "same"; entry: IndexedFile }
+  | { state: "changed"; entry: IndexedFile; size: number; mtimeMs: number }
+  | { state: "gone" };
+
+/**
+ * One look at a file: the same as it was, changed, or gone. Nothing is
+ * hashed here; the caller hashes a changed file, since that is the part
+ * that costs, and then remembers the new record.
+ */
+export function look(file: string, entry: IndexedFile, now = Date.now()): Looked {
+  let stat: { size: number; mtimeMs: number };
+  try {
+    stat = statSync(file);
+  } catch {
+    return { state: "gone" };
+  }
+  if (stat.size === entry.size && Math.floor(stat.mtimeMs) === Math.floor(entry.mtimeMs)) {
+    return { state: "same", entry: { ...entry, checkedAt: now, checkAfter: now + checkInterval(entry.mtimeMs, now) } };
+  }
+  return { state: "changed", entry, size: stat.size, mtimeMs: stat.mtimeMs };
+}
+
+/** How often the watcher reads the index for what is due. */
+export const WATCH_EVERY_MS = 10 * 60 * 1000;
+
+export interface WatchOptions {
+  path?: string;
+  now?: () => number;
+  /** Hash the changed file, tell nixamp.com, and answer the new entry; null when it could not. */
+  refresh: (file: string, before: IndexedFile, stat: { size: number; mtimeMs: number }) => Promise<{ id: string; fingerprint: string } | null>;
+  onEvent?: (message: string) => void;
+}
+
+/**
+ * One pass over what is due. Files that are the same are pushed out to
+ * their next check; changed ones are refreshed; gone ones are forgotten.
+ * Answers how many of each, for the log.
+ */
+export async function watchOnce(options: WatchOptions): Promise<{ same: number; changed: number; gone: number }> {
+  const now = options.now ?? Date.now;
+  const path = options.path ?? indexPath();
+  const index = readIndex(path);
+  const counts = { same: 0, changed: 0, gone: 0 };
+  for (const file of due(index, now())) {
+    const entry = index.files[file];
+    if (!entry) continue;
+    const looked = look(file, entry, now());
+    if (looked.state === "gone") {
+      delete index.files[file];
+      counts.gone += 1;
+      continue;
+    }
+    if (looked.state === "same") {
+      index.files[file] = looked.entry;
+      counts.same += 1;
+      continue;
+    }
+    const fresh = await options.refresh(file, entry, { size: looked.size, mtimeMs: looked.mtimeMs });
+    const at = now();
+    if (fresh) {
+      index.files[file] = { ...fresh, size: looked.size, mtimeMs: looked.mtimeMs, checkedAt: at, checkAfter: at + checkInterval(looked.mtimeMs, at) };
+      counts.changed += 1;
+      options.onEvent?.(`${file} changed: now sha256:${fresh.id.slice(0, 12)} (was ${entry.id.slice(0, 12)})`);
+    } else {
+      // Could not say; ask again in a quarter of an hour rather than never.
+      index.files[file] = { ...entry, checkedAt: at, checkAfter: at + 15 * 60 * 1000 };
+    }
+  }
+  writeIndex(index, path);
+  return counts;
+}

package/src/media-local.ts

@@ -0,0 +1,117 @@
+/**
+ * A file on this machine, described for nixamp.com's record of it.
+ *
+ * The same few steps whoever meets the file: hash every byte (the OpenFile
+ * id), take the quick fingerprint (the transcript key), ask ffprobe what is
+ * inside, ask nichedb what it is, note where it is being carried, and say
+ * when this machine will look at it again. `nixamp hash` does it for a
+ * file you name, `nixamp transcribe` for the one it is writing down, and a
+ * server for a file it puts on the air. A file that changed since the
+ * machine last looked is described again as a new record, and the two
+ * records point at each other.
+ */
+import { basename, extname } from "node:path";
+import { codecsOf, type Tools } from "./audio.ts";
+import type { Enricher } from "./enrich.ts";
+import { checkInterval, contentHash, factsFrom, fileFacts, type Holder, type MediaFacts } from "./media.ts";
+import { remember, type IndexedFile } from "./media-index.ts";
+import { keepMedia, type MediaToKeep, type Signed } from "./transcript-client.ts";
+import { fileFingerprint } from "./transcripts.ts";
+
+export interface Described {
+  id: string;
+  fingerprint: string;
+  size: number;
+  mtimeMs: number;
+  keep: MediaToKeep;
+}
+
+export interface DescribeDeps {
+  /** ffprobe, for what is inside. Absent: only what the filesystem says. */
+  tools?: Tools | null;
+  enricher?: Pick<Enricher, "lookup"> | null;
+  holder?: Holder | null;
+  now?: () => number;
+  /** The tests hand in fakes for the two things that cost. */
+  hash?: (path: string) => Promise<string>;
+  fingerprint?: (path: string) => string;
+}
+
+/** Everything this machine can say about a file, ready to keep. */
+export async function describeFile(path: string, deps: DescribeDeps = {}): Promise<Described> {
+  const now = deps.now ?? Date.now;
+  const file = fileFacts(path);
+  const id = await (deps.hash ?? contentHash)(path);
+  const fingerprint = (deps.fingerprint ?? fileFingerprint)(path);
+  const codecs = deps.tools && deps.tools.carries !== false ? await codecsOf(deps.tools, path) : null;
+  const name = codecs?.tags?.title || basename(path, extname(path));
+  let enriched = null;
+  try {
+    enriched = deps.enricher ? await deps.enricher.lookup(name) : null;
+  } catch {
+    enriched = null;
+  }
+  const at = now();
+  const facts: MediaFacts = {
+    ...factsFrom(codecs, enriched),
+    fingerprint,
+    checkedAt: new Date(at).toISOString(),
+    checkAfter: new Date(at + checkInterval(file.mtimeMs, at)).toISOString(),
+  };
+  return {
+    id,
+    fingerprint,
+    size: file.size,
+    mtimeMs: file.mtimeMs,
+    keep: {
+      name: file.name,
+      size: file.size,
+      contentType: file.contentType,
+      updated: file.updated,
+      facts: facts as Record<string, unknown>,
+      ...(deps.holder ? { holder: deps.holder } : {}),
+    },
+  };
+}
+
+/** Keep a described file on nixamp.com and in this machine's index. Answers the store's sentence when it refused. */
+export async function keepFile(
+  signed: Signed,
+  path: string,
+  described: Described,
+  deps: { fetcher?: typeof fetch; index?: string; now?: () => number } = {},
+): Promise<string | null> {
+  const got = await keepMedia(signed, described.id, described.keep, deps.fetcher ?? fetch);
+  if (!got.ok) return got.error;
+  try {
+    remember(path, { id: described.id, fingerprint: described.fingerprint, size: described.size, mtimeMs: described.mtimeMs }, (deps.now ?? Date.now)(), deps.index);
+  } catch {
+    // The index is a convenience; the record is what matters.
+  }
+  return null;
+}
+
+/**
+ * A file that changed since it was last described: described again as a
+ * new record that says what it was, while the old record says what it
+ * became. Answers the new identity, or null when nixamp.com would not
+ * keep it.
+ */
+export async function refreshChanged(
+  signed: Signed,
+  path: string,
+  before: Pick<IndexedFile, "id">,
+  deps: DescribeDeps & { fetcher?: typeof fetch; index?: string } = {},
+): Promise<{ id: string; fingerprint: string } | null> {
+  const described = await describeFile(path, deps);
+  if (described.id === before.id) {
+    // Touched but not changed: the same bytes, a new modification time.
+    const failed = await keepFile(signed, path, described, deps);
+    return failed ? null : { id: described.id, fingerprint: described.fingerprint };
+  }
+  described.keep.facts = { ...(described.keep.facts ?? {}), supersedes: `sha256:${before.id}` };
+  const failed = await keepFile(signed, path, described, deps);
+  if (failed) return null;
+  await keepMedia(signed, before.id, { facts: { supersededBy: `sha256:${described.id}` } }, deps.fetcher ?? fetch);
+  return { id: described.id, fingerprint: described.fingerprint };
+}

package/src/media-page.ts

@@ -0,0 +1,159 @@
+/**
+ * nixamp.com/hash/<id>, as a page: everything nixamp knows about one file,
+ * for a person with a browser. The same facts as the OpenFile descriptor
+ * beside it, laid out: what it is, how long, what is inside, who said what
+ * it was, where it has been carried, and the transcript in every language
+ * it has been written down in, with subtitle files to take away.
+ *
+ * Rendered on the server from a string, with the terminal's look, so a
+ * crawler and a link preview read it and nothing has to load first.
+ */
+import type { MediaRecord, TranscriptRef } from "./media.ts";
+import type { TranscriptLine } from "./transcripts.ts";
+
+function esc(text: string): string {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+function bytes(size: number): string {
+  if (size >= 1024 ** 3) return `${(size / 1024 ** 3).toFixed(2)} GB`;
+  if (size >= 1024 ** 2) return `${(size / 1024 ** 2).toFixed(1)} MB`;
+  if (size >= 1024) return `${(size / 1024).toFixed(0)} KB`;
+  return `${size} B`;
+}
+
+function clock(seconds: number): string {
+  const whole = Math.max(0, Math.floor(seconds));
+  const h = Math.floor(whole / 3600);
+  const m = Math.floor((whole % 3600) / 60);
+  const s = whole % 60;
+  return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` : `${m}:${String(s).padStart(2, "0")}`;
+}
+
+function when(iso: string): string {
+  return iso ? esc(iso.replace("T", " ").replace(/\.\d+Z$/, " UTC")) : "";
+}
+
+const STYLE = `
+  :root { color-scheme: dark; --bg:#080c09; --panel:#0c120e; --edge:#1d2c22; --green:#4af689; --dim:#227a4a; --fg:#cfe8d8; --muted:#6d8a79; --accent:#7ef0c4; }
+  * { box-sizing: border-box; }
+  body { margin:0; background:var(--bg); color:var(--fg); font:14px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
+  main { max-width: 960px; margin: 0 auto; padding: 20px 16px 48px; }
+  a { color: var(--accent); }
+  .brand { color: var(--green); font-weight: 700; letter-spacing: .14em; text-decoration: none; }
+  h1 { font-size: 20px; margin: 18px 0 4px; color: var(--green); overflow-wrap: anywhere; }
+  .id { color: var(--muted); font-size: 12px; overflow-wrap: anywhere; }
+  .panel { position: relative; border: 1px solid var(--edge); border-radius: 6px; background: var(--panel); padding: 18px 12px 12px; margin-top: 16px; }
+  .panel::before { content: attr(data-title); position: absolute; top: -9px; left: 10px; padding: 0 6px; background: var(--panel); color: var(--dim); font-size: 12px; letter-spacing: .06em; }
+  table { border-collapse: collapse; width: 100%; }
+  td { padding: 3px 8px 3px 0; vertical-align: top; overflow-wrap: anywhere; }
+  td:first-child { color: var(--muted); white-space: nowrap; width: 11em; }
+  .poster { float: right; max-width: 160px; margin: 0 0 8px 12px; border: 1px solid var(--edge); border-radius: 4px; }
+  ul { margin: 0; padding-left: 1.2em; }
+  .lines { list-style: none; padding: 0; max-height: 420px; overflow-y: auto; font-size: 13px; }
+  .lines li { display: flex; gap: 8px; padding: 2px 0; border-bottom: 1px dotted var(--edge); }
+  .lines .t { color: var(--muted); flex: 0 0 auto; }
+  .chips a { display: inline-block; margin: 0 8px 6px 0; border: 1px solid var(--edge); border-radius: 999px; padding: 1px 10px; font-size: 12px; text-decoration: none; }
+  .muted { color: var(--muted); }
+  pre { white-space: pre-wrap; overflow-wrap: anywhere; color: var(--muted); font-size: 12px; }
+`;
+
+export interface PageTranscript extends TranscriptRef {
+  /** The lines themselves, for the one transcript the page shows. */
+  shown?: TranscriptLine[];
+}
+
+/** The page, whole. `transcripts[0]` carries the lines shown; the rest are offered as files. */
+export function mediaPage(record: MediaRecord, site: string, transcripts: PageTranscript[] = []): string {
+  const base = site.replace(/\/+$/, "");
+  const f = record.facts;
+  const title = f.enrichment?.title || f.tags?.title || record.name || record.id.slice(0, 12);
+  const picture = f.enrichment?.image ?? null;
+  const url = `${base}/hash/${record.id}`;
+  const summary = f.enrichment?.summary ?? "";
+  const description = summary || `${record.name}${f.duration ? `, ${clock(f.duration)}` : ""}${transcripts.length > 0 ? `, transcribed in ${transcripts.map((one) => one.language || "its own language").join(", ")}` : ""}`;
+
+  const rows: [string, string][] = [];
+  if (record.name) rows.push(["File", esc(record.name)]);
+  if (record.size) rows.push(["Size", bytes(record.size)]);
+  if (record.contentType) rows.push(["Type", esc(record.contentType)]);
+  if (f.duration) rows.push(["Length", clock(f.duration)]);
+  if (f.width && f.height) rows.push(["Picture", `${f.width}×${f.height}`]);
+  if (f.codecs) rows.push(["Inside", esc([f.codecs.video, f.codecs.audio, f.codecs.container].filter(Boolean).join(" / "))]);
+  if (f.tags?.artist || f.tags?.album) rows.push(["Tagged", esc([f.tags.artist, f.tags.album].filter(Boolean).join(" · "))]);
+  if (record.updated) rows.push(["File changed", when(record.updated)]);
+  if (f.checkedAt) rows.push(["Last checked", `${when(f.checkedAt)}${f.checkAfter ? `, next ${when(f.checkAfter)}` : ""}`]);
+  if (f.fingerprint) rows.push(["Fingerprint", `<span class="id">${esc(f.fingerprint)}</span>`]);
+  if (f.supersedes) rows.push(["Was", `<a href="${base}/hash/${esc(f.supersedes.replace(/^sha256:/, ""))}">${esc(f.supersedes)}</a>`]);
+  if (f.supersededBy) rows.push(["Became", `<a href="${base}/hash/${esc(f.supersededBy.replace(/^sha256:/, ""))}">${esc(f.supersededBy)}</a>`]);
+  rows.push(["Kept", `${when(record.createdAt)}${record.updatedAt !== record.createdAt ? `, last added to ${when(record.updatedAt)}` : ""}`]);
+
+  const enrichment = f.enrichment
+    ? `<section class="panel" data-title="What nichedb says it is">
+      ${picture ? `<img class="poster" src="${esc(picture)}" alt="" />` : ""}
+      <table>
+        <tr><td>Title</td><td>${esc(f.enrichment.title ?? "")}${f.enrichment.year ? ` (${f.enrichment.year})` : ""}</td></tr>
+        ${f.enrichment.kind ? `<tr><td>Kind</td><td>${esc(f.enrichment.kind)}</td></tr>` : ""}
+        ${summary ? `<tr><td>About</td><td>${esc(summary)}</td></tr>` : ""}
+        ${f.enrichment.page ? `<tr><td>Page</td><td><a href="${esc(f.enrichment.page)}">${esc(f.enrichment.page)}</a></td></tr>` : ""}
+      </table>
+    </section>`
+    : "";
+
+  const holders = record.holders.length > 0
+    ? `<section class="panel" data-title="Carried by">
+      <ul>${record.holders.map((h) => `<li><a href="${esc(h.url)}">${esc(h.name || h.url)}</a>${h.channel ? ` as <code>${esc(h.channel)}</code>` : ""} <span class="muted">${when(h.seenAt)}</span></li>`).join("")}</ul>
+    </section>`
+    : "";
+
+  const shown = transcripts[0];
+  const transcript = transcripts.length > 0
+    ? `<section class="panel" data-title="Transcript">
+      <p class="chips">${transcripts.map((one) => {
+        const q = one.language ? `?language=${esc(one.language)}` : "";
+        return `<a href="${url}.srt${q}">${esc(one.language || "as spoken")}${one.translatedFrom ? ` (from ${esc(one.translatedFrom)})` : ""} · ${one.lines} lines${one.complete ? "" : " so far"} · SRT</a> <a href="${url}.vtt${q}">VTT</a> <a href="${url}.txt${q}">text</a>`;
+      }).join("<br />")}</p>
+      ${shown?.shown && shown.shown.length > 0
+        ? `<ul class="lines">${shown.shown.map((line) => `<li><span class="t">${clock(line.start)}</span><span>${esc(line.text)}</span></li>`).join("")}</ul>`
+        : ""}
+    </section>`
+    : `<section class="panel" data-title="Transcript"><p class="muted">Not written down yet. <code>nixamp transcribe FILE</code> keeps it here, and a server captioning it does too.</p></section>`;
+
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${esc(title)} · nixamp</title>
+<meta name="description" content="${esc(description.slice(0, 300))}" />
+<link rel="canonical" href="${url}" />
+<link rel="openfile" href="${url}.openfile.json" />
+<link rel="alternate" type="application/json" href="${url}.json" />
+<meta property="og:title" content="${esc(title)}" />
+<meta property="og:description" content="${esc(description.slice(0, 300))}" />
+<meta property="og:url" content="${url}" />
+<meta property="og:type" content="${record.contentType.startsWith("video/") ? "video.other" : record.contentType.startsWith("audio/") ? "music.song" : "website"}" />
+${picture ? `<meta property="og:image" content="${esc(picture)}" />` : ""}
+<style>${STYLE}</style>
+</head>
+<body>
+<main>
+  <a class="brand" href="${base}/">NIXAMP</a>
+  <h1>${esc(title)}</h1>
+  <div class="id">sha256:${esc(record.id)}</div>
+  <section class="panel" data-title="The file">
+    <table>${rows.map(([k, v]) => `<tr><td>${k}</td><td>${v}</td></tr>`).join("")}</table>
+  </section>
+  ${enrichment}
+  ${holders}
+  ${transcript}
+  <section class="panel" data-title="For a program">
+    <p class="muted">This page as <a href="${url}.openfile.json">OpenFile</a> (<a href="https://logicsrc.com/docs/openfile">the specification</a>) or <a href="${url}.json">JSON</a>. Every file nixamp.com knows: <a href="${base}/.well-known/openfile.json">/.well-known/openfile.json</a>.</p>
+    <pre>nixamp hash FILE            the same address for a file of yours
+nixamp transcribe FILE      and its transcript, kept here</pre>
+  </section>
+</main>
+</body>
+</html>
+`;
+}