nixamp 0.23.7 → 0.24.0

package/dist/transcripts.js

@@ -0,0 +1,384 @@
+/**
+ * Transcripts, kept: what a file, a link or a live said, written down once.
+ *
+ * Hearing costs a CPU for as long as the sound lasts, and a film heard on
+ * Tuesday says the same words on Thursday. So what the ear hears is kept
+ * here, on nixamp.com, under an identity of the media rather than of the
+ * channel that happened to be playing it: a file is its fingerprint, a
+ * link is its address, and a live is the one broadcast it was. The next
+ * captioner to meet the same media reads the lines instead of hearing
+ * them, and a translation is done once and kept beside the original.
+ *
+ * Lines are seconds into the media, not wall-clock moments. A captioner
+ * turns its wall-clock stamps into offsets from the channel's start on the
+ * way in, and back on the way out, so a transcript of a file means the
+ * same thing whichever server plays it.
+ *
+ * One row per (media, language). The original is the row translated from
+ * nothing; a translation says which language it came from. A row grows by
+ * appending: a live is captioned as it happens and a file may be heard in
+ * pieces, on different days, by different servers. A whole-media pass --
+ * `nixamp transcribe FILE` -- replaces the pieces with the whole and marks
+ * the row complete, after which nothing partial touches it again.
+ */
+import { createHash } from "node:crypto";
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+/** A row grows no further than this; a day of talk is under half of it. */
+export const MAX_LINES = 20_000;
+/** A line longer than this is not a line. */
+export const MAX_LINE_CHARS = 2000;
+/** How much of a file's bytes go into its fingerprint, at each end. */
+export const FINGERPRINT_BYTES = 1024 * 1024;
+// --- identity ----------------------------------------------------------------
+/**
+ * A file's identity from its size and a megabyte at each end. Hashing every
+ * byte of a film takes seconds a captioner does not have at start, and the
+ * ends plus the size tell two files apart as surely as anything short of
+ * the whole does. The v1 says how it was made, so a better way later does
+ * not collide with this one.
+ */
+export function fileFingerprint(path) {
+    const size = statSync(path).size;
+    const hash = createHash("sha256");
+    const sizeBytes = Buffer.alloc(8);
+    sizeBytes.writeBigUInt64LE(BigInt(size));
+    hash.update(sizeBytes);
+    const fd = openSync(path, "r");
+    try {
+        const head = Buffer.alloc(Math.min(FINGERPRINT_BYTES, size));
+        readSync(fd, head, 0, head.length, 0);
+        hash.update(head);
+        if (size > FINGERPRINT_BYTES) {
+            const tail = Buffer.alloc(Math.min(FINGERPRINT_BYTES, size - FINGERPRINT_BYTES));
+            readSync(fd, tail, 0, tail.length, size - tail.length);
+            hash.update(tail);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    return `file:v1:${hash.digest("hex")}`;
+}
+/** A link's identity: the address without its fragment, which no server sees. */
+export function mediaOfUrl(url) {
+    const trimmed = url.trim();
+    try {
+        const parsed = new URL(trimmed);
+        parsed.hash = "";
+        return `url:${parsed.toString()}`;
+    }
+    catch {
+        return `url:${trimmed}`;
+    }
+}
+/** A broadcast's identity: the server, the channel, and when it began, so a second airing is a second transcript. */
+export function mediaOfLive(server, channel, startedAt) {
+    let host = server.trim().replace(/\/+$/, "");
+    try {
+        // A bare host:port parses as a scheme and a path; give it one first.
+        host = new URL(host.includes("://") ? host : `https://${host}`).host;
+    }
+    catch {
+        host = host.replace(/^https?:\/\//, "");
+    }
+    return `live:${host}/${channel}@${Math.floor(startedAt)}`;
+}
+export function kindOf(media) {
+    if (media.startsWith("file:"))
+        return "file";
+    if (media.startsWith("live:"))
+        return "live";
+    return "url";
+}
+/** The id a transcript is addressed by: a hash, so a link with a key in it is not in the address bar. */
+export function transcriptIdOf(media) {
+    return createHash("sha256").update(media).digest("hex");
+}
+/** A transcript id as a request names one, or null when it is not one. */
+export function transcriptId(value) {
+    return typeof value === "string" && /^[0-9a-f]{64}$/.test(value) ? value : null;
+}
+/** Either the id itself or a media identity, as a route accepts both. */
+export function idFrom(value) {
+    return transcriptId(value) ?? transcriptIdOf(value);
+}
+// --- lines -------------------------------------------------------------------
+/** Lines as a request or a row hands them in: only the well-formed ones, tidied. */
+export function linesFrom(value) {
+    let parsed = value;
+    if (typeof value === "string") {
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const lines = [];
+    for (const one of parsed) {
+        if (!one || typeof one !== "object")
+            continue;
+        const { start, end, text } = one;
+        if (typeof text !== "string" || typeof start !== "number" || !Number.isFinite(start) || start < 0)
+            continue;
+        const words = text.replace(/\s+/g, " ").trim().slice(0, MAX_LINE_CHARS);
+        if (words === "")
+            continue;
+        const until = typeof end === "number" && Number.isFinite(end) && end > start ? end : start;
+        lines.push({ start: round(start), end: round(until), text: words });
+    }
+    return lines;
+}
+function round(seconds) {
+    return Math.round(seconds * 1000) / 1000;
+}
+/**
+ * Lines in order, with the duplicates gone. Two servers playing one file
+ * both append what they heard, a captioner that restarted hears a window
+ * again: the second copy of a moment says the same thing, later, and a
+ * viewer would read it twice. A line whose span mostly overlaps one already
+ * kept is that second copy.
+ */
+export function mergeLines(lines) {
+    const sorted = [...lines].sort((a, b) => a.start - b.start || a.end - b.end);
+    const kept = [];
+    for (const line of sorted) {
+        const last = kept[kept.length - 1];
+        if (last && overlaps(last, line)) {
+            // The same moment twice: keep the longer account of it.
+            if (line.text.length > last.text.length && Math.abs(line.start - last.start) < 1)
+                kept[kept.length - 1] = line;
+            continue;
+        }
+        kept.push(line);
+    }
+    return kept;
+}
+function overlaps(a, b) {
+    const shorter = Math.min(a.end - a.start, b.end - b.start);
+    const shared = Math.min(a.end, b.end) - Math.max(a.start, b.start);
+    if (shorter <= 0)
+        return Math.abs(a.start - b.start) < 0.5;
+    return shared > shorter * 0.6;
+}
+/** Whether the kept lines already say what this span says: over half of it is covered. */
+export function covered(lines, start, end) {
+    const span = end - start;
+    if (span <= 0)
+        return [];
+    const inside = lines.filter((line) => Math.min(line.end, end) - Math.max(line.start, start) > 0);
+    const shared = inside.reduce((sum, line) => sum + (Math.min(line.end, end) - Math.max(line.start, start)), 0);
+    return shared > span / 2 ? inside : [];
+}
+/** The line for a moment, if there is one: the one that begins nearest, within a second. */
+export function lineAt(lines, start) {
+    let nearest = null;
+    for (const line of lines) {
+        const off = Math.abs(line.start - start);
+        if (off <= 1 && (nearest === null || off < Math.abs(nearest.start - start)))
+            nearest = line;
+    }
+    return nearest;
+}
+/** How far the lines reach, seconds. */
+export function reach(lines) {
+    return lines.reduce((most, line) => Math.max(most, line.end), 0);
+}
+// --- formats -----------------------------------------------------------------
+/** Seconds as a subtitle clock: 01:02:03,456 for SRT, 01:02:03.456 for VTT. */
+export function stamp(seconds, separator = ",") {
+    const whole = Math.max(0, Math.floor(seconds));
+    const ms = Math.max(0, Math.round((seconds - whole) * 1000));
+    const two = (n) => String(n).padStart(2, "0");
+    return `${two(Math.floor(whole / 3600))}:${two(Math.floor((whole % 3600) / 60))}:${two(whole % 60)}${separator}${String(ms).padStart(3, "0")}`;
+}
+export function toSrt(lines) {
+    return lines
+        .map((line, i) => `${i + 1}\n${stamp(line.start)} --> ${stamp(Math.max(line.end, line.start + 0.5))}\n${line.text}\n`)
+        .join("\n");
+}
+export function toVtt(lines) {
+    const cues = lines.map((line) => `${stamp(line.start, ".")} --> ${stamp(Math.max(line.end, line.start + 0.5), ".")}\n${line.text}\n`);
+    return `WEBVTT\n\n${cues.join("\n")}`;
+}
+/** The words alone, one line each, as a person reads them. */
+export function toText(lines) {
+    return lines.map((line) => line.text).join("\n");
+}
+export function formatOf(value) {
+    if (value === null || value === undefined || value === "")
+        return "json";
+    return value === "json" || value === "srt" || value === "vtt" || value === "txt" ? value : null;
+}
+/** A two-letter language, or "" for none; null when the value is something else. */
+export function languageCode(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value !== "string")
+        return null;
+    const code = value.trim().toLowerCase();
+    if (code === "" || code === "original")
+        return "";
+    return /^[a-z]{2}$/.test(code) ? code : null;
+}
+// --- the store ---------------------------------------------------------------
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS transcripts (
+    id               TEXT NOT NULL,
+    language         TEXT NOT NULL DEFAULT '',
+    media            TEXT NOT NULL,
+    kind             TEXT NOT NULL DEFAULT 'url',
+    translated_from  TEXT,
+    model            TEXT NOT NULL DEFAULT '',
+    complete         BOOLEAN NOT NULL DEFAULT false,
+    title            TEXT NOT NULL DEFAULT '',
+    by_account       TEXT NOT NULL DEFAULT '',
+    seconds          DOUBLE PRECISION NOT NULL DEFAULT 0,
+    lines            JSONB NOT NULL DEFAULT '[]'::jsonb,
+    created_at       TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at       TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (id, language)
+  );
+  CREATE INDEX IF NOT EXISTS transcripts_by_account ON transcripts (by_account, updated_at DESC);
+`;
+export class Transcripts {
+    db;
+    onEvent;
+    ready = null;
+    constructor(db, onEvent = () => { }) {
+        this.db = db;
+        this.onEvent = onEvent;
+    }
+    async ensure() {
+        this.ready ??= this.db.query(SCHEMA).then(() => undefined);
+        await this.ready;
+    }
+    /**
+     * Keep lines. New media is a new row; known media grows by these lines,
+     * unless the row is already whole -- then pieces are nothing it needs --
+     * or these lines are the whole, which replaces whatever pieces there
+     * were. Answers the row as it now stands.
+     */
+    async save(ask) {
+        const lines = mergeLines(linesFrom(ask.lines)).slice(0, MAX_LINES);
+        const id = transcriptIdOf(ask.media);
+        const complete = ask.complete === true;
+        await this.ensure();
+        const { rows } = await this.db.query(`INSERT INTO transcripts (id, language, media, kind, translated_from, model, complete, title, by_account, seconds, lines)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11::jsonb)
+       ON CONFLICT (id, language) DO UPDATE SET
+         lines = CASE
+           WHEN EXCLUDED.complete THEN EXCLUDED.lines
+           WHEN transcripts.complete THEN transcripts.lines
+           WHEN jsonb_array_length(transcripts.lines) >= $12 THEN transcripts.lines
+           ELSE transcripts.lines || EXCLUDED.lines
+         END,
+         seconds = CASE WHEN EXCLUDED.complete THEN EXCLUDED.seconds ELSE GREATEST(transcripts.seconds, EXCLUDED.seconds) END,
+         complete = transcripts.complete OR EXCLUDED.complete,
+         model = CASE WHEN EXCLUDED.model = '' THEN transcripts.model ELSE EXCLUDED.model END,
+         title = CASE WHEN EXCLUDED.title = '' THEN transcripts.title ELSE EXCLUDED.title END,
+         translated_from = COALESCE(EXCLUDED.translated_from, transcripts.translated_from),
+         updated_at = now()
+       RETURNING *`, [
+            id,
+            ask.language,
+            ask.media,
+            kindOf(ask.media),
+            ask.translatedFrom ?? null,
+            ask.model ?? "",
+            complete,
+            (ask.title ?? "").slice(0, 200),
+            ask.by,
+            reach(lines),
+            JSON.stringify(lines),
+            MAX_LINES,
+        ]);
+        const row = rows[0];
+        return row ? rowToTranscript(row) : null;
+    }
+    /**
+     * The transcript of some media in a language: the original when none is
+     * named, which is the heard row -- the whole one when there is one.
+     */
+    async get(id, language = "") {
+        await this.ensure();
+        const { rows } = language === ""
+            ? await this.db.query(`SELECT * FROM transcripts WHERE id = $1 AND translated_from IS NULL
+           ORDER BY complete DESC, updated_at DESC LIMIT 1`, [id])
+            : await this.db.query("SELECT * FROM transcripts WHERE id = $1 AND language = $2 LIMIT 1", [id, language]);
+        const row = rows[0];
+        return row ? rowToTranscript(row) : null;
+    }
+    /** Every language some media has been written down in, with how much of it. */
+    async languages(id) {
+        await this.ensure();
+        const { rows } = await this.db.query(`SELECT language, translated_from, complete, jsonb_array_length(lines) AS lines
+       FROM transcripts WHERE id = $1 ORDER BY translated_from NULLS FIRST, language`, [id]);
+        return rows.map((row) => ({
+            language: String(row["language"] ?? ""),
+            translatedFrom: row["translated_from"] === null || row["translated_from"] === undefined ? null : String(row["translated_from"]),
+            lines: Number(row["lines"] ?? 0),
+            complete: row["complete"] === true,
+        }));
+    }
+    /** What an account has had written down, newest first. */
+    async list(by, limit = 50) {
+        await this.ensure();
+        const { rows } = await this.db.query(`SELECT id, language, media, kind, translated_from, model, complete, title, by_account, seconds, updated_at,
+              jsonb_array_length(lines) AS lines
+       FROM transcripts WHERE by_account = $1 ORDER BY updated_at DESC LIMIT $2`, [by, Math.max(1, Math.min(500, limit))]);
+        return rows.map((row) => ({ ...rowToTranscript({ ...row, lines: "[]" }), lines: Number(row["lines"] ?? 0) }));
+    }
+    /** Forget some media, in every language. Only whoever stored it may. Says whether anything went. */
+    async forget(id, by) {
+        await this.ensure();
+        const { rows } = await this.db.query("DELETE FROM transcripts WHERE id = $1 AND by_account = $2 RETURNING language", [id, by]);
+        return rows.length > 0;
+    }
+    /** Never throws: a store that is having a moment costs the memory, not the request. */
+    async quietly(what, run) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            this.onEvent(`  ${what} did not persist: ${error.message}`);
+            return null;
+        }
+    }
+}
+function rowToTranscript(row) {
+    const updated = row["updated_at"];
+    return {
+        id: String(row["id"] ?? ""),
+        media: String(row["media"] ?? ""),
+        kind: kindOf(String(row["media"] ?? "")),
+        language: String(row["language"] ?? ""),
+        translatedFrom: row["translated_from"] === null || row["translated_from"] === undefined ? null : String(row["translated_from"]),
+        model: String(row["model"] ?? ""),
+        complete: row["complete"] === true,
+        title: String(row["title"] ?? ""),
+        by: String(row["by_account"] ?? ""),
+        seconds: Number(row["seconds"] ?? 0),
+        lines: mergeLines(linesFrom(row["lines"])),
+        updatedAt: updated instanceof Date ? updated.toISOString() : typeof updated === "string" ? updated : "",
+    };
+}
+/** A transcript as the routes answer it, with or without its lines. */
+export function wire(transcript, languages = []) {
+    return {
+        id: transcript.id,
+        media: transcript.media,
+        kind: transcript.kind,
+        language: transcript.language,
+        translatedFrom: transcript.translatedFrom,
+        model: transcript.model,
+        complete: transcript.complete,
+        title: transcript.title,
+        seconds: transcript.seconds,
+        updatedAt: transcript.updatedAt,
+        lines: transcript.lines,
+        languages,
+    };
+}

package/dist/translate-cli.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `nixamp translate` -- a line in another language, from the terminal.
+ *
+ * The models are nixamp.com's (see translate.ts); this sends the text and
+ * prints what comes back, signed in as whoever this machine is signed in
+ * as. Text on the command line, or on stdin when there is none there, one
+ * line at a time so a file of lines comes back as a file of lines.
+ */
+import { type Session } from "./session.ts";
+export interface TranslateDeps {
+    fetcher?: typeof fetch;
+    session?: Pick<Session, "site" | "token"> | null;
+    /** What stdin says, when no text is on the command line; the tests hand it in. */
+    stdin?: () => Promise<string>;
+}
+export declare function translate(argv: string[], deps?: TranslateDeps): Promise<number>;

package/dist/translate-cli.js

@@ -0,0 +1,97 @@
+/**
+ * `nixamp translate` -- a line in another language, from the terminal.
+ *
+ * The models are nixamp.com's (see translate.ts); this sends the text and
+ * prints what comes back, signed in as whoever this machine is signed in
+ * as. Text on the command line, or on stdin when there is none there, one
+ * line at a time so a file of lines comes back as a file of lines.
+ */
+import { readSession } from "./session.js";
+import { translateTexts } from "./transcript-client.js";
+import { languageCode } from "./transcripts.js";
+const HELP = `nixamp translate — say it in another language.
+
+  nixamp translate --to sv "Hello there"      Swedish, from English
+  nixamp translate --from de --to en "Guten Tag"
+  cat lines.txt | nixamp translate --to de    each line, in order
+  nixamp translate --languages                what nixamp.com can translate between
+
+The models are open-source (OPUS-MT) and run on nixamp.com's own CPU; a pair
+with no model of its own goes through English. Needs a sign-in
+(\`nixamp login\`).
+`;
+function flag(argv, name) {
+    const at = argv.indexOf(name);
+    return at === -1 ? undefined : argv[at + 1];
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+}
+export async function translate(argv, deps = {}) {
+    if (argv.includes("--help") || argv.includes("-h") || argv[0] === "help") {
+        console.log(HELP);
+        return 0;
+    }
+    const session = deps.session === undefined ? readSession() : deps.session;
+    if (session === null) {
+        console.error("nixamp: not signed in. Try `nixamp login`.");
+        return 1;
+    }
+    const fetcher = deps.fetcher ?? fetch;
+    const signed = { site: session.site, token: session.token };
+    if (argv.includes("--languages")) {
+        let response;
+        try {
+            response = await fetcher(`${signed.site.replace(/\/+$/, "")}/api/v1/translate`);
+        }
+        catch (error) {
+            console.error(`nixamp: could not reach ${signed.site}: ${error.message}`);
+            return 1;
+        }
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok) {
+            console.error(`nixamp: ${body.error ?? `nixamp.com answered ${response.status}`}`);
+            return 1;
+        }
+        if (argv.includes("--json")) {
+            console.log(JSON.stringify(body, null, 2));
+            return 0;
+        }
+        if (body.available === false)
+            console.error("nixamp: that nixamp has no translation models; nixamp.com does.");
+        for (const language of body.languages ?? []) {
+            console.log(`${language.code}  ${language.name.padEnd(11)} ${language.native.padEnd(17)} -> ${language.targets.join(" ")}`);
+        }
+        return 0;
+    }
+    const to = languageCode(flag(argv, "--to"));
+    const from = languageCode(flag(argv, "--from") ?? "en");
+    if (!to || from === null || from === "") {
+        console.error("nixamp: --to (and --from, English by default) are two-letter language codes, such as sv.");
+        return 64;
+    }
+    const withValue = new Set(["--to", "--from"]);
+    const given = argv.filter((one, at) => !one.startsWith("-") && !(at > 0 && withValue.has(argv[at - 1])));
+    const text = given.length > 0 ? given.join(" ") : await (deps.stdin ?? readStdin)();
+    const lines = text.split(/\r?\n/).map((line) => line.trimEnd());
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    if (lines.length === 0) {
+        console.error("nixamp: translate what? Pass the text, or pipe it in.");
+        return 64;
+    }
+    const got = await translateTexts(signed, lines, from, to, fetcher);
+    if (!got.ok) {
+        console.error(`nixamp: ${got.error}`);
+        return 1;
+    }
+    if (argv.includes("--json")) {
+        console.log(JSON.stringify(got.body, null, 2));
+        return 0;
+    }
+    console.log(got.body.texts.join("\n"));
+    return 0;
+}

package/dist/translate-jobs.d.ts

@@ -0,0 +1,39 @@
+import { type Translator } from "./translate.ts";
+import { type Transcript, type TranscriptLine, type Transcripts } from "./transcripts.ts";
+export interface Progress {
+    done: number;
+    total: number;
+}
+/** What a request should answer: the status and the body's extra fields. */
+export type Answer = {
+    status: 200;
+    transcript: Transcript;
+} | {
+    status: 202;
+    transcript: Transcript | null;
+    translating: Progress;
+} | {
+    status: 404 | 409 | 503;
+    error: string;
+};
+export declare class StoredTranslations {
+    private readonly store;
+    private readonly translator;
+    private readonly onEvent;
+    private readonly jobs;
+    constructor(store: Transcripts, translator: Translator | undefined, onEvent?: (message: string) => void);
+    /** The lines of the original that the translation does not yet have. */
+    static missing(original: Transcript, translation: Transcript | null): TranscriptLine[];
+    /**
+     * The transcript in a language, or the job making it. The original when
+     * the language is the one it was heard in.
+     */
+    get(id: string, language: string, by: string): Promise<Answer>;
+    private start;
+    private run;
+    /** What is being translated right now. */
+    running(): {
+        key: string;
+        progress: Progress;
+    }[];
+}

package/dist/translate-jobs.js

@@ -0,0 +1,120 @@
+/**
+ * A stored transcript, translated: the job that does it, and its progress.
+ *
+ * A film's transcript is more than a thousand lines, and a thousand lines
+ * through a Marian model is minutes of CPU. No request waits that long.
+ * The first ask for a language starts the job and answers 202 with what
+ * there is; the job keeps the store up as it goes, so a second ask sees
+ * more, and a process that dies mid-way leaves behind what it had done
+ * for the next one to carry on from -- only the lines the store has no
+ * translation of yet are sent to the model. When the translation is as
+ * far along as the original, the ask is answered 200 with it.
+ *
+ * One job per transcript and language at a time; asking again joins the
+ * job that is running rather than starting another.
+ */
+import { SpeechError } from "./speech.js";
+import { BATCH } from "./translate.js";
+import { lineAt } from "./transcripts.js";
+export class StoredTranslations {
+    store;
+    translator;
+    onEvent;
+    jobs = new Map();
+    constructor(store, translator, onEvent = () => { }) {
+        this.store = store;
+        this.translator = translator;
+        this.onEvent = onEvent;
+    }
+    /** The lines of the original that the translation does not yet have. */
+    static missing(original, translation) {
+        if (!translation)
+            return original.lines;
+        return original.lines.filter((line) => lineAt(translation.lines, line.start) === null);
+    }
+    /**
+     * The transcript in a language, or the job making it. The original when
+     * the language is the one it was heard in.
+     */
+    async get(id, language, by) {
+        const original = await this.store.get(id);
+        if (!original)
+            return { status: 404, error: "nothing has been written down for that" };
+        if (language === "" || language === original.language)
+            return { status: 200, transcript: original };
+        const translation = await this.store.get(id, language);
+        const missing = StoredTranslations.missing(original, translation);
+        if (translation && missing.length === 0)
+            return { status: 200, transcript: translation };
+        if (original.language === "")
+            return { status: 409, error: "the language this was heard in is not known, so it cannot be translated" };
+        if (!this.translator)
+            return { status: 503, error: "this nixamp cannot translate: no model here. nixamp.com can." };
+        if (!this.translator.can(original.language, language)) {
+            return { status: 409, error: `there is no model here from ${original.language} to ${language}` };
+        }
+        const key = `${id}|${language}`;
+        let job = this.jobs.get(key);
+        if (job?.error) {
+            this.jobs.delete(key);
+            return { status: 503, error: job.error };
+        }
+        if (!job) {
+            job = this.start(key, original, translation, missing, language, by);
+            // A short one is done before the ask is answered.
+            if (missing.length <= BATCH) {
+                await job.finished;
+                if (job.error) {
+                    this.jobs.delete(key);
+                    return { status: 503, error: job.error };
+                }
+                const made = await this.store.get(id, language);
+                if (made)
+                    return { status: 200, transcript: made };
+            }
+        }
+        return { status: 202, transcript: translation, translating: { ...job.progress } };
+    }
+    start(key, original, translation, missing, language, by) {
+        const job = { progress: { done: original.lines.length - missing.length, total: original.lines.length }, finished: Promise.resolve(), error: "" };
+        job.finished = this.run(original, translation, missing, language, by, job)
+            .catch((error) => {
+            job.error = error instanceof SpeechError ? error.message : `translating failed: ${error.message}`;
+            this.onEvent(`  translating ${original.title || original.media} to ${language}: ${job.error}`);
+        })
+            .finally(() => {
+            if (!job.error)
+                this.jobs.delete(key);
+        });
+        this.jobs.set(key, job);
+        return job;
+    }
+    async run(original, translation, missing, language, by, job) {
+        const translator = this.translator;
+        const made = translation ? [...translation.lines] : [];
+        let model = "";
+        for (let at = 0; at < missing.length; at += BATCH) {
+            const batch = missing.slice(at, at + BATCH);
+            const done = await translator.translate(batch.map((line) => line.text), original.language, language);
+            model = done.model;
+            const lines = batch.map((line, i) => ({ start: line.start, end: line.end, text: done.texts[i] ?? "" })).filter((line) => line.text !== "");
+            made.push(...lines);
+            await this.store.save({
+                media: original.media, language, translatedFrom: original.language, model, title: original.title, by, lines,
+            });
+            job.progress.done += batch.length;
+        }
+        if (original.complete) {
+            // Whole, like the original: the pieces are replaced by the lot, and nothing partial touches it again.
+            await this.store.save({
+                media: original.media, language, translatedFrom: original.language, model, title: original.title, by, lines: made, complete: true,
+            });
+        }
+        if (missing.length > 0)
+            this.onEvent(`  translated ${missing.length} lines of ${original.title || original.media} to ${language}`);
+    }
+    /** What is being translated right now. */
+    running() {
+        return [...this.jobs.entries()].filter(([, job]) => !job.error).map(([key, job]) => ({ key, progress: { ...job.progress } }));
+    }
+}