nixamp 0.23.7 → 0.24.1

package/README.md

@@ -140,7 +140,12 @@ DATABASE_URL=postgres://user:pass@host/nixamp NIXAMP_JWT_SECRET=… nixamp serve
 Accounts live where the directory lives and nowhere else: a nixamp on a laptop
 has nobody to be an account of.
 
-## Watch parties, and signing in with nixamp
+## Parties, and signing in with nixamp
+
+The web app uses **Join party** for joining a stream or a party on a connected
+site. In the **Parties** panel, enter an **Invite code** and select **Join party**
+to open its room. A listed party's **Join party** link opens the film on the
+site hosting it; **Open room** opens its nixamp room.
 
 A watch party lives on the site that has the film. bittorrented.com has them:
 a six-character code, a host, and everybody at the same second. nixamp has
@@ -192,11 +197,15 @@ nixamp party sync ABC123 --at 930    where playback is (hosts only)
 and an agent reaches the same five actions over the Model Context Protocol:
 
 ```
-nixamp mcp     a stdio MCP server: list, get, host, sync, end
+nixamp mcp     a stdio MCP server: the parties, the rooms, the transcripts
 ```
 
 It acts as whoever the machine is signed in as, so `nixamp login` comes first.
-The film never crosses over: what nixamp carries is the room.
+The film never crosses over: what nixamp carries is the room. The same tools
+are at `https://nixamp.com/mcp` over HTTP, with a nixamp token
+(`nixamp token create`) as the bearer, for an agent with no nixamp installed;
+`/.well-known/oauth-protected-resource` says where the authorization server
+is.
 
 ## BackToSchool.help
 
@@ -405,6 +414,73 @@ nixamp.com instead. `NIXAMP_STT_MODEL` picks another Whisper
 takes twice as long), `NIXAMP_STT_CACHE` says where its files are kept, and
 `NIXAMP_STT=off` leaves the ear out of a deployment altogether.
 
+The ear tells which language it heard: one pass over the first thirty
+seconds, the way whisper.cpp does it, before the words are read. Without
+that a Swedish channel came back as three English words repeated to the end
+of the window. A captioner learns the language from its first line and says
+it on every ask after that.
+
+### Kept: written down once, for everybody
+
+What the ear hears is kept on nixamp.com under the identity of what was
+playing, not of the channel that happened to play it: a file by its
+fingerprint (its size and a megabyte at each end), a link by its address, a
+live as the one broadcast it was. Lines are seconds into the media. The next
+captioner to meet the same film reads the lines out of the store instead of
+hearing them, whichever server it is on; what it hears beyond them is added.
+
+```
+nixamp transcribe FILE                     the whole film, a minute at a time, kept when it is done
+nixamp transcribe FILE --srt > film.srt    as subtitles; --vtt, --txt, --json
+nixamp transcribe FILE --out DIR           a subtitle file per language in DIR
+nixamp transcript --kept MEDIA_OR_ID       what nixamp.com keeps, for a file, a link or a past live
+nixamp transcript --list                   everything this account has had written down
+```
+
+```
+GET  /api/v1/transcripts                   what you have had written down
+GET  /api/v1/transcripts/ID                the transcript; ?format=srt|vtt|txt, ?language=de
+POST /api/v1/transcripts/ID/lines          keep lines: {media, language, lines: [{start, end, text}], complete?}
+DELETE /api/v1/transcripts/ID              forget it (whoever kept it)
+```
+
+ID is the sha256 of the media identity, or the identity itself
+(`file:v1:<hash>`, `url:<address>`, `live:<server>/<channel>@<started>`).
+Signed in to read and to keep, like the ear. A whole-file pass marks the row
+complete and replaces the pieces a captioner left; a live grows as it goes
+and a page that asks for it reads what there is so far. An agent has
+`transcript_get` and `transcripts_list`, and `transcribe_audio` keeps a film
+the same way.
+
+### In another language
+
+Ask for a language and the lines come translated, by an open-source model on
+nixamp.com's own CPU (Helsinki-NLP's OPUS-MT pairs, through Transformers.js):
+German and Swedish among the languages, and anything with a model from or
+into English; a pair with no model of its own goes through English. A
+translation is made once and kept beside the original.
+
+```
+GET  /api/channels/ID/captions?language=sv   a live's lines in Swedish, each translated as it is heard
+GET  /api/v1/transcripts/ID?language=de      a kept transcript in German; 202 with progress while a long one is made
+GET  /api/v1/translate                       the languages, and what each can be turned into here
+POST /api/v1/translate                       {texts, from, to} -> {texts}
+```
+
+```
+nixamp transcript --channel ID --language sv    a live, in Swedish, as it speaks
+nixamp transcribe FILE --translate de,sv        a film in German and Swedish too
+nixamp translate --to sv "Hello there"          a line; or lines on stdin
+nixamp translate --languages                    what nixamp.com can do
+```
+
+The page has the same choice beside the Captions switch, remembered per
+device; a translated line is marked with its language and shows what was
+heard under the pointer. An agent has `translate_text`. `NIXAMP_MT_WARM`
+names pairs to load at boot (`en-de,en-sv`), `NIXAMP_MT=off` leaves
+translation out, and the Docker image bakes the ear and the German and
+Swedish pairs in so a deploy never downloads them again.
+
 ## Several streams at once
 
 A channel is one publisher and everybody listening to them. Two or three devices

package/dist/captions.d.ts

@@ -1,4 +1,5 @@
 import type { Listener } from "./channels.ts";
+import { lineAt } from "./transcripts.ts";
 export interface CaptionLine {
     /** The channel's id. */
     channel: string;
@@ -6,12 +7,31 @@ export interface CaptionLine {
     at: number;
     until: number;
     text: string;
+    /** The language of the words, as heard or as translated into; absent when nobody said. */
+    language?: string;
+    /** What was heard, when this line is a translation of it. */
+    original?: string;
 }
 /** What turns a channel's bytes into 16 kHz mono 16-bit PCM. ffmpeg, or a test's stand-in. */
 export interface Decoder {
     write(chunk: Buffer): boolean;
     end(): void;
 }
+/**
+ * What a channel is playing, for the store: its identity, and how the
+ * sound a new listener gets maps onto seconds of it.
+ */
+export interface ChannelMedia {
+    /** The media identity, as transcripts.ts spells one. */
+    media: string;
+    title: string;
+    /** Seconds into the media at this moment, for a film; absent for anything live. */
+    position?: number;
+    /** When the channel began, wall clock, ms. A live's seconds count from here. */
+    startedAt: number;
+    /** How many seconds behind the live edge a new listener's sound starts. */
+    backlog: number;
+}
 export interface CaptionsOptions {
     /** A listener on a channel, or null when there is no such channel. */
     listen: (id: string, listener: Listener) => (() => void) | null;
@@ -24,10 +44,14 @@ export interface CaptionsOptions {
     fetcher?: typeof fetch;
     /** How bytes become PCM. The default spawns ffmpeg; the tests hand in something quieter. */
     decoder?: (onPcm: (pcm: Buffer) => void, onEnd: () => void) => Decoder;
+    /** What a channel is playing, for the store. Null, or absent, means the lines are not kept. */
+    mediaOf?: (id: string) => ChannelMedia | null;
     now?: () => number;
     onEvent?: (message: string) => void;
     windowMs?: number;
     idleMs?: number;
+    /** How often heard lines go to the store. */
+    flushMs?: number;
 }
 export declare const WINDOW_MS = 5000;
 /** Lines kept per channel for whoever arrives late. */
@@ -37,6 +61,10 @@ export declare const IDLE_MS = 60000;
 export declare const QUIET = 0.004;
 /** Windows waiting on the ear at once. Past this the sound is dropped, not queued: late words are worse than none. */
 export declare const IN_FLIGHT = 2;
+/** Heard lines wait this long, at most, before they are kept. */
+export declare const FLUSH_MS = 20000;
+/** Or this many. */
+export declare const FLUSH_LINES = 12;
 /**
  * The ffmpeg arguments: whatever arrives on stdin, as PCM on stdout, with
  * a short probe so the first line is not long in coming. Never `-fflags
@@ -48,7 +76,30 @@ export declare function decoderArgs(): string[];
 export declare function isQuiet(pcm: Buffer, threshold?: number): boolean;
 /** A WAV around 16-bit mono PCM, without copying it through floats. */
 export declare function wavAround(pcm: Buffer, rate?: number): Buffer;
+/**
+ * Seconds into the media that a window covers. A film is paced in real
+ * time from a known position, so a new listener's first byte is that
+ * position less the backlog it was handed, and every window after it is
+ * one window further on. Anything live counts from when the channel
+ * began, in wall-clock time.
+ */
+export declare function mediaSpan(media: ChannelMedia, windowIndex: number, windowSeconds: number, at: number, until: number): {
+    start: number;
+    end: number;
+};
+export { lineAt };
 type Subscriber = (line: CaptionLine) => void;
+export interface CaptionStatus {
+    on: boolean;
+    lines: number;
+    error: string;
+    /** The language heard, when known. */
+    language: string;
+    /** How many lines the store already had for this media when the captioner began. */
+    known: number;
+    /** The languages lines are being given in besides the original. */
+    languages: string[];
+}
 export declare class Captions {
     private readonly options;
     private readonly running;
@@ -59,17 +110,13 @@ export declare class Captions {
      * Lines for a channel as they are heard, starting the captioner if it is
      * not running. Null when there is no such channel. The returned function
      * is how to stop listening; the captioner itself stops a minute after the
-     * last listener does.
+     * last listener does. A language asks for the lines translated into it;
+     * "" is the original.
      */
-    subscribe(id: string, subscriber: Subscriber): (() => void) | null;
-    /** The recent lines of a channel, oldest first, after a moment when given. Empty when nobody has asked for them. */
-    recent(id: string, after?: number): CaptionLine[];
+    subscribe(id: string, subscriber: Subscriber, language?: string): (() => void) | null;
+    /** The recent lines of a channel, oldest first, after a moment when given, in a language when asked. Empty when nobody has asked for them. */
+    recent(id: string, after?: number, language?: string): CaptionLine[];
     /** Whether a channel is being captioned, and what last went wrong if the lines are not coming. */
-    status(id: string): {
-        on: boolean;
-        lines: number;
-        error: string;
-    };
+    status(id: string): CaptionStatus;
     stopAll(): void;
 }
-export {};

package/dist/captions.js

@@ -20,9 +20,20 @@
  * A quiet window -- the gap between songs, a picture with no talking -- is
  * never sent. Most of a music channel is that, and hearing it costs the
  * same as hearing speech.
+ *
+ * What is heard is kept (see transcripts.ts): every line goes to nixamp.com
+ * under the identity of what the channel is playing, as seconds into it.
+ * When a captioner starts it asks for what is already known, and a window
+ * whose moment the store has been through is read out of it instead of
+ * heard. A film captioned once is captioned by nobody again; a live is
+ * kept as the broadcast it was. And a viewer may ask for the lines in
+ * another language: each heard line is translated once, on nixamp.com,
+ * handed to whoever wanted that language, and kept beside the original.
  */
 import { spawn } from "node:child_process";
 import { RATE } from "./speech.js";
+import { fetchTranscript, keepLines, translateTexts } from "./transcript-client.js";
+import { covered, lineAt, transcriptIdOf } from "./transcripts.js";
 export const WINDOW_MS = 5000;
 /** Lines kept per channel for whoever arrives late. */
 export const KEEP = 200;
@@ -31,6 +42,10 @@ export const IDLE_MS = 60_000;
 export const QUIET = 0.004;
 /** Windows waiting on the ear at once. Past this the sound is dropped, not queued: late words are worse than none. */
 export const IN_FLIGHT = 2;
+/** Heard lines wait this long, at most, before they are kept. */
+export const FLUSH_MS = 20_000;
+/** Or this many. */
+export const FLUSH_LINES = 12;
 /**
  * The ffmpeg arguments: whatever arrives on stdin, as PCM on stdout, with
  * a short probe so the first line is not long in coming. Never `-fflags
@@ -116,14 +131,38 @@ export function wavAround(pcm, rate = RATE) {
     header.writeUInt32LE(pcm.length, 40);
     return Buffer.concat([header, pcm]);
 }
+/**
+ * Seconds into the media that a window covers. A film is paced in real
+ * time from a known position, so a new listener's first byte is that
+ * position less the backlog it was handed, and every window after it is
+ * one window further on. Anything live counts from when the channel
+ * began, in wall-clock time.
+ */
+export function mediaSpan(media, windowIndex, windowSeconds, at, until) {
+    if (typeof media.position === "number") {
+        const join = Math.max(0, media.position - media.backlog);
+        return { start: round(join + windowIndex * windowSeconds), end: round(join + (windowIndex + 1) * windowSeconds) };
+    }
+    return { start: round(Math.max(0, (at - media.startedAt) / 1000)), end: round(Math.max(0, (until - media.startedAt) / 1000)) };
+}
+function round(seconds) {
+    return Math.round(seconds * 1000) / 1000;
+}
+export { lineAt };
 class Captioner {
     id;
     options;
     onStop;
+    /** The lines as heard, oldest first. */
     lines = [];
-    subscribers = new Set();
+    /** The lines in each other language somebody asked for. */
+    linesBy = new Map();
+    subscribers = new Map();
     /** The last thing that went wrong, for whoever asks why there are no lines. */
     error = "";
+    /** What the ear says the sound is in, or the store said it was; "" until one of them has. */
+    language = "";
+    model = "";
     decoder = null;
     detach = null;
     idle = null;
@@ -132,14 +171,35 @@ class Captioner {
     inFlight = 0;
     stopped = false;
     complainedAt = 0;
+    windows = 0;
+    /** What the channel is playing, when the store is to be told. */
+    media;
+    transcriptId;
+    /** What the store had, by language ("" for the original), and which stored moments have been read out. */
+    known = new Map();
+    readOut = new Set();
+    asked = new Set();
+    /** Lines heard or translated here and not yet kept, by language. */
+    unsaved = new Map();
+    flush = null;
+    /** Translations in order, per language: a slow one must not overtake the next. */
+    chains = new Map();
     constructor(id, options, onStop) {
         this.id = id;
         this.options = options;
         this.onStop = onStop;
+        this.media = options.mediaOf?.(id) ?? null;
+        this.transcriptId = this.media ? transcriptIdOf(this.media.media) : null;
     }
     get windowBytes() {
         return Math.round(((this.options.windowMs ?? WINDOW_MS) / 1000) * RATE) * 2;
     }
+    get windowSeconds() {
+        return (this.options.windowMs ?? WINDOW_MS) / 1000;
+    }
+    now() {
+        return (this.options.now ?? Date.now)();
+    }
     start() {
         const make = this.options.decoder ?? ((onPcm, onEnd) => ffmpegDecoder(this.options.ffmpeg, onPcm, onEnd));
         this.decoder = make((pcm) => this.onPcm(pcm), () => this.stop());
@@ -151,8 +211,32 @@ class Captioner {
             this.stop();
             return false;
         }
+        void this.consult("");
         return true;
     }
+    /** Ask the store what it already knows of this media in a language, once. */
+    async consult(language) {
+        if (!this.transcriptId || this.asked.has(language))
+            return;
+        this.asked.add(language);
+        const session = this.options.session();
+        if (session === null)
+            return;
+        const got = await fetchTranscript(session, this.transcriptId, language, this.options.fetcher ?? fetch);
+        if (this.stopped)
+            return;
+        if (!got.ok) {
+            if (got.status !== 404)
+                this.complain(`the store did not answer: ${got.error}`);
+            return;
+        }
+        this.known.set(language, got.body.lines);
+        if (language === "" && this.language === "" && got.body.language)
+            this.language = got.body.language;
+        if (got.body.lines.length > 0) {
+            this.options.onEvent?.(`captions for "${this.id}": the store knows ${got.body.lines.length} lines of this${language ? ` in ${language}` : ""}`);
+        }
+    }
     onPcm(pcm) {
         if (this.stopped)
             return;
@@ -165,13 +249,30 @@ class Captioner {
             const rest = all.subarray(size);
             this.pending = rest.length > 0 ? [Buffer.from(rest)] : [];
             this.pendingBytes = rest.length;
-            const until = (this.options.now ?? Date.now)();
-            void this.hear(Buffer.from(window), until - (this.options.windowMs ?? WINDOW_MS), until);
+            const until = this.now();
+            const index = this.windows;
+            this.windows += 1;
+            void this.hear(Buffer.from(window), until - (this.options.windowMs ?? WINDOW_MS), until, index);
         }
     }
-    async hear(pcm, at, until) {
+    async hear(pcm, at, until, index) {
         if (isQuiet(pcm))
             return;
+        const span = this.media ? mediaSpan(this.media, index, this.windowSeconds, at, until) : null;
+        if (span) {
+            const stored = covered(this.known.get("") ?? [], span.start, span.end);
+            if (stored.length > 0) {
+                // The store has been through this moment: read it out, and let the ear rest.
+                for (const line of stored) {
+                    if (this.readOut.has(line.start))
+                        continue;
+                    this.readOut.add(line.start);
+                    const lineAt = at + (line.start - span.start) * 1000;
+                    this.emit({ channel: this.id, at: lineAt, until: lineAt + (line.end - line.start) * 1000, text: line.text, ...(this.language ? { language: this.language } : {}) }, line.start);
+                }
+                return;
+            }
+        }
         if (this.inFlight >= IN_FLIGHT)
             return;
         const session = this.options.session();
@@ -182,7 +283,10 @@ class Captioner {
         this.inFlight += 1;
         try {
             const wav = wavAround(pcm);
-            const response = await (this.options.fetcher ?? fetch)(`${session.site.replace(/\/+$/, "")}/api/v1/speech/transcribe`, {
+            const url = new URL(`${session.site.replace(/\/+$/, "")}/api/v1/speech/transcribe`);
+            if (this.language)
+                url.searchParams.set("language", this.language);
+            const response = await (this.options.fetcher ?? fetch)(url.toString(), {
                 method: "POST",
                 headers: { authorization: `Bearer ${session.token}`, "content-type": "audio/wav" },
                 body: new Blob([wav.buffer.slice(wav.byteOffset, wav.byteOffset + wav.byteLength)]),
@@ -196,18 +300,14 @@ class Captioner {
             if (text === "" || this.stopped)
                 return;
             this.error = "";
-            const line = { channel: this.id, at, until, text };
-            this.lines.push(line);
-            while (this.lines.length > KEEP)
-                this.lines.shift();
-            for (const subscriber of this.subscribers) {
-                try {
-                    subscriber(line);
-                }
-                catch {
-                    // A listener that throws is not this channel's problem.
-                }
-            }
+            if (body.language && this.language === "")
+                this.language = body.language;
+            if (body.model)
+                this.model = body.model;
+            const line = { channel: this.id, at, until, text, ...(this.language ? { language: this.language } : {}) };
+            this.emit(line, span?.start ?? null);
+            if (span)
+                this.keep("", { start: span.start, end: span.end, text });
         }
         catch (error) {
             this.complain(`could not reach the ear: ${error.message}`);
@@ -216,17 +316,127 @@ class Captioner {
             this.inFlight -= 1;
         }
     }
+    /** A line as heard, to whoever wants the original, and translated to whoever wants another language. */
+    emit(line, mediaStart) {
+        this.lines.push(line);
+        while (this.lines.length > KEEP)
+            this.lines.shift();
+        for (const [subscriber, language] of this.subscribers) {
+            if (language === "" || language === this.language)
+                this.tell(subscriber, line);
+        }
+        for (const language of this.wanted())
+            this.translated(language, line, mediaStart);
+    }
+    tell(subscriber, line) {
+        try {
+            subscriber(line);
+        }
+        catch {
+            // A listener that throws is not this channel's problem.
+        }
+    }
+    /** The languages somebody wants besides the one being heard. */
+    wanted() {
+        const languages = new Set();
+        for (const language of this.subscribers.values())
+            if (language !== "" && language !== this.language)
+                languages.add(language);
+        return languages;
+    }
+    /** The line in another language: from the store when it has been through this moment, from nixamp.com otherwise. */
+    translated(language, line, mediaStart) {
+        const chain = (this.chains.get(language) ?? Promise.resolve()).then(async () => {
+            if (this.stopped)
+                return;
+            let text = "";
+            const stored = mediaStart === null ? null : lineAt(this.known.get(language) ?? [], mediaStart);
+            if (stored) {
+                text = stored.text;
+            }
+            else {
+                const session = this.options.session();
+                if (session === null)
+                    return;
+                const got = await translateTexts(session, [line.text], this.language, language, this.options.fetcher ?? fetch);
+                if (!got.ok) {
+                    this.complain(`could not translate to ${language}: ${got.error}`);
+                    return;
+                }
+                text = (got.body.texts[0] ?? "").trim();
+                if (text === "")
+                    return;
+                if (mediaStart !== null)
+                    this.keep(language, { start: mediaStart, end: round(mediaStart + (line.until - line.at) / 1000), text });
+            }
+            if (this.stopped)
+                return;
+            const said = { ...line, text, language, original: line.text };
+            const lines = this.linesBy.get(language) ?? [];
+            lines.push(said);
+            while (lines.length > KEEP)
+                lines.shift();
+            this.linesBy.set(language, lines);
+            for (const [subscriber, wanted] of this.subscribers)
+                if (wanted === language)
+                    this.tell(subscriber, said);
+        });
+        this.chains.set(language, chain.catch(() => undefined));
+    }
+    /** A line for the store, kept with the others of its language until the next flush. */
+    keep(language, line) {
+        if (!this.media)
+            return;
+        const lines = this.unsaved.get(language) ?? [];
+        lines.push(line);
+        this.unsaved.set(language, lines);
+        if (lines.length >= FLUSH_LINES) {
+            void this.flushNow();
+            return;
+        }
+        if (this.flush === null) {
+            this.flush = setTimeout(() => void this.flushNow(), this.options.flushMs ?? FLUSH_MS);
+            this.flush.unref?.();
+        }
+    }
+    /** Everything not yet kept, to the store. Never throws; a store that is away costs nothing but the keeping. */
+    async flushNow() {
+        if (this.flush)
+            clearTimeout(this.flush);
+        this.flush = null;
+        if (!this.media || !this.transcriptId)
+            return;
+        const session = this.options.session();
+        if (session === null)
+            return;
+        const batches = [...this.unsaved.entries()].filter(([, lines]) => lines.length > 0);
+        this.unsaved.clear();
+        for (const [language, lines] of batches) {
+            const got = await keepLines(session, this.transcriptId, {
+                media: this.media.media,
+                title: this.media.title,
+                language: language === "" ? this.language : language,
+                ...(language === "" ? {} : { translatedFrom: this.language }),
+                ...(this.model ? { model: this.model } : {}),
+                lines,
+            }, this.options.fetcher ?? fetch);
+            if (!got.ok)
+                this.complain(`the store did not keep ${lines.length} lines: ${got.error}`);
+        }
+    }
     /** Said once a minute at most: a broken ear would otherwise say so twelve times a minute. */
     complain(message) {
         this.error = message;
-        const now = (this.options.now ?? Date.now)();
+        const now = this.now();
         if (now - this.complainedAt < 60_000)
             return;
         this.complainedAt = now;
         this.options.onEvent?.(`captions for "${this.id}": ${message}`);
     }
-    subscribe(subscriber) {
-        this.subscribers.add(subscriber);
+    subscribe(subscriber, language = "") {
+        this.subscribers.set(subscriber, language);
+        if (language !== "")
+            void this.consult(language);
         if (this.idle)
             clearTimeout(this.idle);
         this.idle = null;
@@ -241,6 +451,20 @@ class Captioner {
             }
         };
     }
+    recent(after, language = "") {
+        const lines = language === "" || language === this.language ? this.lines : (this.linesBy.get(language) ?? []);
+        return after > 0 ? lines.filter((line) => line.at > after) : [...lines];
+    }
+    status() {
+        return {
+            on: true,
+            lines: this.lines.length,
+            error: this.error,
+            language: this.language,
+            known: this.known.get("")?.length ?? 0,
+            languages: [...this.linesBy.keys()],
+        };
+    }
     stop() {
         if (this.stopped)
             return;
@@ -255,6 +479,7 @@ class Captioner {
         this.pending = [];
         this.pendingBytes = 0;
         this.subscribers.clear();
+        void this.flushNow();
         this.onStop();
     }
 }
@@ -272,9 +497,10 @@ export class Captions {
      * Lines for a channel as they are heard, starting the captioner if it is
      * not running. Null when there is no such channel. The returned function
      * is how to stop listening; the captioner itself stops a minute after the
-     * last listener does.
+     * last listener does. A language asks for the lines translated into it;
+     * "" is the original.
      */
-    subscribe(id, subscriber) {
+    subscribe(id, subscriber, language = "") {
         let captioner = this.running.get(id);
         if (!captioner) {
             const made = new Captioner(id, this.options, () => {
@@ -287,19 +513,17 @@ export class Captions {
             this.options.onEvent?.(`captions for "${id}": started`);
             captioner = made;
         }
-        return captioner.subscribe(subscriber);
+        return captioner.subscribe(subscriber, language);
     }
-    /** The recent lines of a channel, oldest first, after a moment when given. Empty when nobody has asked for them. */
-    recent(id, after = 0) {
+    /** The recent lines of a channel, oldest first, after a moment when given, in a language when asked. Empty when nobody has asked for them. */
+    recent(id, after = 0, language = "") {
         const captioner = this.running.get(id);
-        if (!captioner)
-            return [];
-        return after > 0 ? captioner.lines.filter((line) => line.at > after) : [...captioner.lines];
+        return captioner ? captioner.recent(after, language) : [];
     }
     /** Whether a channel is being captioned, and what last went wrong if the lines are not coming. */
     status(id) {
         const captioner = this.running.get(id);
-        return captioner ? { on: true, lines: captioner.lines.length, error: captioner.error } : { on: false, lines: 0, error: "" };
+        return captioner ? captioner.status() : { on: false, lines: 0, error: "", language: "", known: 0, languages: [] };
     }
     stopAll() {
         for (const captioner of [...this.running.values()])