nixamp 0.27.2 → 0.28.0

package/dist/live-api.js

@@ -1,3 +1,4 @@
+import { EventWriterError } from "./event-writer.js";
 import { tokenFrom } from "./accounts.js";
 import { INVITATION_STATES, LIVE_EVENT_KINDS, LIVE_EVENT_STATUSES, LiveEventError, isTicketed, } from "./live-events.js";
 import { LAYOUT_SCOPES, LayoutError, PANEL_REGISTRY, layoutNameFor, presetLayout, } from "./layouts.js";
@@ -19,13 +20,13 @@ function json(response, code, body) {
     });
     response.end(value);
 }
-async function body(request) {
+async function body(request, limit = 64 * 1024) {
     const chunks = [];
     let size = 0;
     for await (const chunk of request) {
         const buffer = chunk;
         size += buffer.length;
-        if (size > 64 * 1024)
+        if (size > limit)
             throw new LiveEventError("body too large", 413);
         chunks.push(buffer);
     }
@@ -187,6 +188,32 @@ export async function handleLiveApi(request, response, url, options) {
         !path.startsWith("/api/v1/layout-presets"))
         return false;
     try {
+        if (path === "/api/v1/events/ai-draft") {
+            if (request.method !== "POST") {
+                json(response, 405, { error: "POST only" });
+                return true;
+            }
+            const account = await requiredAccount(request, response, options);
+            if (!account)
+                return true;
+            if (!options.eventWriter) {
+                json(response, 503, { error: "The AI writer is temporarily unavailable. You can keep writing here." });
+                return true;
+            }
+            const input = await body(request, 12 * 1024);
+            const controller = new AbortController();
+            const closed = () => controller.abort();
+            response.once("close", closed);
+            try {
+                const result = await options.eventWriter.draft(account.id, input, controller.signal);
+                if (!response.destroyed)
+                    json(response, 200, result);
+            }
+            finally {
+                response.off("close", closed);
+            }
+            return true;
+        }
         if (path === "/api/v1/events") {
             if (request.method === "GET") {
                 const account = await signedIn(request, options.accounts);
@@ -559,6 +586,14 @@ export async function handleLiveApi(request, response, url, options) {
         return true;
     }
     catch (error) {
+        if (error instanceof EventWriterError) {
+            if (!response.destroyed) {
+                if (error.retryAfter)
+                    response.setHeader("retry-after", String(error.retryAfter));
+                json(response, error.status, { error: error.message });
+            }
+            return true;
+        }
         if (error instanceof LiveEventError || error instanceof LayoutError || error instanceof RoomError) {
             json(response, error.status, { error: error.message });
             return true;

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/locales/ar.d.ts

@@ -0,0 +1,201 @@
+declare const _default: {
+    "Interface language": string;
+    Language: string;
+    "Translation language": string;
+    "Original (auto-detect)": string;
+    Play: string;
+    Pause: string;
+    Stop: string;
+    Next: string;
+    Previous: string;
+    Select: string;
+    "Next/Prev": string;
+    Quit: string;
+    "Now Playing": string;
+    "Spectrum Analyser": string;
+    Playlist: string;
+    Files: string;
+    "Open files": string;
+    "Open folder": string;
+    "Add to library": string;
+    "Replace playlist": string;
+    Filter: string;
+    Search: string;
+    "Nothing loaded.": string;
+    "Empty.": string;
+    "Loading\u2026": string;
+    "Connecting\u2026": string;
+    Connected: string;
+    "Not connected": string;
+    "No source": string;
+    Playing: string;
+    Stopped: string;
+    Volume: string;
+    Seek: string;
+    "Full screen": string;
+    Download: string;
+    Share: string;
+    Copy: string;
+    "Copy link": string;
+    Copied: string;
+    Save: string;
+    Cancel: string;
+    Close: string;
+    Remove: string;
+    Delete: string;
+    Edit: string;
+    Add: string;
+    Send: string;
+    Retry: string;
+    Back: string;
+    "Next page": string;
+    "Previous page": string;
+    "Show more": string;
+    Panels: string;
+    "Reset layout": string;
+    Show: string;
+    Hide: string;
+    Collapse: string;
+    Expand: string;
+    "Move up": string;
+    "Move down": string;
+    Install: string;
+    "TV mode": string;
+    On: string;
+    Off: string;
+    Account: string;
+    "Sign in": string;
+    "Sign out": string;
+    "Create account": string;
+    Email: string;
+    Password: string;
+    "Forgot password?": string;
+    "Welcome back": string;
+    Profile: string;
+    Handle: string;
+    "Your servers": string;
+    Server: string;
+    Connect: string;
+    Disconnect: string;
+    Directory: string;
+    Favourites: string;
+    Follow: string;
+    Unfollow: string;
+    Notifications: string;
+    "Phone number": string;
+    "Save number": string;
+    Transcript: string;
+    Captions: string;
+    "Translate audio": string;
+    "Audio language": string;
+    "Audio options": string;
+    "Keep background sound": string;
+    "Background level": string;
+    "Speaker voices": string;
+    "Any voice": string;
+    "Male voice": string;
+    "Female voice": string;
+    "Original audio.": string;
+    "Buy translated audio": string;
+    "Audio credit": string;
+    "Buy pass": string;
+    Pass: string;
+    "Pay with": string;
+    "Check payment": string;
+    "Open checkout": string;
+    "Free sessions": string;
+    "Usage rates and expiry": string;
+    Catalogs: string;
+    "Add catalog": string;
+    "Catalog name": string;
+    Link: string;
+    "Play link": string;
+    "Go live": string;
+    Publish: string;
+    Listen: string;
+    "Live now": string;
+    Upcoming: string;
+    Parties: string;
+    "Join party": string;
+    "Invite code": string;
+    Invite: string;
+    Chat: string;
+    "Chat message": string;
+    People: string;
+    Speaker: string;
+    Speakers: string;
+    Listener: string;
+    Moderator: string;
+    "Raise hand": string;
+    "Hand raises": string;
+    Questions: string;
+    Resources: string;
+    Replay: string;
+    Schedule: string;
+    Event: string;
+    Host: string;
+    About: string;
+    Stage: string;
+    Title: string;
+    Description: string;
+    Topic: string;
+    Public: string;
+    "Anyone with the link": string;
+    "Invited people": string;
+    "Who can join": string;
+    "Date and time": string;
+    "Expected length": string;
+    Repeat: string;
+    "Does not repeat": string;
+    "Every day": string;
+    "Every week": string;
+    Homepage: string;
+    "Host name": string;
+    "Profile photo URL": string;
+    "Broadcast link": string;
+    "Edit event": string;
+    "Save changes": string;
+    "Create live": string;
+    "Schedule class": string;
+    "Start class": string;
+    "End event": string;
+    "End session": string;
+    "Session ended": string;
+    "Event ended": string;
+    Cancelled: string;
+    "Replay available": string;
+    Join: string;
+    "Create invite": string;
+    "Invite as": string;
+    "Watch now": string;
+    "Start a room": string;
+    "Recent replays": string;
+    "Your account": string;
+    "Write with AI": string;
+    "Suggested title": string;
+    "Suggested description": string;
+    "Suggested topic": string;
+    "Use these details": string;
+    "Learn something live.": string;
+    "Screen share": string;
+    "Upload and broadcast": string;
+    Help: string;
+    "Reload Player": string;
+    "Copy Bundled CLI Path": string;
+    "Developer tools": string;
+    Undo: string;
+    Redo: string;
+    Cut: string;
+    Paste: string;
+    "Select all": string;
+    Status: string;
+    "Activity log": string;
+    Admin: string;
+    "Playback controls": string;
+    "Tracks and folders": string;
+    "Original-language captions.": string;
+    "Skip to playback controls": string;
+    "Skip to playlist": string;
+    "Skip to transcript and translated audio": string;
+};
+export default _default;