nixamp 0.23.5 → 0.23.7

package/dist/outro.js

@@ -0,0 +1,225 @@
+/**
+ * The outro: what a channel plays once its show is over.
+ *
+ * A live that ended used to start again from the top, for ever, because a
+ * source that finished cleanly was dialled like a source that dropped. Now
+ * it plays this: five seconds of "THIS LIVE STREAM HAS ENDED" on the
+ * plate with the mark, looped for an hour, so whoever joins late is told
+ * so by the picture and not by a blank panel. Then the channel closes.
+ *
+ * Drawn here, never committed as a file, the way the app's icons are:
+ * a bitmap, a 5x7 pixel face, and ffmpeg to make a clip of it. Encoded
+ * exactly as a channel is sent on the wire (H.264 and AAC for a picture,
+ * MP3 for sound alone) so the channel can copy it through without knowing
+ * how its own source was encoded. Made once per server and kept beside the
+ * keys; a missing or stale one is drawn again.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { deflateSync } from "node:zlib";
+/** How long the outro plays after a show ends, before the channel closes. */
+export const OUTRO_MS = 60 * 60 * 1000;
+/** The clip's length; it loops. */
+export const OUTRO_SECONDS = 5;
+/** Bumped when the drawing changes, so an old clip on disk is drawn again. */
+export const OUTRO_VERSION = 1;
+const BACKGROUND = { r: 8, g: 12, b: 9, a: 255 };
+const GREEN = { r: 74, g: 246, b: 137, a: 255 };
+const DIM = { r: 34, g: 122, b: 74, a: 255 };
+const MUTED = { r: 120, g: 150, b: 130, a: 255 };
+const BARS = [0.30, 0.55, 0.85, 0.62, 1.0, 0.72, 0.45, 0.25];
+/** A canvas of straight RGBA bytes. */
+export class Bitmap {
+    width;
+    height;
+    pixels;
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.pixels = new Uint8Array(width * height * 4);
+    }
+    fill(color) {
+        for (let i = 0; i < this.pixels.length; i += 4)
+            this.set(i, color);
+    }
+    rect(x, y, w, h, color) {
+        const x0 = Math.max(0, Math.round(x));
+        const y0 = Math.max(0, Math.round(y));
+        const x1 = Math.min(this.width, Math.round(x + w));
+        const y1 = Math.min(this.height, Math.round(y + h));
+        for (let py = y0; py < y1; py++) {
+            for (let px = x0; px < x1; px++)
+                this.set((py * this.width + px) * 4, color);
+        }
+    }
+    set(offset, { r, g, b, a }) {
+        this.pixels[offset] = r;
+        this.pixels[offset + 1] = g;
+        this.pixels[offset + 2] = b;
+        this.pixels[offset + 3] = a;
+    }
+}
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+function crc32(bytes) {
+    let c = 0xffffffff;
+    for (const byte of bytes)
+        c = CRC_TABLE[(c ^ byte) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+    const head = Buffer.alloc(8);
+    head.writeUInt32BE(data.length, 0);
+    head.write(type, 4, "ascii");
+    const body = Buffer.concat([head.subarray(4), Buffer.from(data)]);
+    const tail = Buffer.alloc(4);
+    tail.writeUInt32BE(crc32(body), 0);
+    return Buffer.concat([head.subarray(0, 4), body, tail]);
+}
+/** Encode as a non-interlaced 8-bit RGBA PNG. */
+export function encodePng(bitmap) {
+    const { width, height, pixels } = bitmap;
+    const stride = width * 4;
+    const raw = Buffer.alloc((stride + 1) * height);
+    for (let y = 0; y < height; y++) {
+        raw[y * (stride + 1)] = 0;
+        Buffer.from(pixels.subarray(y * stride, (y + 1) * stride)).copy(raw, y * (stride + 1) + 1);
+    }
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr[8] = 8;
+    ihdr[9] = 6;
+    return Buffer.concat([
+        Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+        chunk("IHDR", ihdr),
+        chunk("IDAT", deflateSync(raw, { level: 9 })),
+        chunk("IEND", new Uint8Array(0)),
+    ]);
+}
+/** A 5x7 pixel face: the letters the outro needs and nothing else. */
+const GLYPHS = {
+    A: [".XXX.", "X...X", "X...X", "XXXXX", "X...X", "X...X", "X...X"],
+    C: [".XXXX", "X....", "X....", "X....", "X....", "X....", ".XXXX"],
+    D: ["XXXX.", "X...X", "X...X", "X...X", "X...X", "X...X", "XXXX."],
+    E: ["XXXXX", "X....", "X....", "XXXX.", "X....", "X....", "XXXXX"],
+    H: ["X...X", "X...X", "X...X", "XXXXX", "X...X", "X...X", "X...X"],
+    I: ["XXXXX", "..X..", "..X..", "..X..", "..X..", "..X..", "XXXXX"],
+    L: ["X....", "X....", "X....", "X....", "X....", "X....", "XXXXX"],
+    M: ["X...X", "XX.XX", "X.X.X", "X.X.X", "X...X", "X...X", "X...X"],
+    N: ["X...X", "XX..X", "X.X.X", "X..XX", "X...X", "X...X", "X...X"],
+    O: [".XXX.", "X...X", "X...X", "X...X", "X...X", "X...X", ".XXX."],
+    P: ["XXXX.", "X...X", "X...X", "XXXX.", "X....", "X....", "X...."],
+    R: ["XXXX.", "X...X", "X...X", "XXXX.", "X.X..", "X..X.", "X...X"],
+    S: [".XXXX", "X....", "X....", ".XXX.", "....X", "....X", "XXXX."],
+    T: ["XXXXX", "..X..", "..X..", "..X..", "..X..", "..X..", "..X.."],
+    V: ["X...X", "X...X", "X...X", "X...X", "X...X", ".X.X.", "..X.."],
+    X: ["X...X", "X...X", ".X.X.", "..X..", ".X.X.", "X...X", "X...X"],
+    ".": [".....", ".....", ".....", ".....", ".....", "..XX.", "..XX."],
+};
+export function textWidth(text, cell) {
+    return text.length * 6 * cell - cell;
+}
+export function drawText(bitmap, text, x, y, cell, color) {
+    let at = x;
+    for (const letter of text) {
+        const rows = GLYPHS[letter];
+        if (rows) {
+            rows.forEach((row, r) => {
+                for (let c = 0; c < row.length; c++)
+                    if (row[c] === "X")
+                        bitmap.rect(at + c * cell, y + r * cell, cell, cell, color);
+            });
+        }
+        at += 6 * cell;
+    }
+}
+function drawBars(bitmap, left, bottom, width, tallest, scale) {
+    const slot = width / BARS.length;
+    const bar = slot * 0.62;
+    BARS.forEach((value, i) => {
+        const height = Math.max(2, tallest * value);
+        const x = left + i * slot + (slot - bar) / 2;
+        bitmap.rect(x, bottom - height, bar, height, GREEN);
+        const peak = Math.max(2, scale * 0.018);
+        bitmap.rect(x, bottom - height - peak * 2.4, bar, peak, DIM);
+    });
+    bitmap.rect(left, bottom, width, Math.max(2, scale * 0.028), DIM);
+}
+/** The picture: the mark above the words, on the plate. 1280x720. */
+export function drawOutro(width = 1280, height = 720) {
+    const bitmap = new Bitmap(width, height);
+    bitmap.fill(BACKGROUND);
+    const mark = height * 0.3;
+    drawBars(bitmap, (width - mark) / 2, height * 0.42, mark, mark - height * 0.02, mark * 1.8);
+    const line = "THIS LIVE STREAM HAS ENDED";
+    const cell = Math.floor(Math.min((width * 0.86) / (line.length * 6), height / 40));
+    drawText(bitmap, line, (width - textWidth(line, cell)) / 2, height * 0.56, cell, GREEN);
+    const small = Math.max(2, Math.floor(cell * 0.6));
+    const site = "NIXAMP.COM";
+    drawText(bitmap, site, (width - textWidth(site, small)) / 2, height * 0.56 + cell * 7 + small * 3, small, MUTED);
+    return bitmap;
+}
+/** The encode a channel copies an outro through: what a channel sends on the wire. */
+export const OUTRO_ENCODE = {
+    video: ["-c", "copy", "-f", "mp4", "-movflags", "frag_keyframe+empty_moov+default_base_moof"],
+    audio: ["-c", "copy", "-f", "mp3"],
+};
+/**
+ * The clips, drawn on first use and kept. `clip(kind)` answers the path,
+ * or null when there is no ffmpeg to make one, in which case a channel
+ * that ends simply closes as it used to.
+ */
+export class Outro {
+    options;
+    made = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    clip(kind) {
+        let pending = this.made.get(kind);
+        if (!pending) {
+            pending = Promise.resolve().then(() => this.make(kind)).catch(() => null);
+            this.made.set(kind, pending);
+            // A clip that could not be made is tried again next time, not remembered.
+            void pending.then((path) => { if (path === null)
+                this.made.delete(kind); });
+        }
+        return pending;
+    }
+    make(kind) {
+        mkdirSync(this.options.dir, { recursive: true });
+        const path = join(this.options.dir, kind === "video" ? `outro-v${OUTRO_VERSION}.mp4` : `outro-v${OUTRO_VERSION}.mp3`);
+        if (existsSync(path) && statSync(path).size > 1000)
+            return path;
+        const [command, ...prefix] = this.options.ffmpeg;
+        if (!command)
+            return null;
+        const args = ["-hide_banner", "-loglevel", "error", "-y"];
+        if (kind === "video") {
+            const picture = join(this.options.dir, `outro-v${OUTRO_VERSION}.png`);
+            writeFileSync(picture, encodePng(drawOutro()));
+            args.push("-loop", "1", "-framerate", "30", "-i", picture, "-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo", "-t", String(OUTRO_SECONDS), "-c:v", "libx264", "-preset", "veryfast", "-tune", "stillimage", "-pix_fmt", "yuv420p", "-r", "30", "-g", "30", "-keyint_min", "30", "-c:a", "aac", "-b:a", "64k", "-shortest", "-movflags", "+faststart", path);
+        }
+        else {
+            // Two soft notes, then quiet: something to hear on a channel with no picture.
+            args.push("-f", "lavfi", "-i", `aevalsrc=0.18*sin(2*PI*523.25*t)*exp(-2.5*t)+0.18*sin(2*PI*392*t)*exp(-2.5*max(t-0.7\\,0))*gte(t\\,0.7):s=44100:d=${OUTRO_SECONDS}`, "-c:a", "libmp3lame", "-b:a", "128k", path);
+        }
+        const run = spawnSync(command, [...prefix, ...args], { timeout: 60_000 });
+        if (run.error || run.status !== 0 || !existsSync(path)) {
+            this.options.onEvent?.(`  the outro could not be made${run.stderr ? `: ${run.stderr.toString("utf8").trim().split("\n").pop() ?? ""}` : ""}`);
+            return null;
+        }
+        this.options.onEvent?.(`  outro drawn: ${path}`);
+        return path;
+    }
+}

package/dist/partyline.d.ts

@@ -261,7 +261,9 @@ export declare class PartyLine {
      * voice of whoever typed them. False when nobody is on the phone there,
      * which is most of the time and costs nothing.
      */
-    say(code: string, text: string, voice: string): Promise<boolean>;
+    say(code: string, text: string, voice: string, settings?: {
+        api_key_ref: string;
+    }): Promise<boolean>;
     /** Whether anybody is on the phone in a room, before a line is worth reading. */
     hasCallers(code: string): boolean;
     /**

package/dist/partyline.js

@@ -589,7 +589,7 @@ export class PartyLine {
      * voice of whoever typed them. False when nobody is on the phone there,
      * which is most of the time and costs nothing.
      */
-    async say(code, text, voice) {
+    async say(code, text, voice, settings) {
         const room = this.rooms.get(code);
         if (!room || room.conferenceId === null || room.callers === 0)
             return false;
@@ -599,6 +599,8 @@ export class PartyLine {
         const answer = await this.request(`/conferences/${encodeURIComponent(room.conferenceId)}/actions/speak`, {
             payload: said,
             voice: voice || this.voice,
+            // An ElevenLabs voice needs the key Telnyx holds for it, by name.
+            ...(settings ? { voice_settings: settings } : {}),
         });
         return answer !== null;
     }

package/dist/profile.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `nixamp profile` and `nixamp voices` -- who the rooms know you as, from
+ * the terminal, and the voices a line can be read in.
+ *
+ * The same route the Account panel uses (`/api/v1/me/handle`), signed in
+ * as this machine is. The MCP tools of the same names are these functions
+ * with a different front.
+ */
+import { type Session } from "./session.ts";
+export interface Persona {
+    handle: string;
+    voice: string;
+    profile: string;
+    chosen: boolean;
+    /** The voice a line of theirs would be read in right now. */
+    spoken?: string;
+}
+export interface Pools {
+    provider: string;
+    female: string[];
+    male: string[];
+}
+export type Answer<T> = {
+    ok: true;
+    body: T;
+} | {
+    ok: false;
+    status: number;
+    error: string;
+};
+export declare function readPersona(session: Pick<Session, "site" | "token">, fetcher?: typeof fetch): Promise<Answer<Persona>>;
+export declare function writePersona(session: Pick<Session, "site" | "token">, wanted: {
+    handle?: string;
+    voice?: string;
+    profile?: string;
+}, fetcher?: typeof fetch): Promise<Answer<Persona>>;
+export declare function readVoices(session: Pick<Session, "site" | "token">, fetcher?: typeof fetch): Promise<Answer<Pools>>;
+/** A persona, as the terminal says it. */
+export declare function personaLines(persona: Persona): string[];
+export interface ProfileDeps {
+    fetcher?: typeof fetch;
+    session?: Pick<Session, "site" | "token"> | null;
+}
+export declare function profile(argv: string[], deps?: ProfileDeps): Promise<number>;
+export declare function voices(argv: string[], deps?: ProfileDeps): Promise<number>;

package/dist/profile.js

@@ -0,0 +1,148 @@
+/**
+ * `nixamp profile` and `nixamp voices` -- who the rooms know you as, from
+ * the terminal, and the voices a line can be read in.
+ *
+ * The same route the Account panel uses (`/api/v1/me/handle`), signed in
+ * as this machine is. The MCP tools of the same names are these functions
+ * with a different front.
+ */
+import { readSession } from "./session.js";
+const HELP = `nixamp profile — who the rooms know you as.
+
+  nixamp profile                       your handle, voice and OpenProfile
+  nixamp profile --handle chovy        the name on every line you say
+  nixamp profile --voice female        the voice your lines are read in on the phone:
+                                       female, male, any, or a voice id (see \`nixamp voices\`)
+  nixamp profile --profile URL         your OpenProfile.md; its Voice, Gender or Pronouns
+                                       decide the voice when you set none here
+  nixamp profile --json                as JSON
+  nixamp voices                        the voices this nixamp.com reads lines in
+
+When somebody is on the phone in a live room, every trollbox line is read
+to them in the author's voice: the one set here, else the OpenProfile's,
+else one picked for the account and kept. Two people in a room are two
+different voices.
+`;
+function headers(session) {
+    return { authorization: `Bearer ${session.token}`, "content-type": "application/json" };
+}
+export async function readPersona(session, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/me/handle`, { headers: headers(session) });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+        return { ok: true, body };
+    }
+    catch (error) {
+        return { ok: false, status: 0, error: `could not reach ${session.site}: ${error.message}` };
+    }
+}
+export async function writePersona(session, wanted, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/me/handle`, {
+            method: "PUT",
+            headers: headers(session),
+            body: JSON.stringify(wanted),
+        });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+        return { ok: true, body };
+    }
+    catch (error) {
+        return { ok: false, status: 0, error: `could not reach ${session.site}: ${error.message}` };
+    }
+}
+export async function readVoices(session, fetcher = fetch) {
+    try {
+        const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/voices`, { headers: headers(session) });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+        return { ok: true, body };
+    }
+    catch (error) {
+        return { ok: false, status: 0, error: `could not reach ${session.site}: ${error.message}` };
+    }
+}
+/** A persona, as the terminal says it. */
+export function personaLines(persona) {
+    const voice = persona.voice === "female" ? "a woman's voice"
+        : persona.voice === "male" ? "a man's voice"
+            : persona.voice ? `the voice ${persona.voice}`
+                : persona.profile ? "whatever your OpenProfile says, else one picked for you"
+                    : "one picked for you";
+    return [
+        persona.chosen ? `You are ${persona.handle} in every room.` : `Rooms call you ${persona.handle} until you pick a handle (--handle).`,
+        `On the phone your lines are read in ${voice}${persona.spoken ? ` (${persona.spoken})` : ""}.`,
+        persona.profile ? `OpenProfile: ${persona.profile}` : "No OpenProfile set (--profile URL).",
+    ];
+}
+function flag(argv, name) {
+    const at = argv.indexOf(name);
+    return at === -1 ? undefined : argv[at + 1];
+}
+export async function profile(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 wanted = {};
+    for (const [name, key] of [["--handle", "handle"], ["--voice", "voice"], ["--profile", "profile"]]) {
+        if (argv.includes(name)) {
+            const value = flag(argv, name);
+            if (value === undefined || value.startsWith("--")) {
+                console.error(`nixamp: ${name} needs a value.`);
+                return 64;
+            }
+            wanted[key] = value;
+        }
+    }
+    const answer = Object.keys(wanted).length > 0 ? await writePersona(session, wanted, fetcher) : await readPersona(session, fetcher);
+    if (!answer.ok) {
+        console.error(`nixamp: ${answer.error}`);
+        return 1;
+    }
+    if (argv.includes("--json")) {
+        console.log(JSON.stringify(answer.body, null, 2));
+        return 0;
+    }
+    for (const line of personaLines(answer.body))
+        console.log(line);
+    return 0;
+}
+export async function voices(argv, deps = {}) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        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 answer = await readVoices(session, deps.fetcher ?? fetch);
+    if (!answer.ok) {
+        console.error(`nixamp: ${answer.error}`);
+        return 1;
+    }
+    if (argv.includes("--json")) {
+        console.log(JSON.stringify(answer.body, null, 2));
+        return 0;
+    }
+    console.log(`Voices: ${answer.body.provider}. Set one with \`nixamp profile --voice <id>\`, or --voice female/male to be given one of these and keep it.`);
+    console.log("  Women:");
+    for (const one of answer.body.female)
+        console.log(`    ${one}`);
+    console.log("  Men:");
+    for (const one of answer.body.male)
+        console.log(`    ${one}`);
+    return 0;
+}

package/dist/rtmp-in.js

@@ -70,7 +70,12 @@ export class RtmpListeners {
         if (this.running.get(slot.port) !== child)
             return;
         this.running.delete(slot.port);
-        channel?.close();
+        // The publisher went: the outro plays for whoever is still there, and
+        // whoever joins in the next hour, before the channel closes.
+        if (channel?.finish)
+            channel.finish();
+        else
+            channel?.close();
         if (!this.stopped)
             this.arm(slot);
     }

package/dist/server.d.ts

@@ -32,7 +32,7 @@ import { Rooms } from "./rooms.ts";
 import { Trollbox } from "./trollbox.ts";
 import { Speech } from "./speech.ts";
 import { Captions } from "./captions.ts";
-import { Profiles } from "./voices.ts";
+import { Profiles, Voices } from "./voices.ts";
 import { type Codecs } from "./audio.ts";
 import { type Tools, type Track } from "./audio.ts";
 import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
@@ -701,6 +701,8 @@ export interface HandlerOptions {
     speech?: Speech;
     /** Other people's OpenProfiles, for the voice their lines are read in. */
     profiles?: Profiles;
+    /** The voices lines are read in: ElevenLabs when Telnyx holds the key, Kokoro otherwise. */
+    voices?: Voices;
     /** Tickets: a paid pass to one event's room. Absent means every show is free. */
     tickets?: Tickets;
     /**

package/dist/server.js

@@ -67,7 +67,8 @@ import { Rooms } from "./rooms.js";
 import { Trollbox, TrollboxError, fallbackHandle, roomFor } from "./trollbox.js";
 import { MAX_BYTES as SPEECH_BYTES, Speech, SpeechError, isWav, languageOf } from "./speech.js";
 import { Captions } from "./captions.js";
-import { Profiles, spokenLine, telnyxVoiceFor, voicesFromEnv } from "./voices.js";
+import { Outro } from "./outro.js";
+import { Profiles, Voices, spokenLine, spokenVoiceFor } from "./voices.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
 import { isRemote, isTransportStream, playsInBrowser, sourceLabel } from "./sources.js";
@@ -2212,10 +2213,26 @@ export function createHandler(engine, options) {
             void (async () => {
                 const persona = (await options.handles?.persona(authorId)) ?? { handle, voice: "", profile: "" };
                 const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
-                const voice = telnyxVoiceFor({ userId: authorId, voice: persona.voice, profile }, voicesFromEnv());
-                await partyLine.say(code, spokenLine(handle, body), voice);
+                const pools = options.voices ? await options.voices.pools() : { provider: "kokoro", female: [], male: [] };
+                const spoken = spokenVoiceFor({ userId: authorId, voice: persona.voice, profile }, pools);
+                await partyLine.say(code, spokenLine(handle, body), spoken.voice, spoken.settings);
             })().catch(() => undefined);
         };
+        /*
+         * The voices a line can be read in, for whoever wants to pick one by
+         * id: which provider, and the women's and the men's pools. Signed in,
+         * like the profile it feeds.
+         */
+        if (path === "/api/v1/voices" && options.accounts) {
+            const who = await options.accounts.whoIs(tokenFrom(request.headers));
+            if (who === null) {
+                json(response, 401, { error: "not signed in" });
+                return;
+            }
+            const pools = options.voices ? await options.voices.pools() : { provider: "kokoro", female: [], male: [] };
+            json(response, 200, { provider: pools.provider, female: pools.female, male: pools.male });
+            return;
+        }
         /*
          * The trollbox: the chat for one live room, keyed by the server and
          * the channel so every viewer of a stream is in the same box whichever
@@ -2366,7 +2383,12 @@ export function createHandler(engine, options) {
             // be sent alone; what is not sent is kept.
             if (request.method === "GET") {
                 const persona = await handles.persona(who.id);
-                json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "" });
+                // And the voice a line of theirs would be read in right now, so the
+                // panel and the CLI can say it rather than describe the rule.
+                const pools = options.voices ? await options.voices.pools() : null;
+                const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
+                const spoken = pools ? spokenVoiceFor({ userId: who.id, voice: persona.voice, profile }, pools).voice : "";
+                json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "", spoken });
                 return;
             }
             if (request.method === "PUT" || request.method === "POST") {
@@ -2833,6 +2855,8 @@ export function createHandler(engine, options) {
                     // A picture of it, and a line about it, where there is one.
                     art: artOf(one),
                     about: one.about ?? "",
+                    // Over, with the outro playing: the page says so rather than "LIVE".
+                    ...(one.ended ? { ended: one.ended } : {}),
                 })),
                 // Anything re-streamed into this server is a live stream too, and was
                 // sitting in the middle of the playlist among the files -- which is
@@ -4705,8 +4729,14 @@ export async function serve(argv, version = "0.1.0") {
     });
     // The pictures of channels, taken once each and kept while the channel is on.
     const art = new ArtCache();
+    // What a channel plays once its show is over: drawn here, once, by the
+    // same ffmpeg that carries the channels. No ffmpeg, no outro, and a show
+    // that ends closes its channel as before.
+    const outro = new Outro({ ffmpeg: tools.ffmpeg, dir: join(stateDir(), "outro"), onEvent: (message) => console.log(message) });
     const channels = new Channels({
         ffmpeg: tools.ffmpeg,
+        ...(tools.carries ? { outro: (kind) => outro.clip(kind) } : {}),
+        onOutro: (info) => console.log(`  "${info.id}" has ended; the outro plays for an hour.`),
         onStart: (info) => console.log(`  ${info.name} is publishing to "${info.id}" (${info.format} over ${info.via}).`),
         onEnd: (info) => {
             console.log(`  "${info.id}" stopped.`);
@@ -5224,8 +5254,14 @@ export async function serve(argv, version = "0.1.0") {
         ...(rooms ? { rooms } : {}),
         ...(trollbox ? { trollbox } : {}),
         ...(speech ? { speech } : {}),
-        // Other people's OpenProfiles, read for the voice a line is spoken in.
+        // Other people's OpenProfiles, read for the voice a line is spoken in,
+        // and the voices to speak in: ElevenLabs when the Telnyx account holds
+        // the key for it (an integration secret named "elevenlabs"), Kokoro
+        // otherwise. Nothing to configure on the deployment for either.
         ...(accounts ? { profiles: new Profiles() } : {}),
+        ...(accounts && process.env["TELNYX_API_KEY"]
+            ? { voices: new Voices({ telnyxApiKey: process.env["TELNYX_API_KEY"], onEvent: (message) => console.log(message) }) }
+            : {}),
         ...(tickets ? { tickets } : {}),
         ...(authServer ? { authServer } : {}),
         ...(parties ? { parties } : {}),