nixamp 0.26.7 → 0.27.1

package/README.md

@@ -219,6 +219,18 @@ BackToSchool.help is a branded, mobile-first client for NixAmp live events. It
 uses the same NixAmp accounts, PostgreSQL data, rooms, invitations, layouts, and
 channel transport as the main app; it has no separate backend or user store.
 
+The production Docker image builds both clients and serves the BackToSchool
+client for `backtoschool.help` and `www.backtoschool.help`. Attach both domains
+to the existing NixAmp service and point their DNS at the hosting provider's
+targets. Accounts, event APIs, and live audio stay in that same process. FFmpeg
+is installed in the image so hosts can broadcast from their browser.
+
+`NIXAMP_WEB_SITES` maps public origins to built client directories, for example
+`{"https://backtoschool.help":"/app/backtoschool/dist"}`. The configured origin
+also supplies event metadata and invitation links. Other hosts use `--web`.
+An invalid mapping or missing build stops startup rather than serving the wrong
+client. `NIXAMP_SITE` continues to identify the shared NixAmp account service.
+
 Build the server and both web clients from the repository root:
 
 ```
@@ -545,6 +557,61 @@ uses its direct model; it does not first translate the audio into English.
 
 ### Hear it in your language
 
+**Buy translated audio** (`$` in the player or Transcript title bar) offers
+prepaid, account-bound passes: **$5 / 24 hours**, **$25 / 7 days**, or **$100 /
+30 days**. Each purchase provides that many dollars of usage credit, not
+unlimited listening. There is no automatic renewal. Credit expires; buying
+before expiry adds the credit and keeps the later expiry. At 1,000 translated
+characters/minute with normal recognition overlap, the passes provide about
+16, 81, or 327 minutes respectively. Actual speech density changes the allowance.
+
+Paid access is **5× base speech API cost (400% markup)**: $0.25 per 1,000 Flash
+characters and $1.10 per submitted Scribe audio hour. Recognition includes
+repeated context, normally three submitted hours per listening hour. The price
+is the same for every listener, including reused audio; reuse reduces provider
+spending. Captions and self-hosted text translation retain their existing free
+access and throttles.
+
+CoinPay hosts crypto checkout with the merchant's configured currencies. Network
+fees are shown separately at checkout. Nixamp creates fixed-price orders on the
+server and verifies the stored payment ID, confirmed status, USD currency, and
+exact price before crediting the account. Returning from checkout or sending a
+client-side `paid` flag never unlocks access. Pending purchases can be resumed
+from the panel on another device signed into the same account.
+
+PostgreSQL atomically reserves usage credit before paid calls, refunds rejected
+provider requests, and credits a confirmed payment once across concurrent checks.
+Accepted speech is charged even if playback is canceled. Money is stored as
+integer micro-USD. The ledger uses base cost rounded up to a micro-dollar, then
+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.
+
+Account servers require a paid pass by default. Configure `COINPAY_X402_KEY`
+with `payments:create` permission and at least one business wallet; the scoped
+key supplies the merchant identity. Existing credit still works during a
+checkout outage. A self-hosted operator explicitly sponsoring API usage may set
+`NIXAMP_TRANSLATION_BILLING=off`.
+
+Live Nixamp channels share **one recognition, translation, and voice pipeline
+per source and target language** on the account server. Every listening account
+pays the same access rate; joining adds no extra recognition or voice generation.
+The pipeline persists while anyone remains and closes its source and pending
+work when the last listener leaves. Disconnecting one viewer does not stop the
+others. Two connections per account, four active source/language pipelines, and
+1,000 connections per pipeline bound resource use. A slow or unfunded listener
+is disconnected independently. Background sound stays local and independently
+switchable. Public source addresses are resolved and pinned before fetching;
+redirects and ffmpeg network/file fetches are disabled.
+
+Live pipeline sharing currently runs within one account-server process (as
+nixamp.com's deployment does). Multiple replicas need stream affinity before
+scaling this path; the payment ledger already works across replicas. Files and
+individually timed browser media retain local capture, because viewers can be
+at different playback positions. Shared live streams use the same speaker voices
+for everyone; individual playback retains voice overrides.
+
+
 Use **Translate audio** beside the player's language menu to hear whatever
 Nixamp is playing in your language. One click starts translation; it selects
 your preferred supported language if the menu is still on Original. Turn it off
@@ -574,7 +641,7 @@ recognition. Native captions never translate to English as
 an intermediate recognition step.
 
 Recognition, text translation, and streaming voice playback run as separate
-stages. Each stage has at most one active request per listener. Overlapping
+stages. Each stage has at most one active request per shared pipeline or individual playback session. Overlapping
 recognition windows recover unprocessed words; unfinished phrases briefly stay
 in context instead of translating every two-second fragment separately. The
 voice player preserves pending speaker turns and fetches the next phrase with
@@ -585,8 +652,9 @@ queued speech; errors restore the original audio. This is a delayed live
 interpreter, not a promise of exact lip sync or word-by-word streaming captions.
 
 OpenStream currently compresses server-to-server relays, not this browser
-translation path. The browser uploads bounded mono 16 kHz WAV clips and plays
-streaming PCM speech. Ordinary media playback already uses its audio/video
+translation path. Individual playback uploads bounded mono 16 kHz WAV clips. Shared live channels
+are decoded on the account server and distribute the generated PCM over one
+authenticated event stream per viewer. Ordinary media playback already uses its audio/video
 codecs. The short-window overlap ratio and audio-second spending limits remain
 unchanged; smaller windows do not increase the steady-state audio submitted.
 
@@ -626,8 +694,8 @@ limits, and cached duplicate voice generation. Native speech and local
 translation retain their existing account and queue limits.
 
 Postgres stores atomic usage reservations and hashed grants, so the feature's
-budgets survive restarts and are shared between replicas. Provider failures
-still consume reservations conservatively. The configurable daily limits are:
+budgets survive restarts and are shared between replicas. Provider failures still consume the abuse budgets conservatively;
+the separate paid balance refunds requests rejected before provider acceptance. The configurable daily limits are:
 
 | Setting | Default | Counts |
 | --- | ---: | --- |
@@ -648,7 +716,11 @@ unlimited fallback provider.
 
 ```
 GET  /api/v1/speech/voices       authenticated stock voices and supported audio languages
-POST /api/v1/speech/speakers     authenticated, bounded mono 16 kHz WAV -> native speaker turns
+POST /api/v1/speech/shared       paid {source: liveChannelUrl, language} -> shared captions and PCM events
+GET  /api/v1/translation-passes  plans, balance and pending purchases
+POST /api/v1/translation-passes/checkout  authenticated {plan, coin, requestKey} -> hosted checkout
+GET  /api/v1/translation-passes/orders/:id  authenticated owner payment verification
+POST /api/v1/speech/speakers     paid, bounded mono 16 kHz WAV -> native speaker turns
 POST /api/v1/speech/grant        authenticated {channel: playbackScope} -> short-lived grant
 POST /api/v1/speech/synthesize   scoped grant + {channel, text, language, voice, profile} -> streaming PCM
 ```

package/dist/live-interpreter.d.ts

@@ -0,0 +1,70 @@
+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 translations;
+    constructor(options: {
+        language: () => string;
+        speakers: () => boolean;
+        voices: () => VoiceChoice[];
+        channel: () => string;
+        lines: (lines: Caption[]) => void;
+        status: (text: string) => void;
+        failed: () => 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[];

package/dist/live-interpreter.js

@@ -0,0 +1,243 @@
+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;
+    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.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 new Error(body.error || "Audio translation is unavailable.");
+        return body;
+    }
+    async run(generation) {
+        this.running = generation;
+        try {
+            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)
+                                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));
+                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) {
+                this.reset();
+                this.options.failed();
+                this.options.status(error instanceof Error ? error.message : "Live translation stopped.");
+            }
+        }
+        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();
+                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] }));
+                }
+                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) {
+                this.reset();
+                this.options.failed();
+                this.options.status(error instanceof Error ? error.message : "Live translation stopped.");
+            }
+        }
+        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) };
+    });
+}

package/dist/live-voice.d.ts

@@ -1,5 +1,6 @@
 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;
@@ -32,6 +33,7 @@ export declare class LiveVoice {
     private readonly grants;
     private readonly activeBy;
     private readonly db?;
+    private readonly billing?;
     private schema;
     private readonly dailyChars;
     private cleanupAt;
@@ -49,12 +51,13 @@ export declare class LiveVoice {
         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): Promise<SpeakerTranscript>;
+    hear(bytes: Uint8Array, by: string, signal?: AbortSignal, meter?: TranslationMeter | undefined): Promise<SpeakerTranscript>;
     voices(): Promise<LiveVoiceChoice[]>;
     /** A 90-second capability for one channel, never the viewer's account credential. */
     grant(by: string, channel: string): Promise<{
@@ -67,5 +70,5 @@ export declare class LiveVoice {
     private charge;
     private checkRequest;
     /** Stream the first request immediately; concurrent listeners share its cached result. */
-    stream(ask: VoiceRequest, by: string, signal?: AbortSignal): Promise<Response>;
+    stream(ask: VoiceRequest, by: string, signal?: AbortSignal, meter?: TranslationMeter | undefined): Promise<Response>;
 }

package/dist/live-voice.js

@@ -22,6 +22,7 @@ export class LiveVoice {
     grants = new Map();
     activeBy = new Map();
     db;
+    billing;
     schema = null;
     dailyChars;
     cleanupAt = 0;
@@ -40,14 +41,16 @@ export class LiveVoice {
         this.userDailyAudioSeconds = budget(options.userDailyAudioSeconds, 43_200);
         this.requests = new Guard(this.now);
         this.db = options.db;
+        this.billing = options.billing;
     }
     available() { return this.key !== ""; }
     /** 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. */
-    async hear(bytes, by, signal) {
+    async hear(bytes, by, signal, meter = this.billing) {
         if (!this.available())
             throw new SpeechError("speaker voices are unavailable", 503);
+        await meter?.require(by);
         const wav = decodeWav(bytes);
         const seconds = wav.samples.length / wav.rate;
         if (wav.rate !== 16000 || wav.channels !== 1 || seconds < 0.2 || seconds > 15.1)
@@ -61,6 +64,8 @@ export class LiveVoice {
         if (this.hearing.has(by) || this.hearing.size >= 4)
             throw new SpeechError("speaker transcription is busy", 429);
         this.hearing.add(by);
+        let reservation;
+        let accepted = false;
         try {
             const billed = Math.ceil(seconds);
             await this.reserve(`scribe:user:${by}`, billed, 300, 60_000);
@@ -77,14 +82,23 @@ export class LiveVoice {
             form.set("tag_audio_events", "false");
             form.set("timestamps_granularity", "word");
             // No language_code: preserve the source language, including Spanish.
+            reservation = await meter?.reserve(by, "transcription", wav.samples.length);
             const answer = await this.fetcher("https://api.elevenlabs.io/v1/speech-to-text", {
                 method: "POST", headers: { "xi-api-key": this.key }, body: form,
                 signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(10_000)]) : AbortSignal.timeout(10_000),
             });
             if (!answer.ok)
                 throw new SpeechError("speaker transcription could not run; check provider quota and permissions", answer.status === 429 ? 429 : 502);
+            accepted = true;
+            if (reservation)
+                await meter.commit(reservation);
             return speakerTurns(await answer.json(), wav);
         }
+        catch (error) {
+            if (reservation && !accepted)
+                await meter.refund(reservation);
+            throw error;
+        }
         finally {
             this.hearing.delete(by);
         }
@@ -113,6 +127,7 @@ export class LiveVoice {
             throw new SpeechError("choose a playback session or live channel", 400);
         if (!this.requests.check(`grant:${by}`, { allowed: 10, windowMs: 60_000 }).ok)
             throw new SpeechError("too many audio authorization requests", 429);
+        await this.billing?.require(by);
         for (const [token, grant] of this.grants)
             if (grant.expires <= this.now())
                 this.grants.delete(token);
@@ -200,8 +215,9 @@ export class LiveVoice {
             throw new SpeechError("too many translated audio requests", 429);
     }
     /** Stream the first request immediately; concurrent listeners share its cached result. */
-    async stream(ask, by, signal) {
+    async stream(ask, by, signal, meter = this.billing) {
         this.checkRequest(by);
+        await meter?.require(by);
         const text = typeof ask.text === "string" ? ask.text.trim() : "";
         if (!text || text.length > 600)
             throw new SpeechError("translated audio needs a caption of 1–600 characters", 400);
@@ -222,11 +238,15 @@ export class LiveVoice {
             if (item.until < this.now())
                 this.cache.delete(key);
         const cached = this.cache.get(id);
-        if (cached)
-            return new Response(new Uint8Array(cached.bytes), { headers: HEADERS });
         const pending = this.pending.get(id);
-        if (pending)
-            return new Response(new Uint8Array(await pending), { headers: HEADERS });
+        if (cached || pending) {
+            const bytes = cached?.bytes ?? await pending;
+            signal?.throwIfAborted();
+            const paid = await meter?.reserve(by, "voice", text.length);
+            if (paid)
+                await meter.commit(paid);
+            return new Response(new Uint8Array(bytes), { headers: HEADERS });
+        }
         if (this.pending.size >= 4)
             throw new SpeechError("translated audio is busy; waiting for the next caption", 429);
         if ((this.activeBy.get(by) ?? 0) >= 2)
@@ -240,9 +260,12 @@ export class LiveVoice {
         const release = () => { this.pending.delete(id); this.activeBy.set(by, Math.max(0, (this.activeBy.get(by) ?? 1) - 1)); if (!this.activeBy.get(by))
             this.activeBy.delete(by); };
         void finished.catch(() => undefined);
+        let reservation;
+        let accepted = false;
         try {
             await this.charge(by, ask.channel ?? "direct", text.length);
             signal?.throwIfAborted();
+            reservation = await meter?.reserve(by, "voice", text.length);
             const response = await this.fetcher(`https://api.elevenlabs.io/v1/text-to-speech/${voice.id}/stream?output_format=pcm_16000`, {
                 method: "POST",
                 headers: { "xi-api-key": this.key, "content-type": "application/json" },
@@ -251,6 +274,10 @@ export class LiveVoice {
             });
             if (!response.ok || !response.body)
                 throw new SpeechError(response.status === 429 ? "ElevenLabs audio quota is temporarily exhausted" : "ElevenLabs could not generate audio; check the server key and quota", response.status === 429 ? 429 : 502);
+            // Once the provider accepts, aborting playback cannot refund heard audio.
+            accepted = true;
+            if (reservation)
+                await meter.commit(reservation);
             const [play, keep] = response.body.tee();
             void (async () => {
                 const reader = keep.getReader();
@@ -295,6 +322,8 @@ export class LiveVoice {
         catch (error) {
             fail(error);
             release();
+            if (reservation && !accepted)
+                await meter.refund(reservation);
             throw error;
         }
     }

package/dist/pcm-wav.d.ts

@@ -0,0 +1,2 @@
+/** 16-bit mono PCM WAV bytes from samples in [-1, 1]. */
+export declare function encodeWav(samples: Float32Array, rate?: number): Uint8Array;

package/dist/pcm-wav.js

@@ -0,0 +1,27 @@
+/** 16-bit mono PCM WAV bytes from samples in [-1, 1]. */
+export function encodeWav(samples, rate = 16000) {
+    const bytes = new Uint8Array(44 + samples.length * 2);
+    const view = new DataView(bytes.buffer);
+    const ascii = (at, text) => {
+        for (let i = 0; i < text.length; i++)
+            bytes[at + i] = text.charCodeAt(i);
+    };
+    ascii(0, "RIFF");
+    view.setUint32(4, 36 + samples.length * 2, true);
+    ascii(8, "WAVE");
+    ascii(12, "fmt ");
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, 1, true);
+    view.setUint32(24, rate, true);
+    view.setUint32(28, rate * 2, true);
+    view.setUint16(32, 2, true);
+    view.setUint16(34, 16, true);
+    ascii(36, "data");
+    view.setUint32(40, samples.length * 2, true);
+    for (let i = 0; i < samples.length; i++) {
+        const clipped = Math.max(-1, Math.min(1, samples[i]));
+        view.setInt16(44 + i * 2, clipped < 0 ? clipped * 32768 : clipped * 32767, true);
+    }
+    return bytes;
+}

package/dist/server.d.ts

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