nixamp 0.27.2 → 0.27.3

package/dist/live-interpreter.d.ts

@@ -49,6 +49,8 @@ export declare class Interpreter {
     private controller;
     private translating;
     private translationController;
+    private recognitionFailures;
+    private translationFailures;
     private translations;
     constructor(options: {
         language: () => string;
@@ -57,7 +59,7 @@ export declare class Interpreter {
         channel: () => string;
         lines: (lines: Caption[]) => void;
         status: (text: string) => void;
-        failed: () => void;
+        failed: (message: string) => void;
         fetcher?: typeof fetch;
     });
     reset(): void;

package/dist/live-interpreter.js

@@ -1,3 +1,4 @@
+import { audioError, transientAudioError } from "./live-recovery.js";
 import { encodeWav } from "./pcm-wav.js";
 /** Match provider labels across overlapping timestamps. A speaker absent from
  * the rolling context gets a new label; pitch alone never identifies someone. */
@@ -67,6 +68,8 @@ export class Interpreter {
     controller = null;
     translating = null;
     translationController = null;
+    recognitionFailures = 0;
+    translationFailures = 0;
     translations = [];
     constructor(options) {
         this.options = options;
@@ -78,6 +81,7 @@ export class Interpreter {
         this.pending = null;
         this.running = null;
         this.translating = null;
+        this.recognitionFailures = this.translationFailures = 0;
         this.translations = [];
         this.committedUntil = null;
         this.tracker.reset();
@@ -92,7 +96,7 @@ export class Interpreter {
         const response = await (this.options.fetcher ?? fetch)(path, { ...init, signal });
         const body = await response.json();
         if (!response.ok)
-            throw new Error(body.error || "Audio translation is unavailable.");
+            throw audioError(body.error || "Audio translation is unavailable.", response.status);
         return body;
     }
     async run(generation) {
@@ -101,74 +105,85 @@ export class Interpreter {
             while (this.pending && generation === this.generation) {
                 const window = this.pending;
                 this.pending = null;
-                if (Date.now() - window.until > 12_000)
-                    continue;
-                const controller = new AbortController();
-                this.controller = controller;
-                const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]);
-                const speakers = this.options.speakers(), target = this.options.language();
-                const heard = await this.json(speakers ? "/api/v1/speech/speakers" : "/api/v1/speech/transcribe?live=1", {
-                    method: "POST", headers: { "content-type": "audio/wav" }, body: new Uint8Array(encodeWav(speakers ? window.samples : window.samples.slice(-80_000))),
-                }, signal);
-                if (generation !== this.generation)
-                    return;
-                const language = heard.language;
-                let lines = [];
-                if (speakers) {
-                    const links = this.tracker.reconcile(heard.turns ?? [], window.at, this.options.voices());
-                    // The watermark follows emitted words, not the newest capture
-                    // interval: an overlapping window can recover audio that arrived
-                    // while recognition/translation was busy. Keep unfinished phrases
-                    // in that overlap so short capture intervals do not split every
-                    // sentence (especially damaging when German changes word order).
-                    const cutoff = this.committedUntil ?? window.freshAt;
-                    const turns = heard.turns ?? [];
-                    for (const [index, turn] of turns.entries()) {
-                        const speaker = links.get(turn.speaker);
-                        const words = turn.words.filter(word => window.at + (word.start + word.end) * 500 >= cutoff &&
-                            (window.at + word.end * 1000 <= window.until - 100 || /[.!?。！？]$/.test(word.text)));
-                        let phrase = [];
-                        const emit = () => {
-                            if (!phrase.length)
-                                return;
-                            lines.push({ channel: this.options.channel(), at: window.at + phrase[0].start * 1000,
-                                until: window.at + phrase.at(-1).end * 1000, text: phrase.map(word => word.text).join(" ").trim(),
-                                language, speaker: speaker.id, voiceProfile: turn.profile });
-                            phrase = [];
-                        };
-                        for (const word of words) {
-                            if (phrase.length && word.start - phrase.at(-1).end >= 0.45)
-                                emit();
-                            phrase.push(word);
-                            if (/[.!?。！？]$/.test(word.text) || phrase.map(word => word.text).join(" ").length >= 400)
+                try {
+                    if (Date.now() - window.until > 12_000)
+                        continue;
+                    const controller = new AbortController();
+                    this.controller = controller;
+                    const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]);
+                    const speakers = this.options.speakers(), target = this.options.language();
+                    const heard = await this.json(speakers ? "/api/v1/speech/speakers" : "/api/v1/speech/transcribe?live=1", {
+                        method: "POST", headers: { "content-type": "audio/wav" }, body: new Uint8Array(encodeWav(speakers ? window.samples : window.samples.slice(-80_000))),
+                    }, signal);
+                    if (generation !== this.generation)
+                        return;
+                    this.recognitionFailures = 0;
+                    const language = heard.language;
+                    let lines = [];
+                    if (speakers) {
+                        const links = this.tracker.reconcile(heard.turns ?? [], window.at, this.options.voices());
+                        // The watermark follows emitted words, not the newest capture
+                        // interval: an overlapping window can recover audio that arrived
+                        // while recognition/translation was busy. Keep unfinished phrases
+                        // in that overlap so short capture intervals do not split every
+                        // sentence (especially damaging when German changes word order).
+                        const cutoff = this.committedUntil ?? window.freshAt;
+                        const turns = heard.turns ?? [];
+                        for (const [index, turn] of turns.entries()) {
+                            const speaker = links.get(turn.speaker);
+                            const words = turn.words.filter(word => window.at + (word.start + word.end) * 500 >= cutoff &&
+                                (window.at + word.end * 1000 <= window.until - 100 || /[.!?。！？]$/.test(word.text)));
+                            let phrase = [];
+                            const emit = () => {
+                                if (!phrase.length)
+                                    return;
+                                lines.push({ channel: this.options.channel(), at: window.at + phrase[0].start * 1000,
+                                    until: window.at + phrase.at(-1).end * 1000, text: phrase.map(word => word.text).join(" ").trim(),
+                                    language, speaker: speaker.id, voiceProfile: turn.profile });
+                                phrase = [];
+                            };
+                            for (const word of words) {
+                                if (phrase.length && word.start - phrase.at(-1).end >= 0.45)
+                                    emit();
+                                phrase.push(word);
+                                if (/[.!?。！？]$/.test(word.text) || phrase.map(word => word.text).join(" ").length >= 400)
+                                    emit();
+                            }
+                            if (phrase.length && (index < turns.length - 1 ||
+                                window.until - (window.at + phrase.at(-1).end * 1000) >= 350 ||
+                                window.until - (window.at + phrase[0].start * 1000) >= 3000))
                                 emit();
                         }
-                        if (phrase.length && (index < turns.length - 1 ||
-                            window.until - (window.at + phrase.at(-1).end * 1000) >= 350 ||
-                            window.until - (window.at + phrase[0].start * 1000) >= 3000))
-                            emit();
                     }
+                    else if (heard.text) {
+                        lines = [{ channel: this.options.channel(), at: window.freshAt, until: window.until, text: heard.text, language }];
+                    }
+                    if (!lines.length)
+                        continue;
+                    this.committedUntil = Math.max(this.committedUntil ?? window.freshAt, ...lines.map(line => line.until));
+                    // Drop expired work instead of turning off an otherwise healthy stream.
+                    this.translations = this.translations.filter(item => Date.now() - item.until <= 12_000).slice(-11);
+                    this.translations.push({ lines, language, target, until: window.until });
+                    // Recognition of the next audio window can proceed while the text
+                    // model translates this phrase. Voice synthesis is a third stage.
+                    if (this.translating === null)
+                        void this.translate(this.generation);
                 }
-                else if (heard.text) {
-                    lines = [{ channel: this.options.channel(), at: window.freshAt, until: window.until, text: heard.text, language }];
+                catch (error) {
+                    if (generation !== this.generation)
+                        return;
+                    if (!transientAudioError(error) || ++this.recognitionFailures >= 3)
+                        throw error;
+                    this.options.status("Speech recognition interrupted · listening for the next phrase…");
                 }
-                if (!lines.length)
-                    continue;
-                this.committedUntil = Math.max(this.committedUntil ?? window.freshAt, ...lines.map(line => line.until));
-                if (this.translations.length >= 12)
-                    throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-                this.translations.push({ lines, language, target, until: window.until });
-                // Recognition of the next audio window can proceed while the text
-                // model translates this phrase. Voice synthesis is a third stage.
-                if (this.translating === null)
-                    void this.translate(this.generation);
             }
         }
         catch (error) {
             if (generation === this.generation) {
+                const message = error instanceof Error ? error.message : "Live translation stopped.";
                 this.reset();
-                this.options.failed();
-                this.options.status(error instanceof Error ? error.message : "Live translation stopped.");
+                this.options.failed(message);
+                this.options.status(message);
             }
         }
         finally {
@@ -181,36 +196,47 @@ export class Interpreter {
         try {
             while (this.translations.length && generation === this.generation) {
                 const item = this.translations.shift();
-                let { lines } = item;
-                const { language, target, until } = item;
-                if (Date.now() - until > 12_000)
-                    throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-                const controller = new AbortController();
-                this.translationController = controller;
-                if (target && language !== target) {
-                    if (!language)
-                        throw new Error("The audio language could not be detected. Waiting for clearer speech.");
-                    const translated = await this.json("/api/v1/translate?live=1", {
-                        method: "POST", headers: { "content-type": "application/json" },
-                        body: JSON.stringify({ texts: lines.map(line => line.text), from: language, to: target }),
-                    }, AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]));
-                    if (translated.texts.length !== lines.length || translated.texts.some(text => !text.trim()))
-                        throw new Error("Translation omitted a phrase. Enable translated audio again to retry.");
-                    lines = lines.map((line, i) => ({ ...line, original: line.text, sourceLanguage: language, language: target, text: translated.texts[i] }));
+                try {
+                    let { lines } = item;
+                    const { language, target, until } = item;
+                    if (Date.now() - until > 12_000)
+                        continue;
+                    const controller = new AbortController();
+                    this.translationController = controller;
+                    if (target && language !== target) {
+                        if (!language)
+                            throw audioError("The audio language could not be detected. Waiting for clearer speech.", 502);
+                        const translated = await this.json("/api/v1/translate?live=1", {
+                            method: "POST", headers: { "content-type": "application/json" },
+                            body: JSON.stringify({ texts: lines.map(line => line.text), from: language, to: target }),
+                        }, AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]));
+                        if (translated.texts.length !== lines.length || translated.texts.some(text => !text.trim()))
+                            throw audioError("Translation omitted a phrase. Waiting for the next phrase.", 502);
+                        lines = lines.map((line, i) => ({ ...line, original: line.text, sourceLanguage: language, language: target, text: translated.texts[i] }));
+                    }
+                    if (generation !== this.generation)
+                        return;
+                    if (Date.now() - until > 12_000)
+                        continue;
+                    this.translationFailures = 0;
+                    this.options.lines(lines.flatMap(line => splitCaption(line)));
+                    this.options.status(target ? `${language} → ${target} · live translation` : `Original audio language: ${language || "detecting…"}`);
+                }
+                catch (error) {
+                    if (generation !== this.generation)
+                        return;
+                    if (!transientAudioError(error) || ++this.translationFailures >= 3)
+                        throw error;
+                    this.options.status("Translation interrupted · catching up with live speech…");
                 }
-                if (generation !== this.generation)
-                    return;
-                if (Date.now() - until > 12_000)
-                    throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-                this.options.lines(lines.flatMap(line => splitCaption(line)));
-                this.options.status(target ? `${language} → ${target} · live translation` : `Original audio language: ${language || "detecting…"}`);
             }
         }
         catch (error) {
             if (generation === this.generation) {
+                const message = error instanceof Error ? error.message : "Live translation stopped.";
                 this.reset();
-                this.options.failed();
-                this.options.status(error instanceof Error ? error.message : "Live translation stopped.");
+                this.options.failed(message);
+                this.options.status(message);
             }
         }
         finally {

package/dist/live-recovery.d.ts

@@ -0,0 +1,6 @@
+/** Access, billing and throttling failures are terminal. Only transient service
+ * and transport failures may recover, with a bounded consecutive failure count. */
+export declare function transientAudioError(error: unknown): boolean;
+export declare function audioError(message: string, status: number): Error & {
+    status: number;
+};

package/dist/live-recovery.js

@@ -0,0 +1,11 @@
+/** Access, billing and throttling failures are terminal. Only transient service
+ * and transport failures may recover, with a bounded consecutive failure count. */
+export function transientAudioError(error) {
+    const status = error?.status;
+    if (typeof status === "number")
+        return [408, 502, 503, 504].includes(status);
+    return error instanceof TypeError || (error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name));
+}
+export function audioError(message, status) {
+    return Object.assign(new Error(message), { status });
+}

package/dist/mail-sender.d.ts

@@ -0,0 +1,9 @@
+export interface MailSender {
+    apiKey: string;
+    from: string;
+}
+export interface BrandedMailSender extends MailSender {
+    backtoschool?: MailSender;
+}
+/** Only the exact school origins select its verified sender and credentials. */
+export declare function mailSender(options: BrandedMailSender, link: string): MailSender;

package/dist/mail-sender.js

@@ -0,0 +1,11 @@
+/** Only the exact school origins select its verified sender and credentials. */
+export function mailSender(options, link) {
+    try {
+        const url = new URL(link);
+        if (options.backtoschool && url.protocol === "https:" &&
+            ["backtoschool.help", "www.backtoschool.help"].includes(url.hostname))
+            return options.backtoschool;
+    }
+    catch { /* A malformed link never changes the sender. */ }
+    return options;
+}

package/dist/notify.d.ts

@@ -1,3 +1,4 @@
+import { type BrandedMailSender } from "./mail-sender.ts";
 /**
  * Telling followers a broadcaster went live, wherever they are.
  *
@@ -58,9 +59,8 @@ export declare function notifyAll(audience: readonly Reachable[], note: Notifica
  * HTTP rather than SMTP so there is no connection to hold, no port to be
  * blocked, and no dependency: a fetch is the whole client.
  */
-export declare function resendEmail({ apiKey, from, fetch, onEvent }: {
-    apiKey: string;
-    from: string;
+export declare function resendEmail({ apiKey, from, backtoschool, reason, fetch, onEvent }: BrandedMailSender & {
+    reason?: string;
     fetch?: typeof globalThis.fetch;
     onEvent?: (message: string) => void;
 }): (to: string, note: Notification) => Promise<boolean>;

package/dist/notify.js

@@ -1,3 +1,4 @@
+import { mailSender } from "./mail-sender.js";
 /**
  * Tell an audience, on every channel each of them wants.
  *
@@ -52,20 +53,22 @@ export async function notifyAll(audience, note, channels) {
  * HTTP rather than SMTP so there is no connection to hold, no port to be
  * blocked, and no dependency: a fetch is the whole client.
  */
-export function resendEmail({ apiKey, from, fetch = globalThis.fetch, onEvent }) {
+export function resendEmail({ apiKey, from, backtoschool, reason = "You are getting this because you follow them on nixamp.", fetch = globalThis.fetch, onEvent }) {
     return async (to, note) => {
         try {
+            const sender = mailSender({ apiKey, from, backtoschool }, note.url);
             const response = await fetch("https://api.resend.com/emails", {
                 method: "POST",
-                headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+                headers: { authorization: `Bearer ${sender.apiKey}`, "content-type": "application/json" },
+                signal: AbortSignal.timeout(15_000),
                 body: JSON.stringify({
-                    from,
+                    from: sender.from,
                     to: [to],
                     subject: note.title,
-                    text: `${note.body}\n\n${note.url}\n\nYou are getting this because you follow them on nixamp.`,
+                    text: `${note.body}\n\n${note.url}\n\n${reason}`,
                     html: `<p>${escapeHtml(note.body)}</p>` +
                         `<p><a href="${escapeHtml(note.url)}">${escapeHtml(note.url)}</a></p>` +
-                        `<p style="color:#666;font-size:12px">You are getting this because you follow them on nixamp.</p>`,
+                        `<p style="color:#666;font-size:12px">${escapeHtml(reason)}</p>`,
                 }),
             });
             if (!response.ok) {

package/dist/password-reset.d.ts

@@ -1,5 +1,6 @@
 import type { Queryable } from "./follows.ts";
 import type { Tokens } from "./tokens.ts";
+import { type BrandedMailSender } from "./mail-sender.ts";
 export declare const RESET_MESSAGE = "If an account exists for that email, you\u2019ll receive a password reset link shortly.";
 export declare const RESET_INVALID = "This reset link is invalid, expired, or already used. Request a new link.";
 interface Passwords {
@@ -27,9 +28,7 @@ export declare class PasswordResets {
     acceptsLegacyToken(userId: string, token: string): Promise<boolean>;
 }
 /** Transactional recovery mail has no follower footer and never logs a token. */
-export declare function resendPasswordReset(options: {
-    apiKey: string;
-    from: string;
+export declare function resendPasswordReset(options: BrandedMailSender & {
     fetch?: typeof globalThis.fetch;
 }): ResetMail;
 export {};

package/dist/password-reset.js

@@ -1,4 +1,5 @@
 import { createHash, randomBytes } from "node:crypto";
+import { mailSender } from "./mail-sender.js";
 export const RESET_MESSAGE = "If an account exists for that email, you’ll receive a password reset link shortly.";
 export const RESET_INVALID = "This reset link is invalid, expired, or already used. Request a new link.";
 const LIFETIME_MS = 30 * 60_000;
@@ -105,12 +106,13 @@ export class PasswordResets {
 export function resendPasswordReset(options) {
     return async (email, link) => {
         const host = new URL(link).hostname;
+        const sender = mailSender(options, link);
         const response = await (options.fetch ?? globalThis.fetch)("https://api.resend.com/emails", {
             method: "POST",
-            headers: { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
+            headers: { authorization: `Bearer ${sender.apiKey}`, "content-type": "application/json" },
             signal: AbortSignal.timeout(15_000),
             body: JSON.stringify({
-                from: options.from, to: [email], subject: `Reset your ${host} password`,
+                from: sender.from, to: [email], subject: `Reset your ${host} password`,
                 text: `Someone requested a password reset for your account on ${host}.\n\nChoose a new password using this link:\n${link}\n\nThis link expires in ${LIFETIME_MS / 60_000} minutes and works once. Resetting your password signs out existing sessions.\n\nIf you did not request this, you can ignore this email. Your password will stay the same.`,
             }),
         });

package/dist/server.d.ts

@@ -29,6 +29,7 @@ import { Names } from "./names.ts";
 import { Certs } from "./certs.ts";
 import { type Throttle } from "@profullstack/throttle";
 import { type Notification } from "./notify.ts";
+import { EventWriter } from "./event-writer.ts";
 import { LiveEvents } from "./live-events.ts";
 import { Tickets } from "./tickets.ts";
 import { Layouts } from "./layouts.ts";
@@ -703,6 +704,7 @@ export interface HandlerOptions {
     settingsSync?: SettingsSync;
     /** Scheduled and live sessions, kept by NixAmp and shared by branded clients. */
     events?: LiveEvents;
+    eventWriter?: EventWriter;
     /** Versioned panel layouts, including event and user overrides. */
     layouts?: Layouts;
     /** Persistent participation state that must not be coupled to live audio. */

package/dist/server.js

@@ -66,6 +66,7 @@ import { createThrottle, presentedCredential } from "@profullstack/throttle";
 import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { inviteSubject, inviteText, isEmail, isPhone, watchLink } from "./invite.js";
+import { EventWriter } from "./event-writer.js";
 import { handleLiveApi } from "./live-api.js";
 import { LiveEvents, eventStructuredData, isTicketed } from "./live-events.js";
 import { Tickets, needsTicket, ticketFrom, ticketsFromEnv } from "./tickets.js";
@@ -1448,6 +1449,7 @@ export function createHandler(engine, options) {
             return;
         if (options.events && await handleLiveApi(request, response, url, {
             events: options.events,
+            ...(options.eventWriter ? { eventWriter: options.eventWriter } : {}),
             ...(options.accounts ? { accounts: options.accounts } : {}),
             ...(options.layouts ? { layouts: options.layouts } : {}),
             ...(options.rooms ? { rooms: options.rooms } : {}),
@@ -5599,6 +5601,10 @@ export async function serve(argv, version = "0.1.0") {
     const favorites = pool ? new Favorites(pool) : undefined;
     const settingsSync = pool ? new SettingsSync(pool) : undefined;
     const nixampSite = (process.env["NIXAMP_SITE"] ?? DEFAULT_DIRECTORY).replace(/\/+$/, "");
+    const schoolMailKey = process.env["BACKTOSCHOOL_RESEND_API_KEY"] ?? process.env["RESEND_API_KEY"];
+    const schoolMail = schoolMailKey && process.env["BACKTOSCHOOL_MAIL_FROM"] ? {
+        apiKey: schoolMailKey, from: process.env["BACKTOSCHOOL_MAIL_FROM"],
+    } : undefined;
     const events = pool ? new LiveEvents(pool) : undefined;
     const layouts = pool ? new Layouts(pool) : undefined;
     const rooms = pool ? new Rooms(pool) : undefined;
@@ -6118,7 +6124,10 @@ export async function serve(argv, version = "0.1.0") {
         ...(follows ? { follows, vapidPublicKey } : {}),
         ...(favorites ? { favorites } : {}),
         ...(settingsSync ? { settingsSync } : {}),
-        ...(events ? { events } : {}),
+        ...(events ? { events, eventWriter: new EventWriter({
+                openaiKey: process.env["OPENAI_API_KEY"], anthropicKey: process.env["ANTHROPIC_API_KEY"],
+                openaiModel: process.env["NIXAMP_WRITER_OPENAI_MODEL"], claudeModel: process.env["NIXAMP_WRITER_CLAUDE_MODEL"],
+            }) } : {}),
         ...(layouts ? { layouts } : {}),
         ...(rooms ? { rooms } : {}),
         ...(trollbox ? { trollbox } : {}),
@@ -6135,6 +6144,7 @@ export async function serve(argv, version = "0.1.0") {
             resetMail: resendPasswordReset({
                 apiKey: process.env["RESEND_API_KEY"],
                 from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+                backtoschool: schoolMail,
             }),
         } : {}),
         // Other people's OpenProfiles, read for the voice a line is spoken in,
@@ -6159,6 +6169,8 @@ export async function serve(argv, version = "0.1.0") {
                             email: resendEmail({
                                 apiKey: process.env["RESEND_API_KEY"],
                                 from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+                                backtoschool: schoolMail,
+                                reason: "You received this email because a host invited you to join a live session.",
                                 onEvent: (message) => console.log(message),
                             }),
                         }

package/dist/shared-translation.d.ts

@@ -27,6 +27,7 @@ export type SharedEvent = {
 } | {
     type: "error";
     error: string;
+    retryable?: boolean;
 };
 type Member = {
     by: string;

package/dist/shared-translation.js

@@ -1,5 +1,6 @@
 /** 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 { transientAudioError } from "./live-recovery.js";
 import { createHash, randomUUID } from "node:crypto";
 import { lookup } from "node:dns/promises";
 import { BlockList, isIP } from "node:net";
@@ -179,15 +180,15 @@ export class SharedTranslations {
             }
         }
     }
-    stop(feed, error) {
-        this.broadcast(feed, { type: "error", error });
+    stop(feed, error, retryable = false) {
+        this.broadcast(feed, { type: "error", error, retryable });
         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() };
+        const feed = { id, source, language, members: new Set(), controller: new AbortController(), reservations: new Map(), queue: [], speaking: false, voiceFailures: 0, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() };
         // Each account uses free access first, then the same published credit rate.
         // Additional listeners do not trigger recognition or synthesis.
         feed.meter = {
@@ -254,13 +255,10 @@ export class SharedTranslations {
             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."),
+            failed: message => this.stop(feed, message),
             lines: lines => {
                 feed.queue.push(...lines);
-                if (feed.queue.length > 24) {
-                    this.stop(feed, "Live translation fell behind. Enable it again to retry.");
-                    return;
-                }
+                feed.queue = feed.queue.filter(line => Date.now() - line.until <= 12_000).slice(-24);
                 if (!feed.speaking)
                     void this.speak(feed);
             },
@@ -296,7 +294,7 @@ export class SharedTranslations {
                         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);
+            }, () => this.stop(feed, "The live source disconnected.", true), feed.controller.signal);
             if (feed.controller.signal.aborted)
                 input.stop();
             else
@@ -312,24 +310,35 @@ export class SharedTranslations {
             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();
+                    continue;
                 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") });
+                    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 });
+                    }
+                    feed.voiceFailures = 0;
                 }
-                finally {
-                    reader.releaseLock();
+                catch (error) {
+                    if (feed.controller.signal.aborted)
+                        return;
+                    if (!transientAudioError(error) || ++feed.voiceFailures >= 3)
+                        throw error;
+                    // A provider failure skips this phrase; the source and other listeners
+                    // remain connected. Never replay partial speech or retry a charge.
                 }
-                this.broadcast(feed, { type: "end", id });
             }
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.27.2",
+  "version": "0.27.3",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",