nixamp 0.28.43 → 0.28.45

package/README.md

@@ -619,9 +619,14 @@ multiplied by five. Credentials and balances never travel in checkout URLs.
 New checkout creation is capped at five per account and fifty per account server
 per UTC day, plus IP and request throttles; retries reuse the original invoice.
 
-After the ten free sessions, new sessions require purchased credit. Configure `COINPAY_X402_KEY`
-with `payments:create` permission and at least one business wallet; the scoped
-key supplies the merchant identity. Free sessions and existing credit still work during a
+After the ten free sessions, new sessions require purchased credit. Configure `COINPAY_API_KEY`
+(the older name `COINPAY_X402_KEY` still works; `COINPAY_API_KEY` wins when both are set)
+with `payments:create` and `payments:read` permission and at least one business wallet. The scoped
+key supplies the merchant identity, so it must belong to nixamp's own CoinPay business. Set
+`COINPAY_WEBHOOK_SECRET` to that business's webhook secret and its webhook URL to
+`https://<site>/api/v1/webhooks/coinpay`, and a paid order is credited even if the buyer never
+comes back to the page. The webhook body is only a nudge: the order is re-checked with CoinPay
+before anything is credited, and it is credited once however many times it is delivered. Free sessions and existing credit still work during a
 checkout outage. A self-hosted operator explicitly sponsoring API usage may set
 `NIXAMP_TRANSLATION_BILLING=off`.
 

package/dist/accounts.js

@@ -96,11 +96,19 @@ export class Accounts {
             (options.system
                 ? null
                 : new PostgresAdapter({ connectionString: options.connectionString }));
+        // Without a secret the module signs with a public default, and anyone can
+        // mint a session for any account. Refuse rather than run that way.
+        if (!options.system && !options.secret) {
+            throw new Error("NIXAMP_JWT_SECRET is required for accounts");
+        }
         this.system =
             options.system ??
                 createAuthSystem({
                     adapter,
-                    jwtSecret: options.secret,
+                    // tokenOptions.secret, not jwtSecret: the module has no top-level
+                    // jwtSecret, and until 2026-10-09 this passed one, so every JWT was
+                    // signed with the module's public default secret.
+                    tokenOptions: { secret: options.secret },
                     // The module defaults to requiring an uppercase and a lowercase
                     // letter. Its rules have to match the ones checked above, or a password
                     // this accepts is refused a layer down in a different sentence.

package/dist/live-interpreter.d.ts

@@ -1,72 +1 @@
-import type { SpeakerTurn } from "./speaker-turns.ts";
-export interface Caption {
-    channel: string;
-    at: number;
-    until: number;
-    text: string;
-    language?: string;
-    original?: string;
-    sourceLanguage?: string;
-    speaker?: string;
-    voiceProfile?: "lower" | "higher" | "unknown";
-}
-export interface VoiceChoice {
-    id: string;
-    name: string;
-    gender: string;
-    language: string;
-}
-export interface AudioWindow {
-    samples: Float32Array;
-    at: number;
-    until: number;
-    freshAt: number;
-}
-export interface Speaker {
-    id: string;
-    profile: string;
-    voice: string;
-}
-/** Match provider labels across overlapping timestamps. A speaker absent from
- * the rolling context gets a new label; pitch alone never identifies someone. */
-export declare class SpeakerTracker {
-    private readonly random;
-    private previous;
-    private sequence;
-    readonly speakers: Map<string, Speaker>;
-    constructor(random?: () => number);
-    reset(): void;
-    reconcile(turns: SpeakerTurn[], at: number, voices: VoiceChoice[]): Map<string, Speaker>;
-}
-/** Listener-local interpretation for the playing media. One request in flight and only the latest pending audio window. */
-export declare class Interpreter {
-    private readonly options;
-    readonly tracker: SpeakerTracker;
-    private generation;
-    private pending;
-    private committedUntil;
-    private running;
-    private controller;
-    private translating;
-    private translationController;
-    private recognitionFailures;
-    private translationFailures;
-    private translations;
-    constructor(options: {
-        language: () => string;
-        speakers: () => boolean;
-        voices: () => VoiceChoice[];
-        channel: () => string;
-        lines: (lines: Caption[]) => void;
-        status: (text: string) => void;
-        failed: (message: string) => void;
-        fetcher?: typeof fetch;
-    });
-    reset(): void;
-    push(window: AudioWindow): void;
-    private json;
-    private run;
-    private translate;
-}
-/** Preserve all words while respecting the speech API's character limit. */
-export declare function splitCaption(line: Caption): Caption[];
+export { Interpreter, SpeakerTracker, splitCaption, type Caption, type VoiceChoice, type AudioWindow, type Speaker } from "@profullstack/live-translate/core";

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]);
 }