nixamp 0.26.6 → 0.27.0

package/src/live-voice.ts

@@ -4,6 +4,7 @@ import { SpeechError, decodeWav, encodeWav, quietSamples } from "./speech.ts";
 import { speakerTurns, type ScribeResult, type SpeakerTranscript } from "./speaker-turns.ts";
 import type { VoiceProfile } from "./voice-profile.ts";
 import { Guard } from "./guard.ts";
+import type { TranslationMeter } from "./translation-passes.ts";
 import type { Queryable } from "./follows.ts";
 
 export const LIVE_VOICE_MODEL = "eleven_flash_v2_5";
@@ -28,6 +29,7 @@ export class LiveVoice {
   private readonly grants = new Map<string, { by: string; channel: string; expires: number; remaining: number }>();
   private readonly activeBy = new Map<string, number>();
   private readonly db?: Queryable;
+  private readonly billing?: TranslationMeter;
   private schema: Promise<unknown> | null = null;
   private readonly dailyChars: number;
   private cleanupAt = 0;
@@ -36,7 +38,7 @@ export class LiveVoice {
   private readonly userDailyChars: number;
   private readonly userDailyAudioSeconds: number;
 
-  constructor(options: { apiKey?: string; fetcher?: typeof fetch; now?: () => number; charsPerMinute?: number; dailyChars?: number; dailyAudioSeconds?: number; userDailyChars?: number; userDailyAudioSeconds?: number; db?: Queryable } = {}) {
+  constructor(options: { apiKey?: string; fetcher?: typeof fetch; now?: () => number; charsPerMinute?: number; dailyChars?: number; dailyAudioSeconds?: number; userDailyChars?: number; userDailyAudioSeconds?: number; db?: Queryable; billing?: TranslationMeter } = {}) {
     this.key = options.apiKey ?? process.env["ELEVENLABS_API_KEY"] ?? "";
     this.fetcher = options.fetcher ?? fetch;
     this.now = options.now ?? Date.now;
@@ -47,6 +49,7 @@ 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(): boolean { return this.key !== ""; }
@@ -54,16 +57,19 @@ export class LiveVoice {
   /** 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: Uint8Array, by: string, signal?: AbortSignal): Promise<SpeakerTranscript> {
+  async hear(bytes: Uint8Array, by: string, signal?: AbortSignal, meter = this.billing): Promise<SpeakerTranscript> {
     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) throw new SpeechError("send up to 15 seconds of mono 16 kHz WAV", 400);
     if (wav.samples.some(sample => !Number.isFinite(sample))) throw new SpeechError("invalid audio samples", 400);
-    if (!this.requests.check(`hear:${by}`, { allowed: 20, windowMs: 60_000 }).ok) throw new SpeechError("too many speaker transcription requests", 429);
+    if (!this.requests.check(`hear:${by}`, { allowed: 36, windowMs: 60_000 }).ok) throw new SpeechError("too many speaker transcription requests", 429);
     if (quietSamples(wav.samples)) return { language: "", seconds, turns: [] };
     if (this.hearing.has(by) || this.hearing.size >= 4) throw new SpeechError("speaker transcription is busy", 429);
     this.hearing.add(by);
+    let reservation: string | undefined;
+    let accepted = false;
     try {
       const billed = Math.ceil(seconds);
       await this.reserve(`scribe:user:${by}`, billed, 300, 60_000);
@@ -80,12 +86,18 @@ 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() as ScribeResult, wav);
+    } catch (error) {
+      if (reservation && !accepted) await meter!.refund(reservation);
+      throw error;
     } finally { this.hearing.delete(by); }
   }
 
@@ -110,6 +122,7 @@ export class LiveVoice {
   async grant(by: string, channel: string): Promise<{ token: string; expires: number }> {
     if (!/^[\w-]{1,80}$/.test(channel)) 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);
     if (this.grants.size >= 5000) throw new SpeechError("audio authorization is busy", 503);
     const token = `nxd_${randomBytes(32).toString("base64url")}`;
@@ -185,8 +198,9 @@ export class LiveVoice {
   }
 
   /** Stream the first request immediately; concurrent listeners share its cached result. */
-  async stream(ask: VoiceRequest, by: string, signal?: AbortSignal): Promise<Response> {
+  async stream(ask: VoiceRequest, by: string, signal?: AbortSignal, meter = this.billing): Promise<Response> {
     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);
     if (!LIVE_VOICE_LANGUAGES.has(ask.language)) throw new SpeechError("this language is not supported by Flash voices", 400);
@@ -202,9 +216,14 @@ export class LiveVoice {
     const id = createHash("sha256").update(JSON.stringify([LIVE_VOICE_MODEL, voice.id, ask.language, text])).digest("hex");
     for (const [key, item] of this.cache) 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) throw new SpeechError("two voice requests are already active for this account", 429);
     // Register before the first provider await, so identical requests cannot both bill.
@@ -215,9 +234,12 @@ export class LiveVoice {
     this.activeBy.set(by, (this.activeBy.get(by) ?? 0) + 1);
     const release = (): void => { 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: string | undefined;
+    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" },
@@ -225,6 +247,9 @@ export class LiveVoice {
         signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(10_000)]) : AbortSignal.timeout(10_000),
       });
       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();
@@ -251,7 +276,9 @@ export class LiveVoice {
       })();
       return new Response(play, { headers: HEADERS });
     } catch (error) {
-      fail(error); release(); throw error;
+      fail(error); release();
+      if (reservation && !accepted) await meter!.refund(reservation);
+      throw error;
     }
   }
 }

package/src/pcm-wav.ts

@@ -0,0 +1,26 @@
+/** 16-bit mono PCM WAV bytes from samples in [-1, 1]. */
+export function encodeWav(samples: Float32Array, rate = 16000): Uint8Array {
+  const bytes = new Uint8Array(44 + samples.length * 2);
+  const view = new DataView(bytes.buffer);
+  const ascii = (at: number, text: string): void => {
+    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] as number));
+    view.setInt16(44 + i * 2, clipped < 0 ? clipped * 32768 : clipped * 32767, true);
+  }
+  return bytes;
+}

package/src/server.ts

@@ -18,6 +18,8 @@ import { spawn, spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { Readable } from "node:stream";
 import { pipeline as pipeStream } from "node:stream/promises";
+import { SharedTranslations, type SharedEvent } from "./shared-translation.ts";
+import { TranslationPasses } from "./translation-passes.ts";
 import { LiveVoice, LIVE_VOICE_LANGUAGES, LIVE_VOICE_MODEL, type VoiceRequest } from "./live-voice.ts";
 import { Connections, type Kind } from "./connections.ts";
 import {
@@ -1599,6 +1601,8 @@ async function readBytes(request: IncomingMessage, limit: number): Promise<Uint8
 
 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. */
@@ -1760,6 +1764,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. */
@@ -1843,6 +1849,9 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
   return async function handle(request: IncomingMessage, response: ServerResponse): Promise<void> {
     const url = new URL(request.url ?? "/", "http://localhost");
     const path = url.pathname;
+    const webSite = options.webSites?.get((request.headers.host ?? "").toLowerCase());
+    const web = webSite?.web ?? options.web;
+    const eventSite = webSite?.site ?? options.invites?.site;
     const key = options.key ?? null;
     const behindProxy = options.behindProxy ?? false;
     const listenKey = options.listenKey ?? null;
@@ -1934,7 +1943,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       ...(options.layouts ? { layouts: options.layouts } : {}),
       ...(options.rooms ? { rooms: options.rooms } : {}),
       ...(options.tickets ? { tickets: options.tickets } : {}),
-      ...(options.invites?.site ? { site: options.invites.site } : {}),
+      ...(eventSite ? { site: eventSite } : {}),
       ...(options.invites?.email ? { email: options.invites.email } : {}),
     })) return;
 
@@ -2852,6 +2861,75 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       return;
     }
 
+    if (path === "/api/v1/speech/shared" && request.method === "POST") {
+      try {
+        const service = options.sharedTranslations;
+        const who = await options.accounts?.whoIs(tokenFrom(request.headers));
+        if (!who) throw new SpeechError("Sign in to translate live audio.", 401);
+        if (!service) throw new SpeechError("Shared translation is unavailable.", 503);
+        const caller = callerOf(request.headers, request.socket.remoteAddress, options.behindProxy ?? false);
+        if (!guard.check(`shared-join:${who.id}`, { allowed: 10, windowMs: 60_000 }).ok || !guard.check(`shared-ip:${caller}`, { allowed: 30, windowMs: 60_000 }).ok) throw new SpeechError("Too many live translation joins.", 429);
+        if (!request.headers["content-type"]?.startsWith("application/json")) throw new SpeechError("Send a live source as JSON.", 415);
+        let body: { source?: unknown; language?: unknown };
+        try { body = JSON.parse(await readBody(request, 4096)); } catch { throw new SpeechError("Choose a live source and language.", 400); }
+        if (typeof body?.source !== "string" || typeof body.language !== "string") throw new SpeechError("Choose a live source and language.", 400);
+        const queued: SharedEvent[] = [];
+        let finished = false;
+        const send = (event: SharedEvent): void => {
+          if (!response.headersSent) { queued.push(event); return; }
+          if (response.destroyed || response.writableLength > 512_000) throw new Error("slow listener");
+          response.write(`data: ${JSON.stringify(event)}\n\n`);
+        };
+        const leave = await service.join(body.source, body.language, who.id, send, () => { finished = true; if (response.headersSent) response.end(); });
+        if (response.destroyed) { leave(); return; }
+        response.writeHead(200, { ...CORS, "content-type": "text/event-stream", "cache-control": "no-store", "x-accel-buffering": "no" });
+        for (const event of queued) send(event);
+        if (finished) { leave(); response.end(); return; }
+        const heartbeat = setInterval(() => { if (!response.destroyed) response.write(": listening\n\n"); }, 10_000);
+        response.once("close", () => { clearInterval(heartbeat); leave(); });
+      } catch (error) {
+        if (response.headersSent) response.end();
+        else json(response, error instanceof SpeechError ? error.status : 502, { error: error instanceof SpeechError ? error.message : "Shared translation is unavailable." });
+      }
+      return;
+    }
+
+    if (path === "/api/v1/translation-passes" || path.startsWith("/api/v1/translation-passes/")) {
+      response.setHeader("cache-control", "no-store");
+      try {
+        const caller = callerOf(request.headers, request.socket.remoteAddress, options.behindProxy ?? false);
+        if (!guard.check(`translation-pass-ip:${caller}`, { allowed: 120, windowMs: 60_000 }).ok) throw new SpeechError("Too many purchase requests.", 429);
+        const service = options.translationPasses;
+        if (!service || !options.accounts) {
+          if (path === "/api/v1/translation-passes" && request.method === "GET") json(response, 200, { required: false, available: false, balanceMicros: 0, expires: null, plans: [], coins: [], orders: [] });
+          else json(response, 503, { error: "Translation checkout is unavailable." });
+          return;
+        }
+        const who = await options.accounts.whoIs(tokenFrom(request.headers));
+        if (path === "/api/v1/translation-passes" && request.method === "GET") {
+          json(response, 200, await service.access(who?.id)); return;
+        }
+        if (!who) throw new SpeechError("Sign in to buy translated audio.", 401);
+        if (!guard.check(`translation-pass-account:${who.id}`, { allowed: 30, windowMs: 60_000 }).ok) throw new SpeechError("Too many purchase requests.", 429);
+        if (path === "/api/v1/translation-passes/checkout" && request.method === "POST") {
+          if (!request.headers["content-type"]?.startsWith("application/json")) throw new SpeechError("Send a purchase as JSON.", 415);
+          if (!guard.check(`translation-checkout-ip:${caller}`, { allowed: 10, windowMs: 3600_000 }).ok) throw new SpeechError("Too many new checkouts. Resume your pending purchase.", 429);
+          let body: Record<string, unknown>;
+          try { body = JSON.parse(await readBody(request, 1024)); } catch { throw new SpeechError("Choose a translation pass.", 400); }
+          if (!body || typeof body !== "object" || typeof body["plan"] !== "string" || typeof body["coin"] !== "string" || typeof body["requestKey"] !== "string") throw new SpeechError("Choose a translation pass and payment currency.", 400);
+          json(response, 200, await service.checkout(who.id, body["plan"], body["coin"], body["requestKey"])); return;
+        }
+        const order = path.match(/^\/api\/v1\/translation-passes\/orders\/([^/]+)$/);
+        if (order && request.method === "GET") {
+          json(response, 200, await service.check(who.id, order[1]!)); return;
+        }
+        json(response, 405, { error: "GET your balance or purchase status; POST a checkout." });
+      } catch (error) {
+        json(response, error instanceof SpeechError ? error.status : 502, { error: error instanceof SpeechError ? error.message : "Translation purchases are temporarily unavailable." });
+      }
+      return;
+    }
+
     /*
      * Speech to text: a WAV in, the words out. Signed in only -- the ear
      * costs CPU and a trollbox line needs a name anyway -- and, given a
@@ -5358,8 +5436,8 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       return;
     }
 
-    if (options.web !== null) {
-      const direct = safeJoin(options.web, path);
+    if (web !== null) {
+      const direct = safeJoin(web, path);
       if (direct === null) {
         json(response, 400, { error: "bad path" });
         return;
@@ -5368,7 +5446,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       if (isFile(direct)) file = direct;
       else if (isFile(join(direct, "index.html"))) file = join(direct, "index.html");
       // A single-page app: any unknown path is the shell, and the client routes.
-      else if (isFile(join(options.web, "index.html"))) file = join(options.web, "index.html");
+      else if (isFile(join(web, "index.html"))) file = join(web, "index.html");
       if (file !== null) {
         if (file.endsWith("index.html") && path.startsWith("/live/") && options.events) {
           try {
@@ -5381,7 +5459,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
             if (event && (await options.events.canAccess(event, account?.id) || invited)) {
               const shell = readIfPossible(file);
               if (shell !== null) {
-                html(response, 200, eventDocument(shell, event, options.invites?.site ?? "https://backtoschool.help"));
+                html(response, 200, eventDocument(shell, event, eventSite ?? "https://backtoschool.help"));
                 return;
               }
             }
@@ -5391,7 +5469,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           const subject = joinSubject(url, options);
           const shell = subject ? readIfPossible(file) : null;
           if (subject && shell !== null) {
-            html(response, 200, joinDocument(shell, subject, options.invites?.site ?? "https://nixamp.com"));
+            html(response, 200, joinDocument(shell, subject, eventSite ?? "https://nixamp.com"));
             return;
           }
         }
@@ -5832,6 +5910,8 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   if (!options.noJingle) playJingle(tools);
 
   const web = options.web !== null ? resolve(options.web) : defaultWebDir();
+  const { webSitesFromEnv } = await import("./web-sites.ts");
+  const webSites = webSitesFromEnv();
   // The same keys this port used last time, so a link somebody was given
   // still works after a restart -- and a server is restarted to pick up a new
   // version, which is to say often. `--new-key` mints a fresh pair and forgets
@@ -6001,8 +6081,14 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   // the first person to speak does not wait for the model to arrive; a box
   // without the optional model never says it is ready, and answers 503.
   const speech = accounts && process.env["NIXAMP_STT"] !== "off" ? new Speech() : undefined;
+  // Account servers meter paid providers by default, including when checkout
+  // is temporarily unconfigured. Self-hosters can explicitly sponsor usage.
+  const translationPasses = accounts && pool && process.env["NIXAMP_TRANSLATION_BILLING"] !== "off"
+    ? new TranslationPasses({ db: pool, key: process.env["COINPAY_X402_KEY"] ?? "", site: nixampSite }) : undefined;
+  if (translationPasses) void translationPasses.access().catch(() => console.error("nixamp: translation checkout could not warm; it will retry on demand"));
   const liveVoice = accounts && process.env["NIXAMP_DUBBING"] !== "off" ? new LiveVoice({
     ...(pool ? { db: pool } : {}),
+    ...(translationPasses ? { billing: translationPasses } : {}),
     dailyChars: Number(process.env["NIXAMP_DUB_DAILY_CHARS"] ?? 200_000),
     dailyAudioSeconds: Number(process.env["NIXAMP_DUB_DAILY_AUDIO_SECONDS"] ?? 86_400),
     userDailyChars: Number(process.env["NIXAMP_DUB_USER_DAILY_CHARS"] ?? 120_000),
@@ -6018,6 +6104,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   // names pairs to load at boot (en-de,en-sv) so the first line does not
   // wait; NIXAMP_MT=off turns it off.
   const translator = accounts && process.env["NIXAMP_MT"] !== "off" ? new Translator() : undefined;
+  const sharedTranslations = liveVoice && translator ? new SharedTranslations({ voice: liveVoice, translator, ...(translationPasses ? { billing: translationPasses } : {}) }) : undefined;
   if (translator) {
     const warm = (process.env["NIXAMP_MT_WARM"] ?? "").split(",").map((one) => one.trim()).filter(Boolean);
     if (warm.length > 0) {
@@ -6414,6 +6501,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
 
   const server = createServer(engine, {
     web,
+    webSites,
     media: options.media,
     owner,
     channels,
@@ -6500,6 +6588,8 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ...(trollbox ? { trollbox } : {}),
     ...(speech ? { speech } : {}),
     ...(liveVoice ? { liveVoice } : {}),
+    ...(translationPasses ? { translationPasses } : {}),
+    ...(sharedTranslations ? { sharedTranslations } : {}),
     ...(translator ? { translator } : {}),
     ...(transcripts ? { transcripts } : {}),
     ...(translations ? { translations } : {}),

package/src/shared-translation.ts

@@ -0,0 +1,218 @@
+/** One live source/language pipeline, paid access for every listening account.
+ * Browsers receive the same PCM, never upload a replacement for a public feed. */
+import { createHash, randomUUID } from "node:crypto";
+import { lookup } from "node:dns/promises";
+import { BlockList, isIP } from "node:net";
+import http from "node:http";
+import https from "node:https";
+import { spawn } from "node:child_process";
+import { Interpreter, type Caption } from "./live-interpreter.ts";
+import { LiveVoice, LIVE_VOICE_LANGUAGES } from "./live-voice.ts";
+import { SpeechError } from "./speech.ts";
+import type { Translator } from "./translate.ts";
+import type { TranslationMeter, TranslationUsage } from "./translation-passes.ts";
+
+const blocked = new BlockList();
+for (const [ip, bits] of [["0.0.0.0",8],["10.0.0.0",8],["100.64.0.0",10],["127.0.0.0",8],["169.254.0.0",16],["172.16.0.0",12],["192.0.0.0",24],["192.0.2.0",24],["192.168.0.0",16],["198.18.0.0",15],["198.51.100.0",24],["203.0.113.0",24],["224.0.0.0",4],["240.0.0.0",4]] as const) blocked.addSubnet(ip, bits, "ipv4");
+const v6global = new BlockList(); v6global.addSubnet("2000::", 3, "ipv6");
+blocked.addSubnet("2001:db8::", 32, "ipv6"); blocked.addSubnet("2002::", 16, "ipv6"); blocked.addSubnet("2001::", 32, "ipv6");
+export function publicStreamAddress(address: string): boolean {
+  const family = isIP(address);
+  return family === 4 ? !blocked.check(address, "ipv4") : family === 6 && v6global.check(address, "ipv6") && !blocked.check(address, "ipv6");
+}
+export function sharedSource(raw: string): URL {
+  let url: URL;
+  try { url = new URL(raw); } catch { throw new SpeechError("Choose a live Nixamp channel.", 400); }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash || !/^\/api\/channels\/[\w-]{1,80}$/.test(url.pathname) || [...url.searchParams.keys()].some(key => key !== "k")) throw new SpeechError("Choose a live Nixamp channel.", 400);
+  if (url.toString().length > 2048) throw new SpeechError("Invalid live source.", 400);
+  url.searchParams.sort(); return url;
+}
+export interface LiveInput { stop(): void; }
+export type OpenLiveInput = (source: URL, pcm: (bytes: Buffer) => void, ended: () => void, signal: AbortSignal) => Promise<LiveInput>;
+
+/** Resolve once and pin that public address; no redirects or ffmpeg URL fetches. */
+export function liveInput(ffmpeg: string[] = ["ffmpeg"]): OpenLiveInput {
+  return async (source, pcm, ended, signal) => {
+    const hostname = source.hostname.replace(/^\[|\]$/g, "");
+    const addresses = await lookup(hostname, { all: true });
+    if (!addresses.length || addresses.some(one => !publicStreamAddress(one.address))) throw new SpeechError("This live source is not publicly reachable.", 400);
+    signal.throwIfAborted();
+    const selected = addresses[0]!;
+    const child = spawn(ffmpeg[0]!, [...ffmpeg.slice(1), "-v", "error", "-nostats", "-protocol_whitelist", "pipe", "-readrate", "1", "-analyzeduration", "500000", "-probesize", "262144", "-i", "pipe:0", "-vn", "-ac", "1", "-ar", "16000", "-f", "s16le", "pipe:1"], { stdio: ["pipe", "pipe", "ignore"] });
+    let stopped = false;
+    const request = (source.protocol === "https:" ? https : http).get(source, {
+      signal, headers: { "user-agent": "Nixamp shared translated audio", accept: "audio/*,video/*,application/octet-stream" },
+      lookup: (_name, options, callback) => { if (typeof options === "object" && options.all) callback(null, [selected]); else callback(null, selected.address, selected.family); },
+    });
+    const stop = (): void => { if (stopped) return; stopped = true; request.destroy(); child.stdin.destroy(); child.kill("SIGKILL"); signal.removeEventListener("abort", stop); };
+    const end = (): void => { if (!stopped) { stop(); ended(); } };
+    signal.addEventListener("abort", stop, { once: true });
+    child.stdout.on("data", pcm); child.on("error", end); child.on("close", end); child.stdin.on("error", end);
+    request.on("response", response => {
+      if (response.statusCode !== 200) { response.destroy(); end(); return; }
+      response.on("error", end); response.on("end", end); response.pipe(child.stdin);
+    });
+    request.on("error", end);
+    request.setTimeout(15_000, end);
+    return { stop };
+  };
+}
+
+export type SharedEvent = { type: "status"; listeners: number } | { type: "line"; id: string; line: Caption } | { type: "audio"; id: string; data: string } | { type: "end"; id: string } | { type: "error"; error: string };
+type Member = { by: string; send: (event: SharedEvent) => void; close: () => void };
+interface Feed { id: string; source: URL; language: string; members: Set<Member>; controller: AbortController; input?: LiveInput; interpreter: Interpreter; meter: TranslationMeter; reservations: Map<string, string[]>; queue: Caption[]; speaking: boolean; previous: Buffer; pending: Buffer; until: number; heartbeat?: ReturnType<typeof setInterval>; }
+
+export class SharedTranslations {
+  private readonly feeds = new Map<string, Feed>();
+  constructor(private readonly options: { voice: LiveVoice; translator: Pick<Translator, "translate">; billing?: TranslationMeter; open?: OpenLiveInput }) {}
+  get size(): number { return this.feeds.size; }
+
+  async join(raw: string, language: string, by: string, send: Member["send"], close: () => void): Promise<() => void> {
+    if (!this.options.voice.available()) throw new SpeechError("Translated audio is unavailable.", 503);
+    const source = sharedSource(raw);
+    if (!LIVE_VOICE_LANGUAGES.has(language)) throw new SpeechError("Choose a supported audio language.", 400);
+    await this.options.billing?.require(by);
+    const connections = [...this.feeds.values()].reduce((total, feed) => total + [...feed.members].filter(member => member.by === by).length, 0);
+    if (connections >= 2) throw new SpeechError("Translated audio is already open in two players for this account.", 429);
+    const id = `dub-${createHash("sha256").update(`${source}|${language}`).digest("hex").slice(0, 40)}`;
+    let feed = this.feeds.get(id);
+    if (!feed) {
+      if (this.feeds.size >= 4) throw new SpeechError("Live translation is busy. Try again shortly.", 429);
+      feed = this.make(id, source, language); this.feeds.set(id, feed);
+      const current = feed;
+      current.heartbeat = setInterval(() => void this.checkMembers(current), 10_000); current.heartbeat.unref?.();
+    }
+    if (feed.members.size >= 1000) throw new SpeechError("This translated stream is full. Try again shortly.", 429);
+    const member = { by, send, close }; feed.members.add(member);
+    this.broadcast(feed, { type: "status", listeners: feed.members.size });
+    if (feed.members.size === 1 && !feed.input) void this.start(feed);
+    const current = feed;
+    return () => this.leave(current, member);
+  }
+  private leave(feed: Feed, member: Member): void {
+    if (!feed.members.delete(member)) return;
+    if (!feed.members.size) {
+      if (feed.heartbeat) clearInterval(feed.heartbeat);
+      feed.controller.abort(); feed.input?.stop(); feed.interpreter.reset(); feed.queue = [];
+      this.feeds.delete(feed.id);
+    } else this.broadcast(feed, { type: "status", listeners: feed.members.size });
+  }
+  private async checkMembers(feed: Feed): Promise<void> {
+    const accounts = [...new Set([...feed.members].map(member => member.by))];
+    let funded = new Set(accounts), message = "Your translation balance is used up or expired. Buy another pass to continue.";
+    try {
+      if (this.options.billing?.eligible) funded = new Set(await this.options.billing.eligible(accounts));
+      else if (this.options.billing) {
+        const results = await Promise.allSettled(accounts.map(by => this.options.billing!.require(by)));
+        funded = new Set(accounts.filter((_by, index) => results[index]?.status === "fulfilled"));
+      }
+    } catch { funded.clear(); message = "Your translation balance could not be checked. Try again shortly."; }
+    for (const member of [...feed.members]) if (accounts.includes(member.by) && !funded.has(member.by)) {
+      try { member.send({ type: "error", error: message }); } catch { /* disconnected */ }
+      finally { this.leave(feed, member); member.close(); }
+    }
+  }
+  private broadcast(feed: Feed, event: SharedEvent): void {
+    for (const member of [...feed.members]) {
+      try { member.send(event); } catch { this.leave(feed, member); member.close(); }
+    }
+  }
+  private stop(feed: Feed, error: string): void {
+    this.broadcast(feed, { type: "error", error });
+    for (const member of [...feed.members]) { this.leave(feed, member); member.close(); }
+  }
+  private make(id: string, source: URL, language: string): Feed {
+    const feed = { id, source, language, members: new Set<Member>(), controller: new AbortController(), reservations: new Map<string, string[]>(), queue: [], speaking: false, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() } as unknown as Feed;
+    // Every active account pays the same published access rate. API work is
+    // done once; additional listeners do not trigger recognition or synthesis.
+    feed.meter = {
+      require: async () => { if (!feed.members.size) throw new SpeechError("No listeners.", 410); },
+      reserve: async (_by: string, kind: TranslationUsage, units: number) => {
+        const ids: string[] = [];
+        const accounts = [...new Set([...feed.members].map(member => member.by))];
+        const accepted = new Set<string>();
+        const billing = this.options.billing;
+        if (billing?.reserveMany) {
+          for (const charged of await billing.reserveMany(accounts, kind, units)) { ids.push(charged.id); accepted.add(charged.by); }
+        } else {
+          const results = await Promise.allSettled(accounts.map(async account => ({ by: account, id: await billing?.reserve(account, kind, units) })));
+          let failure: unknown;
+          for (const result of results) {
+            if (result.status === "fulfilled") { accepted.add(result.value.by); if (result.value.id) ids.push(result.value.id); }
+            else if (!(result.reason instanceof SpeechError) || result.reason.status !== 402) failure = result.reason;
+          }
+          if (failure) { await Promise.all(ids.map(id => billing!.refund(id))); throw failure; }
+        }
+        for (const member of [...feed.members]) if (accounts.includes(member.by) && !accepted.has(member.by)) {
+          try { member.send({ type: "error", error: "Your translation balance is used up or expired. Buy another pass to continue." }); }
+          catch { /* disconnected */ } finally { this.leave(feed, member); member.close(); }
+        }
+        if (!feed.members.size) { await Promise.all(ids.map(id => this.options.billing!.refund(id))); throw new SpeechError("No funded listeners.", 402); }
+        const reservation = randomUUID(); feed.reservations.set(reservation, ids); return reservation;
+      },
+      commit: async id => { const ids = feed.reservations.get(id) ?? []; if (this.options.billing?.commitMany) await this.options.billing.commitMany(ids); else await Promise.all(ids.map(id => this.options.billing!.commit(id))); feed.reservations.delete(id); },
+      refund: async id => { const ids = feed.reservations.get(id) ?? []; if (this.options.billing?.refundMany) await this.options.billing.refundMany(ids); else await Promise.all(ids.map(id => this.options.billing!.refund(id))); feed.reservations.delete(id); },
+    };
+    let voices: Awaited<ReturnType<LiveVoice["voices"]>> = [];
+    feed.interpreter = new Interpreter({
+      language: () => language, speakers: () => true, voices: () => voices, channel: () => id,
+      status: text => { if (!feed.controller.signal.aborted && !feed.members.size) this.stop(feed, text); },
+      failed: () => this.stop(feed, "Live translation stopped. Enable it again to retry."),
+      lines: lines => {
+        feed.queue.push(...lines);
+        if (feed.queue.length > 24) { this.stop(feed, "Live translation fell behind. Enable it again to retry."); return; }
+        if (!feed.speaking) void this.speak(feed);
+      },
+      fetcher: (async (url, init) => {
+        feed.controller.signal.throwIfAborted();
+        const signal = AbortSignal.any([feed.controller.signal, ...(init?.signal ? [init.signal] : [])]);
+        if (String(url).includes("/speakers")) {
+          voices = await this.options.voice.voices();
+          return Response.json(await this.options.voice.hear(new Uint8Array(init?.body as Uint8Array), id, signal, feed.meter));
+        }
+        const body = JSON.parse(String(init?.body));
+        return Response.json(await this.options.translator.translate(body.texts, body.from, body.to, { by: id, deadline: Date.now() + 10_000 }));
+      }) as typeof fetch,
+    });
+    return feed;
+  }
+  private async start(feed: Feed): Promise<void> {
+    try {
+      const input = await (this.options.open ?? liveInput())(feed.source, bytes => {
+        if (feed.controller.signal.aborted) return;
+        feed.pending = Buffer.concat([feed.pending, bytes]);
+        while (feed.pending.length >= 64_000) {
+          const fresh = feed.pending.subarray(0, 64_000); feed.pending = feed.pending.subarray(64_000);
+          const pcm = Buffer.concat([feed.previous, fresh]); feed.previous = pcm.subarray(-128_000);
+          feed.until += 2000;
+          if (Math.abs(Date.now() - feed.until) > 2000) feed.until = Date.now();
+          const samples = new Float32Array(pcm.length / 2);
+          for (let index = 0; index < samples.length; index++) samples[index] = pcm.readInt16LE(index * 2) / 32768;
+          feed.interpreter.push({ samples, at: feed.until - samples.length / 16, until: feed.until, freshAt: feed.until - 2000 });
+        }
+      }, () => this.stop(feed, "The live source stopped. Enable translated audio again when playback resumes."), feed.controller.signal);
+      if (feed.controller.signal.aborted) input.stop(); else feed.input = input;
+    } catch (error) { this.stop(feed, error instanceof SpeechError ? error.message : "The live source could not be opened."); }
+  }
+  private async speak(feed: Feed): Promise<void> {
+    feed.speaking = true;
+    try {
+      while (feed.queue.length && !feed.controller.signal.aborted) {
+        const line = feed.queue.shift()!;
+        if (Date.now() - line.until > 12_000) throw new SpeechError("Live translation fell behind. Enable it again to retry.", 503);
+        const response = await this.options.voice.stream({ text: line.text, language: feed.language, channel: feed.id, speaker: line.speaker, voice: feed.interpreter.tracker.speakers.get(line.speaker ?? "")?.voice }, feed.id, feed.controller.signal, feed.meter);
+        const id = randomUUID();
+        this.broadcast(feed, { type: "line", id, line });
+        const reader = response.body!.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read(); if (done) break;
+            for (let at = 0; at < value.length; at += 16_384) this.broadcast(feed, { type: "audio", id, data: Buffer.from(value.subarray(at, at + 16_384)).toString("base64") });
+          }
+        } finally { reader.releaseLock(); }
+        this.broadcast(feed, { type: "end", id });
+      }
+    } catch (error) { if (!feed.controller.signal.aborted) this.stop(feed, error instanceof SpeechError ? error.message : "Translated audio was interrupted."); }
+    finally { feed.speaking = false; }
+  }
+}