nixamp 0.28.44 → 0.29.1

package/dist/live-interpreter.js

@@ -1,269 +1 @@
-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. */
-export class SpeakerTracker {
-    random;
-    previous = [];
-    sequence = 0;
-    speakers = new Map();
-    constructor(random = Math.random) {
-        this.random = random;
-    }
-    reset() { this.previous = []; this.sequence = 0; this.speakers.clear(); }
-    reconcile(turns, at, voices) {
-        const links = new Map();
-        const used = new Set();
-        const candidates = [];
-        const totals = new Map();
-        for (const turn of turns)
-            for (const old of this.previous) {
-                const overlap = Math.min(at + turn.end * 1000, old.end) - Math.max(at + turn.start * 1000, old.start);
-                if (overlap > 120) {
-                    const key = `${turn.speaker}|${old.speaker}`;
-                    totals.set(key, (totals.get(key) ?? 0) + overlap);
-                }
-            }
-        for (const [key, overlap] of totals) {
-            const [local, global] = key.split("|");
-            candidates.push({ local: local, global: global, overlap });
-        }
-        for (const one of candidates.sort((a, b) => b.overlap - a.overlap)) {
-            const speaker = this.speakers.get(one.global);
-            if (speaker && !links.has(one.local) && !used.has(one.global)) {
-                links.set(one.local, speaker);
-                used.add(one.global);
-            }
-        }
-        for (const turn of turns) {
-            let speaker = links.get(turn.speaker);
-            if (!speaker) {
-                // Assign contrasting stock voices, without guessing a person's
-                // gender from pitch or a noisy, short opening phrase.
-                const taken = new Set([...this.speakers.values()].map(one => one.voice));
-                const available = voices.filter(voice => !taken.has(voice.id));
-                const pool = available.length ? available : voices;
-                const voice = pool[Math.floor(this.random() * pool.length)];
-                speaker = { id: `speaker-${++this.sequence}`, profile: turn.profile, voice: voice?.id ?? "auto" };
-                this.speakers.set(speaker.id, speaker);
-                links.set(turn.speaker, speaker);
-            }
-        }
-        this.previous = turns.map(turn => ({ start: at + turn.start * 1000, end: at + turn.end * 1000, speaker: links.get(turn.speaker).id }));
-        const present = new Set(this.previous.map(turn => turn.speaker));
-        for (const key of this.speakers.keys())
-            if (this.speakers.size > 64 && !present.has(key))
-                this.speakers.delete(key);
-        return links;
-    }
-}
-/** Listener-local interpretation for the playing media. One request in flight and only the latest pending audio window. */
-export class Interpreter {
-    options;
-    tracker = new SpeakerTracker();
-    generation = 0;
-    pending = null;
-    committedUntil = null;
-    running = null;
-    controller = null;
-    translating = null;
-    translationController = null;
-    recognitionFailures = 0;
-    translationFailures = 0;
-    translations = [];
-    constructor(options) {
-        this.options = options;
-    }
-    reset() {
-        this.generation++;
-        this.controller?.abort();
-        this.translationController?.abort();
-        this.pending = null;
-        this.running = null;
-        this.translating = null;
-        this.recognitionFailures = this.translationFailures = 0;
-        this.translations = [];
-        this.committedUntil = null;
-        this.tracker.reset();
-    }
-    push(window) {
-        this.committedUntil ??= window.freshAt;
-        this.pending = window;
-        if (this.running === null)
-            void this.run(this.generation);
-    }
-    async json(path, init, signal) {
-        const response = await (this.options.fetcher ?? fetch)(path, { ...init, signal });
-        const body = await response.json();
-        if (!response.ok)
-            throw audioError(body.error || "Audio translation is unavailable.", response.status);
-        return body;
-    }
-    async run(generation) {
-        this.running = generation;
-        try {
-            while (this.pending && generation === this.generation) {
-                const window = this.pending;
-                this.pending = null;
-                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();
-                        }
-                    }
-                    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);
-                }
-                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…");
-                }
-            }
-        }
-        catch (error) {
-            if (generation === this.generation) {
-                const message = error instanceof Error ? error.message : "Live translation stopped.";
-                this.reset();
-                this.options.failed(message);
-                this.options.status(message);
-            }
-        }
-        finally {
-            if (this.running === generation)
-                this.running = null;
-        }
-    }
-    async translate(generation) {
-        this.translating = generation;
-        try {
-            while (this.translations.length && generation === this.generation) {
-                const item = this.translations.shift();
-                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…");
-                }
-            }
-        }
-        catch (error) {
-            if (generation === this.generation) {
-                const message = error instanceof Error ? error.message : "Live translation stopped.";
-                this.reset();
-                this.options.failed(message);
-                this.options.status(message);
-            }
-        }
-        finally {
-            if (this.translating === generation)
-                this.translating = null;
-        }
-    }
-}
-/** Preserve all words while respecting the speech API's character limit. */
-export function splitCaption(line) {
-    const text = line.text.trim();
-    if (!text)
-        return [];
-    const parts = [];
-    let rest = text;
-    while (rest.length > 600) {
-        const space = rest.lastIndexOf(" ", 600);
-        const end = space > 300 ? space : 600;
-        parts.push(rest.slice(0, end));
-        rest = rest.slice(end).trimStart();
-    }
-    if (rest)
-        parts.push(rest);
-    let offset = 0;
-    return parts.map(part => {
-        const at = line.at + (line.until - line.at) * offset / text.length;
-        offset += part.length + 1;
-        return { ...line, text: part, at, until: Math.min(line.until, line.at + (line.until - line.at) * offset / text.length) };
-    });
-}
+export { Interpreter, SpeakerTracker, splitCaption } from "@profullstack/live-translate/core";

package/dist/live-recovery.d.ts

@@ -1,6 +1 @@
-/** 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;
-};
+export { audioError, transientAudioError } from "@profullstack/live-translate/core";

package/dist/live-recovery.js

@@ -1,11 +1 @@
-/** 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 });
-}
+export { audioError, transientAudioError } from "@profullstack/live-translate/core";

package/dist/live-voice.d.ts

@@ -1,77 +1,7 @@
-import { type SpeakerTranscript } from "./speaker-turns.ts";
-import type { VoiceProfile } from "./voice-profile.ts";
-import type { TranslationMeter } from "./translation-passes.ts";
-import type { Queryable } from "./follows.ts";
-export declare const LIVE_VOICE_MODEL = "eleven_flash_v2_5";
-export declare const LIVE_VOICE_RATE = 16000;
-export declare const LIVE_VOICE_LANGUAGES: Set<string>;
-export interface LiveVoiceChoice {
-    id: string;
-    name: string;
-    gender: string;
-    language: string;
-}
-export interface VoiceRequest {
-    text: string;
-    language: string;
-    voice?: string;
-    profile?: VoiceProfile;
-    channel?: string;
-    speaker?: string;
-}
-export declare class LiveVoice {
-    private readonly key;
-    private readonly fetcher;
-    private readonly now;
-    private catalog;
-    private catalogUntil;
-    private readonly cache;
-    private readonly pending;
-    private readonly usage;
-    private readonly charsPerMinute;
-    private readonly requests;
-    private readonly grants;
-    private readonly activeBy;
-    private readonly db?;
-    private readonly billing?;
-    private schema;
-    private readonly dailyChars;
-    private cleanupAt;
-    private readonly hearing;
-    private readonly dailyAudioSeconds;
-    private readonly userDailyChars;
-    private readonly userDailyAudioSeconds;
-    private providerPause;
-    private checkProvider;
-    private providerFailed;
-    constructor(options?: {
-        apiKey?: string;
-        fetcher?: typeof fetch;
-        now?: () => number;
-        charsPerMinute?: number;
-        dailyChars?: number;
-        dailyAudioSeconds?: number;
-        userDailyChars?: number;
-        userDailyAudioSeconds?: number;
-        db?: Queryable;
-        billing?: TranslationMeter;
-    });
-    available(): boolean;
-    /** Optional diarization, billed only while a signed-in listener requests it.
-     * Rolling audio is bounded to 15 seconds, including overlap. Every second
-     * submitted (also repeated context) consumes the persistent provider budget. */
-    hear(bytes: Uint8Array, by: string, signal?: AbortSignal, meter?: TranslationMeter | undefined, resource?: string): Promise<SpeakerTranscript>;
-    voices(): Promise<LiveVoiceChoice[]>;
-    /** A 90-second capability for one channel, never the viewer's account credential. */
-    grant(by: string, channel: string): Promise<{
-        token: string;
-        expires: number;
-    }>;
-    authorize(token: string, channel: string, chars: number): Promise<string>;
-    private ensure;
-    private reserve;
-    private charge;
-    private checkRequest;
-    /** Stream the first request immediately; concurrent listeners share its cached result. */
-    stream(ask: VoiceRequest, by: string, signal?: AbortSignal, meter?: TranslationMeter | undefined): Promise<Response>;
+/** ElevenLabs Flash/Scribe for live captions, from @profullstack/live-translate.
+ * nixamp keeps its `nxd_` grant tokens: captions.ts and older pages expect them. */
+import { LiveVoice as Base } from "@profullstack/live-translate";
+export { LIVE_VOICE_MODEL, LIVE_VOICE_RATE, LIVE_VOICE_LANGUAGES, type LiveVoiceChoice, type VoiceRequest } from "@profullstack/live-translate";
+export declare class LiveVoice extends Base {
+    constructor(options?: ConstructorParameters<typeof Base>[0]);
 }