nixamp 0.28.44 → 0.28.45

package/src/shared-translation.ts

@@ -1,26 +1,8 @@
-/** 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 { transientAudioError } from "./live-recovery.ts";
-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";
+/** Shared live translation, from @profullstack/live-translate, limited to nixamp channels. */
+import { SharedTranslations as Base, liveInput as baseLiveInput, SpeechError, type OpenLiveInput } from "@profullstack/live-translate";
+export { publicStreamAddress, type LiveInput, type OpenLiveInput, type SharedEvent } from "@profullstack/live-translate";
 
-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");
-}
+/** Only a live nixamp channel (`/api/channels/<id>`, optionally `?k=`). */
 export function sharedSource(raw: string): URL {
   let url: URL;
   try { url = new URL(raw); } catch { throw new SpeechError("Choose a live Nixamp channel.", 400); }
@@ -28,205 +10,8 @@ export function sharedSource(raw: string): URL {
   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; retryable?: boolean };
-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; voiceFailures: number; 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; }
+export function liveInput(ffmpeg: string[] = ["ffmpeg"]): OpenLiveInput { return baseLiveInput(ffmpeg, "Nixamp shared translated audio"); }
 
-  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);
-    const id = `dub-${createHash("sha256").update(`${source}|${language}`).digest("hex").slice(0, 40)}`;
-    const capacity = (): void => {
-      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 feed = this.feeds.get(id);
-      if (!feed && this.feeds.size >= 4) throw new SpeechError("Live translation is busy. Try again shortly.", 429);
-      if (feed && feed.members.size >= 1000) throw new SpeechError("This translated stream is full. Try again shortly.", 429);
-    };
-    capacity();
-    if (this.options.billing?.begin) await this.options.billing.begin(by, id);
-    else await this.options.billing?.require(by, id);
-    capacity(); // Other joins can finish during the account/database check.
-    let feed = this.feeds.get(id);
-    if (!feed) {
-      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?.();
-    }
-    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 = "This free session ended and audio credit is used up. Start a remaining free session or buy a pass.";
-    try {
-      if (this.options.billing?.eligible) funded = new Set(await this.options.billing.eligible(accounts, feed.id));
-      else if (this.options.billing) {
-        const results = await Promise.allSettled(accounts.map(by => this.options.billing!.require(by, feed.id)));
-        funded = new Set(accounts.filter((_by, index) => results[index]?.status === "fulfilled"));
-      }
-    } catch { funded.clear(); message = "Your translation access 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, retryable = false): void {
-    this.broadcast(feed, { type: "error", error, retryable });
-    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, voiceFailures: 0, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() } as unknown as Feed;
-    // Each account uses free access first, then the same published credit rate.
-    // 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, feed.id)) { 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, feed.id) })));
-          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: "This free session ended and audio credit is used up. Start a remaining free session or buy a pass." }); }
-          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: message => this.stop(feed, message),
-      lines: lines => {
-        feed.queue.push(...lines);
-        feed.queue = feed.queue.filter(line => Date.now() - line.until <= 12_000).slice(-24);
-        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 disconnected.", true), 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) continue;
-        try {
-          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 }); }
-          feed.voiceFailures = 0;
-        } catch (error) {
-          if (feed.controller.signal.aborted) return;
-          if (!transientAudioError(error) || ++feed.voiceFailures >= 3) throw error;
-          // A provider failure skips this phrase; the source and other listeners
-          // remain connected. Never replay partial speech or retry a charge.
-        }
-      }
-    } catch (error) { if (!feed.controller.signal.aborted) this.stop(feed, error instanceof SpeechError ? error.message : "Translated audio was interrupted."); }
-    finally { feed.speaking = false; }
-  }
+export class SharedTranslations extends Base {
+  constructor(options: ConstructorParameters<typeof Base>[0]) { super({ parse: sharedSource, open: liveInput(), ...options }); }
 }

package/src/speaker-turns.ts

@@ -1,34 +1 @@
-/** Provider speaker IDs belong to a clip. Clients reconcile the overlapping
- * word timestamps before assigning a voice; these are not people's identities. */
-import { reliableText, type Wav } from "./speech.ts";
-import { voiceProfile, type VoiceProfile } from "./voice-profile.ts";
-
-export interface SpeakerTurn { start: number; end: number; text: string; speaker: string; profile: VoiceProfile; words: { text: string; start: number; end: number }[]; }
-export interface SpeakerTranscript { language: string; seconds: number; turns: SpeakerTurn[]; }
-export interface ScribeResult {
-  language_code?: string;
-  words?: { text: string; start: number; end: number; type: string; speaker_id?: string | null }[];
-}
-const ISO: Record<string, string> = Object.fromEntries("eng:en spa:es deu:de ger:de fra:fr fre:fr por:pt ita:it nld:nl dut:nl swe:sv dan:da fin:fi rus:ru ukr:uk ces:cs cze:cs hun:hu cmn:zh zho:zh ara:ar hin:hi vie:vi ind:id jpn:ja kor:ko pol:pl tur:tr ron:ro bul:bg ell:el nor:no nob:no nno:no".split(" ").map(pair => pair.split(":")));
-
-export function speakerTurns(body: ScribeResult, wav: Wav): SpeakerTranscript {
-  const seconds = wav.samples.length / wav.rate;
-  const language = ISO[body.language_code ?? ""] ?? body.language_code ?? "";
-  const turns: SpeakerTurn[] = [];
-  for (const word of (body.words ?? []).slice(0, 1500)) {
-    if (word.type !== "word" || typeof word.text !== "string" || !Number.isFinite(word.start) || !Number.isFinite(word.end) || word.start < 0 || word.end < word.start || word.end > seconds + 0.5) continue;
-    const speaker = typeof word.speaker_id === "string" && /^[\w-]{1,80}$/.test(word.speaker_id) ? word.speaker_id : "unknown";
-    const last = turns.at(-1);
-    if (last && last.speaker === speaker && word.start - last.end < 0.8 && last.text.length + word.text.length < 400) {
-      last.text += ` ${word.text}`; last.end = Math.max(last.end, word.end);
-      last.words.push({ text: word.text, start: word.start, end: word.end });
-    } else turns.push({ start: word.start, end: word.end, text: word.text, speaker, profile: "unknown", words: [{ text: word.text, start: word.start, end: word.end }] });
-  }
-  const pcm = Buffer.alloc(wav.samples.length * 2);
-  wav.samples.forEach((sample, i) => pcm.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample)) * 32767), i * 2));
-  for (const turn of turns) {
-    turn.text = reliableText(turn.text, Math.max(1, turn.end - turn.start));
-    turn.profile = voiceProfile(pcm.subarray(Math.floor(turn.start * 16000) * 2, Math.ceil(turn.end * 16000) * 2));
-  }
-  return { language, seconds, turns: turns.filter(turn => turn.text !== "") };
-}
+export { speakerTurns, type SpeakerTurn, type SpeakerTranscript, type ScribeResult } from "@profullstack/live-translate";

package/src/speech.ts

@@ -43,11 +43,10 @@ export const DEFAULT_MODEL = "onnx-community/whisper-base";
 /** Stored live lines from older recognition settings must be heard again. */
 export const NATIVE_REVISION = "native-v2";
 
-export class SpeechError extends Error {
-  constructor(message: string, readonly status: number) {
-    super(message);
-  }
-}
+/** The package's class, so an error thrown inside @profullstack/live-translate
+ * is still `instanceof SpeechError` to the server's handlers. */
+export { SpeechError } from "@profullstack/live-translate/core";
+import { SpeechError } from "@profullstack/live-translate/core";
 
 /** A stretch of the clip and what was said in it, seconds from the clip's start. */
 export interface Segment {

package/src/translation-passes.ts

@@ -1,294 +1,8 @@
-/** Account-bound, prepaid translation credit. Money is integer micro-USD;
- * each listening account reserves 5x base provider cost for paid access. */
-import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
-import type { Queryable } from "./follows.ts";
-import { SpeechError } from "./speech.ts";
-import { UpgradeAllowances, type UpgradeAllowance } from "./upgrade-allowance.ts";
+/** Prepaid translation credit, from @profullstack/live-translate, sold as nixamp. */
+import { TranslationPasses as Base } from "@profullstack/live-translate";
+export { TRANSLATION_MULTIPLIER, TRANSLATION_PLANS, translationCost, verifyTranslationPayment, coinpayKeyFrom, verifyCoinpaySignature, readCoinpayWebhook,
+  type TranslationPlan, type TranslationUsage, type TranslationMeter, type TranslationAccess } from "@profullstack/live-translate";
 
-export const TRANSLATION_MULTIPLIER = 5;
-export const TRANSLATION_PLANS = [
-  { id: "day", name: "Day", days: 1, priceCents: 100 },
-  { id: "month", name: "Month", days: 30, priceCents: 500 },
-] as const;
-export type TranslationPlan = typeof TRANSLATION_PLANS[number];
-export type TranslationUsage = "transcription" | "voice";
-export interface TranslationMeter {
-  begin?(by: string, resource: string): Promise<void>;
-  require(by: string, resource?: string): Promise<void>;
-  eligible?(accounts: string[], resource?: string): Promise<string[]>;
-  reserve(by: string, kind: TranslationUsage, units: number, resource?: string): Promise<string>;
-  reserveMany?(accounts: string[], kind: TranslationUsage, units: number, resource?: string): Promise<{ by: string; id: string }[]>;
-  commitMany?(ids: string[]): Promise<void>;
-  refundMany?(ids: string[]): Promise<void>;
-  commit(id: string): Promise<void>;
-  refund(id: string): Promise<void>;
-}
-export interface TranslationAccess {
-  required: boolean; available: boolean; balanceMicros: number; expires: string | null;
-  plans: readonly TranslationPlan[]; coins: string[]; orders: { id: string; url: string; plan: string }[];
-  rates: { transcriptionHour: number; voiceThousand: number; multiplier: number };
-  free: UpgradeAllowance;
-}
-const COINS = ["USDC_POL", "USDC_SOL", "SOL", "POL", "BTC", "ETH", "USDC_ETH", "BCH", "DOGE"];
-const ID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
-const DAY = 86_400_000;
-const PAID = new Set(["confirmed", "forwarding", "forwarded", "forwarding_failed", "completed"]);
-
-/** At the published rates: Scribe $0.22/submitted hour, Flash $0.05/1k chars.
- * Transcription units are 16 kHz samples; overlap is charged exactly as sent. */
-export function translationCost(kind: TranslationUsage, units: number): { cost: number; charge: number } {
-  if (!["voice", "transcription"].includes(kind) || !Number.isSafeInteger(units) || units < 1 || (kind === "voice" ? units > 600 : units > 241600)) throw new SpeechError("invalid translation usage", 400);
-  const cost = Math.ceil(kind === "voice" ? units * 50 : units * 220_000 / 57_600_000);
-  return { cost, charge: cost * TRANSLATION_MULTIPLIER };
-}
-function cents(value: unknown): number {
-  if (typeof value !== "number" && typeof value !== "string") return -1;
-  const text = String(value);
-  if (!/^\d+(?:\.\d{1,2}0*)?$/.test(text)) return -1;
-  const result = Math.round(Number(text) * 100);
-  return Number.isSafeInteger(result) ? result : -1;
-}
-export function verifyTranslationPayment(payment: Record<string, unknown>, id: string, priceCents: number): boolean {
-  return payment["id"] === id && PAID.has(String(payment["status"])) &&
-    String(payment["currency"]).toUpperCase() === "USD" && cents(payment["amount"]) === priceCents;
-}
-
-/** Which CoinPay key this deployment sells with. `COINPAY_API_KEY` is nixamp's
- * own business; `COINPAY_X402_KEY` is the older name, still honoured so a box
- * that has only it keeps selling. The own key wins, because the fleet-wide
- * x402 key belongs to another site's business and would book nixamp's sales
- * (and send its webhooks) there. */
-export function coinpayKeyFrom(env: NodeJS.ProcessEnv = process.env): string {
-  return env["COINPAY_API_KEY"] || env["COINPAY_X402_KEY"] || "";
-}
-
-/** CoinPay signs `t=<unix>,v1=<hex HMAC-SHA256 of "t.rawBody">` and allows
- * 300 s of skew. Computed over the raw bytes: reserialising changes them. */
-export function verifyCoinpaySignature(raw: string, header: string | undefined, secret: string, nowMs = Date.now()): boolean {
-  if (!secret || !header) return false;
-  let t = "", v1 = "";
-  for (const part of header.split(",")) {
-    const at = part.indexOf("=");
-    const name = part.slice(0, at).trim(), value = part.slice(at + 1).trim();
-    if (name === "t") t = value; else if (name === "v1") v1 = value;
-  }
-  if (!/^\d{1,12}$/.test(t) || !/^[a-f0-9]{64}$/i.test(v1)) return false;
-  if (Math.abs(nowMs / 1000 - Number(t)) > 300) return false;
-  const expected = createHmac("sha256", secret).update(`${t}.${raw}`).digest();
-  return timingSafeEqual(expected, Buffer.from(v1, "hex"));
-}
-
-/** CoinPay's webhook nests the payment under `data`, and its top-level `id` is
- * the EVENT (`evt_…`), not the payment. Read `data` first; the flat shape is
- * only the older test sender's. */
-export function readCoinpayWebhook(payload: unknown): { type: string; paymentId: string; status: string } {
-  const body = payload && typeof payload === "object" ? payload as Record<string, unknown> : {};
-  const data = body["data"] && typeof body["data"] === "object" ? body["data"] as Record<string, unknown> : body;
-  return {
-    type: String(body["type"] ?? ""),
-    paymentId: String(data["payment_id"] ?? data["id"] ?? ""),
-    status: String(data["status"] ?? "").toLowerCase(),
-  };
-}
-
-export class TranslationPasses implements TranslationMeter {
-  private schema: Promise<void> | null = null;
-  private merchant: Promise<{ business: string; coins: string[] }> | null = null;
-  private merchantUntil = 0;
-  private readonly fetcher: typeof fetch;
-  private readonly now: () => number;
-  readonly free: UpgradeAllowances;
-  constructor(private readonly options: { db: Queryable; key: string; site: string; fetcher?: typeof fetch; now?: () => number }) {
-    this.fetcher = options.fetcher ?? fetch; this.now = options.now ?? Date.now;
-    this.free = new UpgradeAllowances(options.db, this.now);
-  }
-  private async ensure(): Promise<void> {
-    this.schema ??= (async () => {
-      await this.free.ensure();
-      await this.options.db.query(`CREATE TABLE IF NOT EXISTS translation_wallets (
-        by_account TEXT PRIMARY KEY, balance_micros BIGINT NOT NULL CHECK (balance_micros >= 0), expires_at TIMESTAMPTZ NOT NULL)`);
-      await this.options.db.query(`CREATE TABLE IF NOT EXISTS translation_orders (
-        id TEXT PRIMARY KEY, by_account TEXT NOT NULL, request_key TEXT NOT NULL, plan TEXT NOT NULL,
-        price_cents INTEGER NOT NULL CHECK (price_cents > 0), days INTEGER NOT NULL,
-        business_id TEXT NOT NULL, coin TEXT NOT NULL, payment_id TEXT UNIQUE,
-        status TEXT NOT NULL DEFAULT 'pending', created_at TIMESTAMPTZ NOT NULL,
-        credited_at TIMESTAMPTZ, expires_at TIMESTAMPTZ, UNIQUE(by_account, request_key))`);
-      await this.options.db.query(`CREATE TABLE IF NOT EXISTS translation_usage (
-        id TEXT PRIMARY KEY, by_account TEXT NOT NULL, kind TEXT NOT NULL, units BIGINT NOT NULL,
-        cost_micros BIGINT NOT NULL, charge_micros BIGINT NOT NULL, status TEXT NOT NULL DEFAULT 'reserved',
-        created_at TIMESTAMPTZ NOT NULL)`);
-      await this.options.db.query(`CREATE TABLE IF NOT EXISTS translation_checkout_limits (bucket TEXT PRIMARY KEY, attempts INTEGER NOT NULL)`);
-      await this.options.db.query("CREATE INDEX IF NOT EXISTS translation_orders_account ON translation_orders (by_account, created_at)");
-    })().catch(error => { this.schema = null; throw error; });
-    await this.schema;
-  }
-  private async provider(path: string, init: RequestInit = {}): Promise<any> {
-    if (!this.options.key) throw new SpeechError("Translation checkout is unavailable.", 503);
-    const response = await this.fetcher(`https://coinpayportal.com${path}`, {
-      ...init, signal: AbortSignal.timeout(15_000), headers: { authorization: `Bearer ${this.options.key}`, "content-type": "application/json", ...init.headers },
-    });
-    const body = await response.json();
-    if (!response.ok || body.success !== true) throw new SpeechError("The payment service is unavailable. Your purchase has not been activated; retry to check its status.", 502);
-    return body;
-  }
-  private async settings(): Promise<{ business: string; coins: string[] }> {
-    if (!this.merchant || this.now() >= this.merchantUntil) {
-      this.merchantUntil = this.now() + 600_000;
-      this.merchant = this.provider("/api/supported-coins").then(body => {
-        if (!ID.test(body.business_id)) throw new SpeechError("Translation checkout is unavailable.", 503);
-        const coins = COINS.filter(symbol => body.coins?.some((coin: any) => coin.symbol === symbol && coin.is_active && coin.has_wallet));
-        return { business: body.business_id as string, coins };
-      }).catch(error => { this.merchant = null; throw error; });
-    }
-    return this.merchant;
-  }
-  async access(by?: string): Promise<TranslationAccess> {
-    await this.ensure();
-    const config = await this.settings().catch(() => ({ business: "", coins: [] as string[] }));
-    const row = by ? (await this.options.db.query("SELECT balance_micros, expires_at FROM translation_wallets WHERE by_account = $1 AND expires_at > $2", [by, new Date(this.now())])).rows[0] : null;
-    const orders = by ? (await this.options.db.query("SELECT id, payment_id, plan FROM translation_orders WHERE by_account = $1 AND status = 'pending' AND payment_id IS NOT NULL ORDER BY created_at DESC LIMIT 5", [by])).rows.map(order => ({ id: String(order["id"]), plan: String(order["plan"]), url: `https://coinpayportal.com/pay/${order["payment_id"]}` })) : [];
-    return { required: true, available: config.coins.length > 0, balanceMicros: Number(row?.["balance_micros"] ?? 0),
-      expires: row ? new Date(String(row["expires_at"])).toISOString() : null, plans: TRANSLATION_PLANS, coins: config.coins, orders, free: await this.free.access(by),
-      rates: { transcriptionHour: 0.22, voiceThousand: 0.05, multiplier: TRANSLATION_MULTIPLIER } };
-  }
-  async begin(by: string, resource: string): Promise<void> {
-    await this.ensure();
-    if (await this.free.begin(by, "translation", resource)) return;
-    await this.require(by, resource);
-  }
-  async require(by: string, resource = ""): Promise<void> {
-    await this.ensure();
-    if ((await this.free.active([by], "translation", resource, true)).length) return;
-    const found = await this.options.db.query("SELECT by_account FROM translation_wallets WHERE by_account = $1 AND expires_at > $2 AND balance_micros > 0", [by, new Date(this.now())]);
-    if (!found.rows.length) throw new SpeechError("Buy a pass or start a remaining free session: this session has no free time or audio credit.", 402);
-  }
-  async eligible(accounts: string[], resource = ""): Promise<string[]> {
-    await this.ensure();
-    const result = await this.options.db.query("SELECT by_account FROM translation_wallets WHERE by_account = ANY($1::text[]) AND expires_at > $2 AND balance_micros > 0", [accounts, new Date(this.now())]);
-    return [...new Set([...result.rows.map(row => String(row["by_account"])), ...await this.free.active(accounts, "translation", resource, true)])];
-  }
-  async reserve(by: string, kind: TranslationUsage, units: number, resource = ""): Promise<string> {
-    const result = await this.reserveMany([by], kind, units, resource);
-    if (!result.length) throw new SpeechError("This free session ended and audio credit is used up. Start a remaining free session or buy a pass.", 402);
-    return result[0]!.id;
-  }
-  /** Batch a shared stream's access charges in one database round trip. */
-  async reserveMany(accounts: string[], kind: TranslationUsage, units: number, resource = ""): Promise<{ by: string; id: string }[]> {
-    await this.ensure();
-    const { cost, charge } = translationCost(kind, units);
-    const now = this.now(), key = resource ? this.free.key("translation", resource) : "";
-    const result = await this.options.db.query(`WITH free AS (
-      SELECT DISTINCT by_account FROM upgrade_daily_uses WHERE by_account = ANY($1::text[])
-        AND (sessions->>$7)::bigint > $8), debit AS (
-      UPDATE translation_wallets SET balance_micros = balance_micros - $2
-      WHERE by_account = ANY($1::text[]) AND expires_at > $3 AND balance_micros >= $2
-        AND by_account NOT IN (SELECT by_account FROM free) RETURNING by_account), admitted AS (
-      SELECT by_account, 0::bigint AS charge FROM free UNION ALL SELECT by_account, $2::bigint FROM debit)
-      INSERT INTO translation_usage (id, by_account, kind, units, cost_micros, charge_micros, created_at)
-      SELECT gen_random_uuid()::text, by_account, $4, $5, $6, charge, $3 FROM admitted RETURNING id, by_account`,
-    [[...new Set(accounts)], charge, new Date(now), kind, units, cost, key, now]);
-    return result.rows.map(row => ({ by: String(row["by_account"]), id: String(row["id"]) }));
-  }
-  async commit(id: string): Promise<void> {
-    await this.options.db.query("UPDATE translation_usage SET status = 'charged' WHERE id = $1 AND status = 'reserved'", [id]);
-  }
-  async refund(id: string): Promise<void> {
-    await this.options.db.query(`WITH undone AS (
-      UPDATE translation_usage SET status = 'refunded' WHERE id = $1 AND status = 'reserved'
-      RETURNING by_account, charge_micros)
-      UPDATE translation_wallets AS wallet SET balance_micros = wallet.balance_micros + undone.charge_micros
-      FROM undone WHERE wallet.by_account = undone.by_account`, [id]);
-  }
-  async commitMany(ids: string[]): Promise<void> {
-    await this.options.db.query("UPDATE translation_usage SET status = 'charged' WHERE id = ANY($1::text[]) AND status = 'reserved'", [ids]);
-  }
-  async refundMany(ids: string[]): Promise<void> {
-    await this.options.db.query(`WITH undone AS (
-      UPDATE translation_usage SET status = 'refunded' WHERE id = ANY($1::text[]) AND status = 'reserved'
-      RETURNING by_account, charge_micros), totals AS (SELECT by_account, SUM(charge_micros) AS charge FROM undone GROUP BY by_account)
-      UPDATE translation_wallets AS wallet SET balance_micros = wallet.balance_micros + totals.charge
-      FROM totals WHERE wallet.by_account = totals.by_account`, [ids]);
-  }
-  async checkout(by: string, planId: string, coin: string, requestKey: string): Promise<{ id: string; url: string }> {
-    await this.ensure();
-    const plan = TRANSLATION_PLANS.find(plan => plan.id === planId);
-    if (!plan || !ID.test(requestKey)) throw new SpeechError("Choose a translation pass.", 400);
-    const config = await this.settings();
-    if (!config.coins.includes(coin)) throw new SpeechError("Choose an available payment currency.", 400);
-    // Durable caps across restarts/replicas protect the merchant's invoice quota.
-    // Retrying an existing order does not consume another invoice allowance.
-    const existing = await this.options.db.query("SELECT id FROM translation_orders WHERE by_account = $1 AND request_key = $2", [by, requestKey]);
-    if (!existing.rows.length) {
-      for (const [scope, limit] of [[`account:${by}`, 5], ["server", 50]] as const) {
-        const limited = await this.options.db.query(`INSERT INTO translation_checkout_limits (bucket, attempts) VALUES ($1, 1)
-          ON CONFLICT (bucket) DO UPDATE SET attempts = translation_checkout_limits.attempts + 1
-          WHERE translation_checkout_limits.attempts < $2 RETURNING attempts`, [`${scope}:${Math.floor(this.now() / DAY)}`, limit]);
-        if (!limited.rows.length) throw new SpeechError("Too many new checkouts today. Resume an existing purchase or try tomorrow.", 429);
-      }
-    }
-    const id = randomUUID();
-    await this.options.db.query(`INSERT INTO translation_orders (id, by_account, request_key, plan, price_cents, days, business_id, coin, created_at)
-      VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) ON CONFLICT (by_account, request_key) DO NOTHING`,
-    [id, by, requestKey, plan.id, plan.priceCents, plan.days, config.business, coin, new Date(this.now())]);
-    const order = (await this.options.db.query("SELECT * FROM translation_orders WHERE by_account = $1 AND request_key = $2", [by, requestKey])).rows[0]!;
-    if (order["plan"] !== plan.id || order["coin"] !== coin) throw new SpeechError("This checkout already belongs to a different pass. Start a new purchase.", 409);
-    let paymentId = String(order["payment_id"] ?? "");
-    if (!paymentId) {
-      const created = await this.provider("/api/payments/create", {
-        method: "POST", headers: { "idempotency-key": `nixamp-translation-${order["id"]}` },
-        body: JSON.stringify({ business_id: order["business_id"], amount_usd: Number(order["price_cents"]) / 100,
-          currency: coin.toLowerCase(), payment_method: "crypto", description: `Nixamp translated audio: ${plan.name} pass`,
-          metadata: { app: "nixamp", product: "translation", order_id: order["id"] },
-          redirect_url: `${this.options.site}/?translation_order=${order["id"]}` }),
-      });
-      paymentId = created.payment?.id;
-      if (!ID.test(paymentId ?? "")) throw new SpeechError("Checkout did not return a valid payment. Retry this purchase.", 502);
-      await this.options.db.query("UPDATE translation_orders SET payment_id = $2 WHERE id = $1 AND payment_id IS NULL", [order["id"], paymentId]);
-    }
-    return { id: String(order["id"]), url: `https://coinpayportal.com/pay/${paymentId}` };
-  }
-  /**
-   * A CoinPay webhook only says "look again". The order is settled by asking
-   * CoinPay, exactly as a returning buyer's check does, so a replayed or
-   * stale body cannot credit anything and a second delivery (confirmed, then
-   * forwarded) credits nothing twice. A payment that is not ours is answered,
-   * not failed: CoinPay would otherwise retry it forever.
-   */
-  async settle(paymentId: string): Promise<{ settled: boolean; status?: string; reason?: string }> {
-    if (!ID.test(paymentId)) return { settled: false, reason: "unknown payment" };
-    await this.ensure();
-    const order = (await this.options.db.query("SELECT id, by_account FROM translation_orders WHERE payment_id = $1", [paymentId])).rows[0];
-    if (!order) return { settled: false, reason: "unknown payment" };
-    const { status } = await this.check(String(order["by_account"]), String(order["id"]));
-    return { settled: status === "paid", status };
-  }
-  async check(by: string, id: string): Promise<{ status: string; access: TranslationAccess }> {
-    if (!ID.test(id)) throw new SpeechError("Purchase not found.", 404);
-    await this.ensure();
-    const order = (await this.options.db.query("SELECT * FROM translation_orders WHERE id = $1 AND by_account = $2", [id, by])).rows[0];
-    if (!order) throw new SpeechError("Purchase not found.", 404);
-    let status = String(order["status"]);
-    if (["pending", "expired"].includes(status) && order["payment_id"]) {
-      const result = await this.provider(`/api/payments/${encodeURIComponent(String(order["payment_id"]))}`);
-      const payment = result.payment;
-      if (payment && verifyTranslationPayment(payment, String(order["payment_id"]), Number(order["price_cents"]))) {
-        const now = new Date(this.now()), expires = new Date(this.now() + Number(order["days"]) * DAY);
-        // One statement atomically marks the order and adds credit. A retry,
-        // second tab or second replica cannot activate the same money twice.
-        await this.options.db.query(`WITH paid AS (
-          UPDATE translation_orders SET status = 'paid', credited_at = $3, expires_at = $4
-          WHERE id = $1 AND by_account = $2 AND status IN ('pending', 'expired') RETURNING by_account, price_cents)
-          INSERT INTO translation_wallets (by_account, balance_micros, expires_at)
-          SELECT by_account, price_cents::bigint * 10000, $4 FROM paid
-          ON CONFLICT (by_account) DO UPDATE SET
-            balance_micros = CASE WHEN translation_wallets.expires_at > $3 THEN translation_wallets.balance_micros ELSE 0 END + EXCLUDED.balance_micros,
-            expires_at = GREATEST(translation_wallets.expires_at, EXCLUDED.expires_at)`, [id, by, now, expires]);
-        status = "paid";
-      } else if (payment && ["expired", "failed", "refunded"].includes(payment.status)) {
-        status = payment.status;
-        await this.options.db.query("UPDATE translation_orders SET status = $3 WHERE id = $1 AND by_account = $2 AND status = 'pending'", [id, by, status]);
-      }
-    }
-    return { status, access: await this.access(by) };
-  }
+export class TranslationPasses extends Base {
+  constructor(options: ConstructorParameters<typeof Base>[0]) { super({ app: "nixamp", label: "Nixamp translated audio", ...options }); }
 }