nixamp 0.26.6 → 0.27.0

package/dist/server.d.ts

@@ -1,4 +1,6 @@
 import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { SharedTranslations } from "./shared-translation.ts";
+import { TranslationPasses } from "./translation-passes.ts";
 import { LiveVoice } from "./live-voice.ts";
 import { Connections } from "./connections.ts";
 import { Broadcaster, type Destination, type EncoderSettings } from "./broadcast.ts";
@@ -525,6 +527,8 @@ export declare function joinSubject(url: URL, options: Pick<HandlerOptions, "dir
 export declare function joinDocument(shell: string, subject: JoinSubject, site: string): string;
 export interface HandlerOptions {
     web: string | null;
+    /** Branded clients on this same backend, keyed by an explicitly configured host. */
+    webSites?: ReadonlyMap<string, import("./web-sites.ts").WebSite>;
     media: boolean;
     version: string;
     /** The key from the share link, or null to serve to anyone who can connect. */
@@ -705,6 +709,8 @@ export interface HandlerOptions {
     /** Speech to text: a line said out loud, heard here. Needs the optional model. */
     speech?: Speech;
     liveVoice?: LiveVoice;
+    translationPasses?: TranslationPasses;
+    sharedTranslations?: SharedTranslations;
     /** Translation: texts in another language, by a model here. The same optional library. */
     translator?: Translator;
     /** The transcript store: what was heard, kept under the media's identity. Where the accounts are. */

package/dist/server.js

@@ -18,6 +18,8 @@ import { spawn, spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { Readable } from "node:stream";
 import { pipeline as pipeStream } from "node:stream/promises";
+import { SharedTranslations } from "./shared-translation.js";
+import { TranslationPasses } from "./translation-passes.js";
 import { LiveVoice, LIVE_VOICE_LANGUAGES, LIVE_VOICE_MODEL } from "./live-voice.js";
 import { Connections } from "./connections.js";
 import { Broadcaster, DEFAULT_ENCODER, PRESETS, redact, } from "./broadcast.js";
@@ -1355,6 +1357,9 @@ export function createHandler(engine, options) {
     return async function handle(request, response) {
         const url = new URL(request.url ?? "/", "http://localhost");
         const path = url.pathname;
+        const webSite = options.webSites?.get((request.headers.host ?? "").toLowerCase());
+        const web = webSite?.web ?? options.web;
+        const eventSite = webSite?.site ?? options.invites?.site;
         const key = options.key ?? null;
         const behindProxy = options.behindProxy ?? false;
         const listenKey = options.listenKey ?? null;
@@ -1444,7 +1449,7 @@ export function createHandler(engine, options) {
             ...(options.layouts ? { layouts: options.layouts } : {}),
             ...(options.rooms ? { rooms: options.rooms } : {}),
             ...(options.tickets ? { tickets: options.tickets } : {}),
-            ...(options.invites?.site ? { site: options.invites.site } : {}),
+            ...(eventSite ? { site: eventSite } : {}),
             ...(options.invites?.email ? { email: options.invites.email } : {}),
         }))
             return;
@@ -2325,6 +2330,117 @@ export function createHandler(engine, options) {
             }
             return;
         }
+        if (path === "/api/v1/speech/shared" && request.method === "POST") {
+            try {
+                const service = options.sharedTranslations;
+                const who = await options.accounts?.whoIs(tokenFrom(request.headers));
+                if (!who)
+                    throw new SpeechError("Sign in to translate live audio.", 401);
+                if (!service)
+                    throw new SpeechError("Shared translation is unavailable.", 503);
+                const caller = callerOf(request.headers, request.socket.remoteAddress, options.behindProxy ?? false);
+                if (!guard.check(`shared-join:${who.id}`, { allowed: 10, windowMs: 60_000 }).ok || !guard.check(`shared-ip:${caller}`, { allowed: 30, windowMs: 60_000 }).ok)
+                    throw new SpeechError("Too many live translation joins.", 429);
+                if (!request.headers["content-type"]?.startsWith("application/json"))
+                    throw new SpeechError("Send a live source as JSON.", 415);
+                let body;
+                try {
+                    body = JSON.parse(await readBody(request, 4096));
+                }
+                catch {
+                    throw new SpeechError("Choose a live source and language.", 400);
+                }
+                if (typeof body?.source !== "string" || typeof body.language !== "string")
+                    throw new SpeechError("Choose a live source and language.", 400);
+                const queued = [];
+                let finished = false;
+                const send = (event) => {
+                    if (!response.headersSent) {
+                        queued.push(event);
+                        return;
+                    }
+                    if (response.destroyed || response.writableLength > 512_000)
+                        throw new Error("slow listener");
+                    response.write(`data: ${JSON.stringify(event)}\n\n`);
+                };
+                const leave = await service.join(body.source, body.language, who.id, send, () => { finished = true; if (response.headersSent)
+                    response.end(); });
+                if (response.destroyed) {
+                    leave();
+                    return;
+                }
+                response.writeHead(200, { ...CORS, "content-type": "text/event-stream", "cache-control": "no-store", "x-accel-buffering": "no" });
+                for (const event of queued)
+                    send(event);
+                if (finished) {
+                    leave();
+                    response.end();
+                    return;
+                }
+                const heartbeat = setInterval(() => { if (!response.destroyed)
+                    response.write(": listening\n\n"); }, 10_000);
+                response.once("close", () => { clearInterval(heartbeat); leave(); });
+            }
+            catch (error) {
+                if (response.headersSent)
+                    response.end();
+                else
+                    json(response, error instanceof SpeechError ? error.status : 502, { error: error instanceof SpeechError ? error.message : "Shared translation is unavailable." });
+            }
+            return;
+        }
+        if (path === "/api/v1/translation-passes" || path.startsWith("/api/v1/translation-passes/")) {
+            response.setHeader("cache-control", "no-store");
+            try {
+                const caller = callerOf(request.headers, request.socket.remoteAddress, options.behindProxy ?? false);
+                if (!guard.check(`translation-pass-ip:${caller}`, { allowed: 120, windowMs: 60_000 }).ok)
+                    throw new SpeechError("Too many purchase requests.", 429);
+                const service = options.translationPasses;
+                if (!service || !options.accounts) {
+                    if (path === "/api/v1/translation-passes" && request.method === "GET")
+                        json(response, 200, { required: false, available: false, balanceMicros: 0, expires: null, plans: [], coins: [], orders: [] });
+                    else
+                        json(response, 503, { error: "Translation checkout is unavailable." });
+                    return;
+                }
+                const who = await options.accounts.whoIs(tokenFrom(request.headers));
+                if (path === "/api/v1/translation-passes" && request.method === "GET") {
+                    json(response, 200, await service.access(who?.id));
+                    return;
+                }
+                if (!who)
+                    throw new SpeechError("Sign in to buy translated audio.", 401);
+                if (!guard.check(`translation-pass-account:${who.id}`, { allowed: 30, windowMs: 60_000 }).ok)
+                    throw new SpeechError("Too many purchase requests.", 429);
+                if (path === "/api/v1/translation-passes/checkout" && request.method === "POST") {
+                    if (!request.headers["content-type"]?.startsWith("application/json"))
+                        throw new SpeechError("Send a purchase as JSON.", 415);
+                    if (!guard.check(`translation-checkout-ip:${caller}`, { allowed: 10, windowMs: 3600_000 }).ok)
+                        throw new SpeechError("Too many new checkouts. Resume your pending purchase.", 429);
+                    let body;
+                    try {
+                        body = JSON.parse(await readBody(request, 1024));
+                    }
+                    catch {
+                        throw new SpeechError("Choose a translation pass.", 400);
+                    }
+                    if (!body || typeof body !== "object" || typeof body["plan"] !== "string" || typeof body["coin"] !== "string" || typeof body["requestKey"] !== "string")
+                        throw new SpeechError("Choose a translation pass and payment currency.", 400);
+                    json(response, 200, await service.checkout(who.id, body["plan"], body["coin"], body["requestKey"]));
+                    return;
+                }
+                const order = path.match(/^\/api\/v1\/translation-passes\/orders\/([^/]+)$/);
+                if (order && request.method === "GET") {
+                    json(response, 200, await service.check(who.id, order[1]));
+                    return;
+                }
+                json(response, 405, { error: "GET your balance or purchase status; POST a checkout." });
+            }
+            catch (error) {
+                json(response, error instanceof SpeechError ? error.status : 502, { error: error instanceof SpeechError ? error.message : "Translation purchases are temporarily unavailable." });
+            }
+            return;
+        }
         /*
          * Speech to text: a WAV in, the words out. Signed in only -- the ear
          * costs CPU and a trollbox line needs a name anyway -- and, given a
@@ -4809,8 +4925,8 @@ export function createHandler(engine, options) {
             json(response, 404, { error: "no such endpoint" });
             return;
         }
-        if (options.web !== null) {
-            const direct = safeJoin(options.web, path);
+        if (web !== null) {
+            const direct = safeJoin(web, path);
             if (direct === null) {
                 json(response, 400, { error: "bad path" });
                 return;
@@ -4821,8 +4937,8 @@ export function createHandler(engine, options) {
             else if (isFile(join(direct, "index.html")))
                 file = join(direct, "index.html");
             // A single-page app: any unknown path is the shell, and the client routes.
-            else if (isFile(join(options.web, "index.html")))
-                file = join(options.web, "index.html");
+            else if (isFile(join(web, "index.html")))
+                file = join(web, "index.html");
             if (file !== null) {
                 if (file.endsWith("index.html") && path.startsWith("/live/") && options.events) {
                     try {
@@ -4835,7 +4951,7 @@ export function createHandler(engine, options) {
                         if (event && (await options.events.canAccess(event, account?.id) || invited)) {
                             const shell = readIfPossible(file);
                             if (shell !== null) {
-                                html(response, 200, eventDocument(shell, event, options.invites?.site ?? "https://backtoschool.help"));
+                                html(response, 200, eventDocument(shell, event, eventSite ?? "https://backtoschool.help"));
                                 return;
                             }
                         }
@@ -4846,7 +4962,7 @@ export function createHandler(engine, options) {
                     const subject = joinSubject(url, options);
                     const shell = subject ? readIfPossible(file) : null;
                     if (subject && shell !== null) {
-                        html(response, 200, joinDocument(shell, subject, options.invites?.site ?? "https://nixamp.com"));
+                        html(response, 200, joinDocument(shell, subject, eventSite ?? "https://nixamp.com"));
                         return;
                     }
                 }
@@ -5257,6 +5373,8 @@ export async function serve(argv, version = "0.1.0") {
     if (!options.noJingle)
         playJingle(tools);
     const web = options.web !== null ? resolve(options.web) : defaultWebDir();
+    const { webSitesFromEnv } = await import("./web-sites.js");
+    const webSites = webSitesFromEnv();
     // The same keys this port used last time, so a link somebody was given
     // still works after a restart -- and a server is restarted to pick up a new
     // version, which is to say often. `--new-key` mints a fresh pair and forgets
@@ -5418,8 +5536,15 @@ export async function serve(argv, version = "0.1.0") {
     // the first person to speak does not wait for the model to arrive; a box
     // without the optional model never says it is ready, and answers 503.
     const speech = accounts && process.env["NIXAMP_STT"] !== "off" ? new Speech() : undefined;
+    // Account servers meter paid providers by default, including when checkout
+    // is temporarily unconfigured. Self-hosters can explicitly sponsor usage.
+    const translationPasses = accounts && pool && process.env["NIXAMP_TRANSLATION_BILLING"] !== "off"
+        ? new TranslationPasses({ db: pool, key: process.env["COINPAY_X402_KEY"] ?? "", site: nixampSite }) : undefined;
+    if (translationPasses)
+        void translationPasses.access().catch(() => console.error("nixamp: translation checkout could not warm; it will retry on demand"));
     const liveVoice = accounts && process.env["NIXAMP_DUBBING"] !== "off" ? new LiveVoice({
         ...(pool ? { db: pool } : {}),
+        ...(translationPasses ? { billing: translationPasses } : {}),
         dailyChars: Number(process.env["NIXAMP_DUB_DAILY_CHARS"] ?? 200_000),
         dailyAudioSeconds: Number(process.env["NIXAMP_DUB_DAILY_AUDIO_SECONDS"] ?? 86_400),
         userDailyChars: Number(process.env["NIXAMP_DUB_USER_DAILY_CHARS"] ?? 120_000),
@@ -5435,6 +5560,7 @@ export async function serve(argv, version = "0.1.0") {
     // names pairs to load at boot (en-de,en-sv) so the first line does not
     // wait; NIXAMP_MT=off turns it off.
     const translator = accounts && process.env["NIXAMP_MT"] !== "off" ? new Translator() : undefined;
+    const sharedTranslations = liveVoice && translator ? new SharedTranslations({ voice: liveVoice, translator, ...(translationPasses ? { billing: translationPasses } : {}) }) : undefined;
     if (translator) {
         const warm = (process.env["NIXAMP_MT_WARM"] ?? "").split(",").map((one) => one.trim()).filter(Boolean);
         if (warm.length > 0) {
@@ -5820,6 +5946,7 @@ export async function serve(argv, version = "0.1.0") {
     let publishable_;
     const server = createServer(engine, {
         web,
+        webSites,
         media: options.media,
         owner,
         channels,
@@ -5909,6 +6036,8 @@ export async function serve(argv, version = "0.1.0") {
         ...(trollbox ? { trollbox } : {}),
         ...(speech ? { speech } : {}),
         ...(liveVoice ? { liveVoice } : {}),
+        ...(translationPasses ? { translationPasses } : {}),
+        ...(sharedTranslations ? { sharedTranslations } : {}),
         ...(translator ? { translator } : {}),
         ...(transcripts ? { transcripts } : {}),
         ...(translations ? { translations } : {}),

package/dist/shared-translation.d.ts

@@ -0,0 +1,55 @@
+import { type Caption } from "./live-interpreter.ts";
+import { LiveVoice } from "./live-voice.ts";
+import type { Translator } from "./translate.ts";
+import type { TranslationMeter } from "./translation-passes.ts";
+export declare function publicStreamAddress(address: string): boolean;
+export declare function sharedSource(raw: string): URL;
+export interface LiveInput {
+    stop(): void;
+}
+export type OpenLiveInput = (source: URL, pcm: (bytes: Buffer) => void, ended: () => void, signal: AbortSignal) => Promise<LiveInput>;
+/** Resolve once and pin that public address; no redirects or ffmpeg URL fetches. */
+export declare function liveInput(ffmpeg?: string[]): OpenLiveInput;
+export type SharedEvent = {
+    type: "status";
+    listeners: number;
+} | {
+    type: "line";
+    id: string;
+    line: Caption;
+} | {
+    type: "audio";
+    id: string;
+    data: string;
+} | {
+    type: "end";
+    id: string;
+} | {
+    type: "error";
+    error: string;
+};
+type Member = {
+    by: string;
+    send: (event: SharedEvent) => void;
+    close: () => void;
+};
+export declare class SharedTranslations {
+    private readonly options;
+    private readonly feeds;
+    constructor(options: {
+        voice: LiveVoice;
+        translator: Pick<Translator, "translate">;
+        billing?: TranslationMeter;
+        open?: OpenLiveInput;
+    });
+    get size(): number;
+    join(raw: string, language: string, by: string, send: Member["send"], close: () => void): Promise<() => void>;
+    private leave;
+    private checkMembers;
+    private broadcast;
+    private stop;
+    private make;
+    private start;
+    private speak;
+}
+export {};

package/dist/shared-translation.js

@@ -0,0 +1,335 @@
+/** One live source/language pipeline, paid access for every listening account.
+ * Browsers receive the same PCM, never upload a replacement for a public feed. */
+import { createHash, randomUUID } from "node:crypto";
+import { lookup } from "node:dns/promises";
+import { BlockList, isIP } from "node:net";
+import http from "node:http";
+import https from "node:https";
+import { spawn } from "node:child_process";
+import { Interpreter } from "./live-interpreter.js";
+import { LIVE_VOICE_LANGUAGES } from "./live-voice.js";
+import { SpeechError } from "./speech.js";
+const blocked = new BlockList();
+for (const [ip, bits] of [["0.0.0.0", 8], ["10.0.0.0", 8], ["100.64.0.0", 10], ["127.0.0.0", 8], ["169.254.0.0", 16], ["172.16.0.0", 12], ["192.0.0.0", 24], ["192.0.2.0", 24], ["192.168.0.0", 16], ["198.18.0.0", 15], ["198.51.100.0", 24], ["203.0.113.0", 24], ["224.0.0.0", 4], ["240.0.0.0", 4]])
+    blocked.addSubnet(ip, bits, "ipv4");
+const v6global = new BlockList();
+v6global.addSubnet("2000::", 3, "ipv6");
+blocked.addSubnet("2001:db8::", 32, "ipv6");
+blocked.addSubnet("2002::", 16, "ipv6");
+blocked.addSubnet("2001::", 32, "ipv6");
+export function publicStreamAddress(address) {
+    const family = isIP(address);
+    return family === 4 ? !blocked.check(address, "ipv4") : family === 6 && v6global.check(address, "ipv6") && !blocked.check(address, "ipv6");
+}
+export function sharedSource(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new SpeechError("Choose a live Nixamp channel.", 400);
+    }
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash || !/^\/api\/channels\/[\w-]{1,80}$/.test(url.pathname) || [...url.searchParams.keys()].some(key => key !== "k"))
+        throw new SpeechError("Choose a live Nixamp channel.", 400);
+    if (url.toString().length > 2048)
+        throw new SpeechError("Invalid live source.", 400);
+    url.searchParams.sort();
+    return url;
+}
+/** Resolve once and pin that public address; no redirects or ffmpeg URL fetches. */
+export function liveInput(ffmpeg = ["ffmpeg"]) {
+    return async (source, pcm, ended, signal) => {
+        const hostname = source.hostname.replace(/^\[|\]$/g, "");
+        const addresses = await lookup(hostname, { all: true });
+        if (!addresses.length || addresses.some(one => !publicStreamAddress(one.address)))
+            throw new SpeechError("This live source is not publicly reachable.", 400);
+        signal.throwIfAborted();
+        const selected = addresses[0];
+        const child = spawn(ffmpeg[0], [...ffmpeg.slice(1), "-v", "error", "-nostats", "-protocol_whitelist", "pipe", "-readrate", "1", "-analyzeduration", "500000", "-probesize", "262144", "-i", "pipe:0", "-vn", "-ac", "1", "-ar", "16000", "-f", "s16le", "pipe:1"], { stdio: ["pipe", "pipe", "ignore"] });
+        let stopped = false;
+        const request = (source.protocol === "https:" ? https : http).get(source, {
+            signal, headers: { "user-agent": "Nixamp shared translated audio", accept: "audio/*,video/*,application/octet-stream" },
+            lookup: (_name, options, callback) => { if (typeof options === "object" && options.all)
+                callback(null, [selected]);
+            else
+                callback(null, selected.address, selected.family); },
+        });
+        const stop = () => { if (stopped)
+            return; stopped = true; request.destroy(); child.stdin.destroy(); child.kill("SIGKILL"); signal.removeEventListener("abort", stop); };
+        const end = () => { if (!stopped) {
+            stop();
+            ended();
+        } };
+        signal.addEventListener("abort", stop, { once: true });
+        child.stdout.on("data", pcm);
+        child.on("error", end);
+        child.on("close", end);
+        child.stdin.on("error", end);
+        request.on("response", response => {
+            if (response.statusCode !== 200) {
+                response.destroy();
+                end();
+                return;
+            }
+            response.on("error", end);
+            response.on("end", end);
+            response.pipe(child.stdin);
+        });
+        request.on("error", end);
+        request.setTimeout(15_000, end);
+        return { stop };
+    };
+}
+export class SharedTranslations {
+    options;
+    feeds = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    get size() { return this.feeds.size; }
+    async join(raw, language, by, send, close) {
+        if (!this.options.voice.available())
+            throw new SpeechError("Translated audio is unavailable.", 503);
+        const source = sharedSource(raw);
+        if (!LIVE_VOICE_LANGUAGES.has(language))
+            throw new SpeechError("Choose a supported audio language.", 400);
+        await this.options.billing?.require(by);
+        const connections = [...this.feeds.values()].reduce((total, feed) => total + [...feed.members].filter(member => member.by === by).length, 0);
+        if (connections >= 2)
+            throw new SpeechError("Translated audio is already open in two players for this account.", 429);
+        const id = `dub-${createHash("sha256").update(`${source}|${language}`).digest("hex").slice(0, 40)}`;
+        let feed = this.feeds.get(id);
+        if (!feed) {
+            if (this.feeds.size >= 4)
+                throw new SpeechError("Live translation is busy. Try again shortly.", 429);
+            feed = this.make(id, source, language);
+            this.feeds.set(id, feed);
+            const current = feed;
+            current.heartbeat = setInterval(() => void this.checkMembers(current), 10_000);
+            current.heartbeat.unref?.();
+        }
+        if (feed.members.size >= 1000)
+            throw new SpeechError("This translated stream is full. Try again shortly.", 429);
+        const member = { by, send, close };
+        feed.members.add(member);
+        this.broadcast(feed, { type: "status", listeners: feed.members.size });
+        if (feed.members.size === 1 && !feed.input)
+            void this.start(feed);
+        const current = feed;
+        return () => this.leave(current, member);
+    }
+    leave(feed, member) {
+        if (!feed.members.delete(member))
+            return;
+        if (!feed.members.size) {
+            if (feed.heartbeat)
+                clearInterval(feed.heartbeat);
+            feed.controller.abort();
+            feed.input?.stop();
+            feed.interpreter.reset();
+            feed.queue = [];
+            this.feeds.delete(feed.id);
+        }
+        else
+            this.broadcast(feed, { type: "status", listeners: feed.members.size });
+    }
+    async checkMembers(feed) {
+        const accounts = [...new Set([...feed.members].map(member => member.by))];
+        let funded = new Set(accounts), message = "Your translation balance is used up or expired. Buy another pass to continue.";
+        try {
+            if (this.options.billing?.eligible)
+                funded = new Set(await this.options.billing.eligible(accounts));
+            else if (this.options.billing) {
+                const results = await Promise.allSettled(accounts.map(by => this.options.billing.require(by)));
+                funded = new Set(accounts.filter((_by, index) => results[index]?.status === "fulfilled"));
+            }
+        }
+        catch {
+            funded.clear();
+            message = "Your translation balance could not be checked. Try again shortly.";
+        }
+        for (const member of [...feed.members])
+            if (accounts.includes(member.by) && !funded.has(member.by)) {
+                try {
+                    member.send({ type: "error", error: message });
+                }
+                catch { /* disconnected */ }
+                finally {
+                    this.leave(feed, member);
+                    member.close();
+                }
+            }
+    }
+    broadcast(feed, event) {
+        for (const member of [...feed.members]) {
+            try {
+                member.send(event);
+            }
+            catch {
+                this.leave(feed, member);
+                member.close();
+            }
+        }
+    }
+    stop(feed, error) {
+        this.broadcast(feed, { type: "error", error });
+        for (const member of [...feed.members]) {
+            this.leave(feed, member);
+            member.close();
+        }
+    }
+    make(id, source, language) {
+        const feed = { id, source, language, members: new Set(), controller: new AbortController(), reservations: new Map(), queue: [], speaking: false, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() };
+        // Every active account pays the same published access rate. API work is
+        // done once; additional listeners do not trigger recognition or synthesis.
+        feed.meter = {
+            require: async () => { if (!feed.members.size)
+                throw new SpeechError("No listeners.", 410); },
+            reserve: async (_by, kind, units) => {
+                const ids = [];
+                const accounts = [...new Set([...feed.members].map(member => member.by))];
+                const accepted = new Set();
+                const billing = this.options.billing;
+                if (billing?.reserveMany) {
+                    for (const charged of await billing.reserveMany(accounts, kind, units)) {
+                        ids.push(charged.id);
+                        accepted.add(charged.by);
+                    }
+                }
+                else {
+                    const results = await Promise.allSettled(accounts.map(async (account) => ({ by: account, id: await billing?.reserve(account, kind, units) })));
+                    let failure;
+                    for (const result of results) {
+                        if (result.status === "fulfilled") {
+                            accepted.add(result.value.by);
+                            if (result.value.id)
+                                ids.push(result.value.id);
+                        }
+                        else if (!(result.reason instanceof SpeechError) || result.reason.status !== 402)
+                            failure = result.reason;
+                    }
+                    if (failure) {
+                        await Promise.all(ids.map(id => billing.refund(id)));
+                        throw failure;
+                    }
+                }
+                for (const member of [...feed.members])
+                    if (accounts.includes(member.by) && !accepted.has(member.by)) {
+                        try {
+                            member.send({ type: "error", error: "Your translation balance is used up or expired. Buy another pass to continue." });
+                        }
+                        catch { /* disconnected */ }
+                        finally {
+                            this.leave(feed, member);
+                            member.close();
+                        }
+                    }
+                if (!feed.members.size) {
+                    await Promise.all(ids.map(id => this.options.billing.refund(id)));
+                    throw new SpeechError("No funded listeners.", 402);
+                }
+                const reservation = randomUUID();
+                feed.reservations.set(reservation, ids);
+                return reservation;
+            },
+            commit: async (id) => { const ids = feed.reservations.get(id) ?? []; if (this.options.billing?.commitMany)
+                await this.options.billing.commitMany(ids);
+            else
+                await Promise.all(ids.map(id => this.options.billing.commit(id))); feed.reservations.delete(id); },
+            refund: async (id) => { const ids = feed.reservations.get(id) ?? []; if (this.options.billing?.refundMany)
+                await this.options.billing.refundMany(ids);
+            else
+                await Promise.all(ids.map(id => this.options.billing.refund(id))); feed.reservations.delete(id); },
+        };
+        let voices = [];
+        feed.interpreter = new Interpreter({
+            language: () => language, speakers: () => true, voices: () => voices, channel: () => id,
+            status: text => { if (!feed.controller.signal.aborted && !feed.members.size)
+                this.stop(feed, text); },
+            failed: () => this.stop(feed, "Live translation stopped. Enable it again to retry."),
+            lines: lines => {
+                feed.queue.push(...lines);
+                if (feed.queue.length > 24) {
+                    this.stop(feed, "Live translation fell behind. Enable it again to retry.");
+                    return;
+                }
+                if (!feed.speaking)
+                    void this.speak(feed);
+            },
+            fetcher: (async (url, init) => {
+                feed.controller.signal.throwIfAborted();
+                const signal = AbortSignal.any([feed.controller.signal, ...(init?.signal ? [init.signal] : [])]);
+                if (String(url).includes("/speakers")) {
+                    voices = await this.options.voice.voices();
+                    return Response.json(await this.options.voice.hear(new Uint8Array(init?.body), id, signal, feed.meter));
+                }
+                const body = JSON.parse(String(init?.body));
+                return Response.json(await this.options.translator.translate(body.texts, body.from, body.to, { by: id, deadline: Date.now() + 10_000 }));
+            }),
+        });
+        return feed;
+    }
+    async start(feed) {
+        try {
+            const input = await (this.options.open ?? liveInput())(feed.source, bytes => {
+                if (feed.controller.signal.aborted)
+                    return;
+                feed.pending = Buffer.concat([feed.pending, bytes]);
+                while (feed.pending.length >= 64_000) {
+                    const fresh = feed.pending.subarray(0, 64_000);
+                    feed.pending = feed.pending.subarray(64_000);
+                    const pcm = Buffer.concat([feed.previous, fresh]);
+                    feed.previous = pcm.subarray(-128_000);
+                    feed.until += 2000;
+                    if (Math.abs(Date.now() - feed.until) > 2000)
+                        feed.until = Date.now();
+                    const samples = new Float32Array(pcm.length / 2);
+                    for (let index = 0; index < samples.length; index++)
+                        samples[index] = pcm.readInt16LE(index * 2) / 32768;
+                    feed.interpreter.push({ samples, at: feed.until - samples.length / 16, until: feed.until, freshAt: feed.until - 2000 });
+                }
+            }, () => this.stop(feed, "The live source stopped. Enable translated audio again when playback resumes."), feed.controller.signal);
+            if (feed.controller.signal.aborted)
+                input.stop();
+            else
+                feed.input = input;
+        }
+        catch (error) {
+            this.stop(feed, error instanceof SpeechError ? error.message : "The live source could not be opened.");
+        }
+    }
+    async speak(feed) {
+        feed.speaking = true;
+        try {
+            while (feed.queue.length && !feed.controller.signal.aborted) {
+                const line = feed.queue.shift();
+                if (Date.now() - line.until > 12_000)
+                    throw new SpeechError("Live translation fell behind. Enable it again to retry.", 503);
+                const response = await this.options.voice.stream({ text: line.text, language: feed.language, channel: feed.id, speaker: line.speaker, voice: feed.interpreter.tracker.speakers.get(line.speaker ?? "")?.voice }, feed.id, feed.controller.signal, feed.meter);
+                const id = randomUUID();
+                this.broadcast(feed, { type: "line", id, line });
+                const reader = response.body.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        for (let at = 0; at < value.length; at += 16_384)
+                            this.broadcast(feed, { type: "audio", id, data: Buffer.from(value.subarray(at, at + 16_384)).toString("base64") });
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+                this.broadcast(feed, { type: "end", id });
+            }
+        }
+        catch (error) {
+            if (!feed.controller.signal.aborted)
+                this.stop(feed, error instanceof SpeechError ? error.message : "Translated audio was interrupted.");
+        }
+        finally {
+            feed.speaking = false;
+        }
+    }
+}