nixamp 0.28.43 → 0.28.45

package/dist/live-voice.js

@@ -1,353 +1,7 @@
-/** ElevenLabs Flash for live captions. The key stays on the account server. */
-import { createHash, randomBytes } from "node:crypto";
-import { SpeechError, decodeWav, encodeWav, quietSamples } from "./speech.js";
-import { speakerTurns } from "./speaker-turns.js";
-import { Guard } from "./guard.js";
-import { voiceProviderFailure } from "./voice-provider.js";
-export const LIVE_VOICE_MODEL = "eleven_flash_v2_5";
-export const LIVE_VOICE_RATE = 16_000;
-export const LIVE_VOICE_LANGUAGES = new Set("en ja zh de hi fr ko pt it es id nl tr fil pl sv bg ro ar cs el fi hr ms sk da ta uk ru hu no vi".split(" "));
-const HEADERS = { "content-type": "audio/pcm", "cache-control": "no-store", "x-audio-sample-rate": String(LIVE_VOICE_RATE) };
-const budget = (value, fallback) => Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
-export class LiveVoice {
-    key;
-    fetcher;
-    now;
-    catalog = null;
-    catalogUntil = 0;
-    cache = new Map();
-    pending = new Map();
-    usage = new Map();
-    charsPerMinute;
-    requests;
-    grants = new Map();
-    activeBy = new Map();
-    db;
-    billing;
-    schema = null;
-    dailyChars;
-    cleanupAt = 0;
-    hearing = new Set();
-    dailyAudioSeconds;
-    userDailyChars;
-    userDailyAudioSeconds;
-    providerPause = null;
-    checkProvider() {
-        if (this.providerPause && this.providerPause.until > this.now())
-            throw this.providerPause.error;
-    }
-    async providerFailed(response, operation) {
-        const failure = await voiceProviderFailure(response);
-        const until = this.now() + failure.cooldownMs;
-        // Another in-flight response must not shorten an existing billing pause.
-        if (!this.providerPause || this.providerPause.until < until)
-            this.providerPause = { until, error: failure.error };
-        console.error(JSON.stringify({ event: "voice_provider_failure", provider: "elevenlabs", operation, status: response.status, code: failure.code, cooldownMs: failure.cooldownMs }));
-        throw failure.error;
-    }
-    constructor(options = {}) {
-        this.key = options.apiKey ?? process.env["ELEVENLABS_API_KEY"] ?? "";
-        this.fetcher = options.fetcher ?? fetch;
-        this.now = options.now ?? Date.now;
-        this.charsPerMinute = budget(options.charsPerMinute, 3000);
-        this.dailyChars = budget(options.dailyChars, 200_000);
-        this.dailyAudioSeconds = budget(options.dailyAudioSeconds, 86_400);
-        this.userDailyChars = budget(options.userDailyChars, 120_000);
-        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, meter = this.billing, resource = "") {
-        if (!this.available())
-            throw new SpeechError("speaker voices are unavailable", 503);
-        await meter?.require(by, resource);
-        this.checkProvider();
-        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: 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;
-        let accepted = false;
-        try {
-            const billed = Math.ceil(seconds);
-            await this.reserve(`scribe:user:${by}`, billed, 300, 60_000);
-            await this.reserve("scribe:server", billed, 600, 60_000);
-            await this.reserve(`scribe:user:${by}`, billed, this.userDailyAudioSeconds, 86_400_000);
-            await this.reserve("scribe:server", billed, this.dailyAudioSeconds, 86_400_000);
-            signal?.throwIfAborted();
-            this.checkProvider();
-            const form = new FormData();
-            // Canonical PCM prevents a crafted container from billing more audio
-            // than the duration we validated, and removes uploaded metadata.
-            form.set("file", new Blob([new Uint8Array(encodeWav(wav.samples))], { type: "audio/wav" }), "listening.wav");
-            form.set("model_id", "scribe_v2");
-            form.set("diarize", "true");
-            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, resource);
-            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)
-                await this.providerFailed(answer, "transcription");
-            accepted = true;
-            console.info(JSON.stringify({ event: "voice_provider_usage", provider: "elevenlabs", operation: "transcription", account: createHash("sha256").update(by).digest("hex").slice(0, 16), audioSeconds: seconds }));
-            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);
-        }
-    }
-    async voices() {
-        if (!this.available())
-            throw new SpeechError("translated audio needs ELEVENLABS_API_KEY on the account server", 503);
-        this.checkProvider();
-        if (!this.catalog || this.now() >= this.catalogUntil) {
-            this.catalogUntil = this.now() + 3600_000;
-            this.catalog = this.fetcher("https://api.elevenlabs.io/v2/voices?page_size=100&voice_type=default", {
-                headers: { "xi-api-key": this.key }, signal: AbortSignal.timeout(8000),
-            }).then(async (response) => {
-                if (!response.ok)
-                    await this.providerFailed(response, "voices");
-                const body = await response.json();
-                return body.voices.filter(voice => /^[a-zA-Z0-9_-]+$/.test(voice.voice_id)).map(voice => ({
-                    id: voice.voice_id, name: voice.name, gender: voice.labels?.["gender"] ?? "neutral", language: voice.labels?.["language"] ?? "",
-                }));
-            }).catch(error => { this.catalog = null; throw error; });
-        }
-        return this.catalog;
-    }
-    /** A 90-second capability for one channel, never the viewer's account credential. */
-    async grant(by, channel) {
-        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, channel);
-        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")}`;
-        const expires = this.now() + 90_000;
-        if (this.db) {
-            await this.ensure();
-            await this.db.query("INSERT INTO live_voice_grants (token_hash, by_account, channel, expires_at, remaining) VALUES ($1, $2, $3, $4, 2000)", [createHash("sha256").update(token).digest("hex"), by, channel, new Date(expires)]);
-        }
-        else
-            this.grants.set(token, { by, channel, expires, remaining: 2000 });
-        return { token, expires };
-    }
-    async authorize(token, channel, chars) {
-        if (!/^nxd_[A-Za-z0-9_-]{43}$/.test(token))
-            throw new SpeechError("sign in to enable translated audio", 401);
-        if (!Number.isFinite(chars) || chars < 1 || chars > 600)
-            throw new SpeechError("invalid caption length", 400);
-        if (this.db) {
-            await this.ensure();
-            const result = await this.db.query(`UPDATE live_voice_grants SET remaining = remaining - $3
-        WHERE token_hash = $1 AND channel = $2 AND expires_at > $4 AND remaining >= $3 RETURNING by_account`, [createHash("sha256").update(token).digest("hex"), channel, chars, new Date(this.now())]);
-            if (!result.rows.length)
-                throw new SpeechError("audio authorization expired or reached its limit; enable translated audio again", 401);
-            return String(result.rows[0]?.["by_account"]);
-        }
-        const grant = this.grants.get(token);
-        if (!grant || grant.expires <= this.now() || grant.channel !== channel)
-            throw new SpeechError("sign in to renew translated audio", 401);
-        if (grant.remaining < chars)
-            throw new SpeechError("this audio authorization reached its character limit", 429);
-        grant.remaining -= chars;
-        return grant.by;
-    }
-    async ensure() {
-        if (!this.db)
-            return;
-        this.schema ??= (async () => {
-            await this.db.query("CREATE TABLE IF NOT EXISTS live_voice_usage (bucket TEXT PRIMARY KEY, chars BIGINT NOT NULL, expires_at TIMESTAMPTZ NOT NULL)");
-            await this.db.query("CREATE TABLE IF NOT EXISTS live_voice_grants (token_hash TEXT PRIMARY KEY, by_account TEXT NOT NULL, channel TEXT NOT NULL, expires_at TIMESTAMPTZ NOT NULL, remaining INTEGER NOT NULL)");
-        })().catch(error => { this.schema = null; throw error; });
-        await this.schema;
-        if (this.now() >= this.cleanupAt) {
-            this.cleanupAt = this.now() + 60_000;
-            // Keep only live windows; accounting survives restarts and is shared by replicas.
-            await this.db.query("DELETE FROM live_voice_usage WHERE expires_at <= $1", [new Date(this.now())]);
-            await this.db.query("DELETE FROM live_voice_grants WHERE expires_at <= $1", [new Date(this.now())]);
-        }
-    }
-    async reserve(bucket, chars, limit, windowMs) {
-        if (chars > limit)
-            throw new SpeechError("translated audio reached its character budget; try again later", 429);
-        const window = Math.floor(this.now() / windowMs);
-        const key = `${bucket}:${windowMs}:${window}`;
-        if (this.db) {
-            await this.ensure();
-            const result = await this.db.query(`INSERT INTO live_voice_usage (bucket, chars, expires_at) VALUES ($1, $2, $4)
-        ON CONFLICT (bucket) DO UPDATE SET chars = live_voice_usage.chars + EXCLUDED.chars
-        WHERE live_voice_usage.chars + EXCLUDED.chars <= $3 RETURNING chars`, [key, chars, limit, new Date((window + 1) * windowMs)]);
-            if (!result.rows.length)
-                throw new SpeechError("translated audio reached its character budget; try again later", 429);
-            return;
-        }
-        // Local/single-process installations without a database. Account servers pass their pool.
-        const record = this.usage.get(key) ?? { minute: (window + 1) * windowMs, chars: 0 };
-        if (record.chars + chars > limit)
-            throw new SpeechError("translated audio reached its character budget; try again later", 429);
-        record.chars += chars;
-        this.usage.set(key, record);
-    }
-    async charge(by, channel, chars) {
-        for (const [key, record] of this.usage)
-            if (record.minute <= this.now())
-                this.usage.delete(key);
-        await this.reserve(`user:${by}`, chars, this.charsPerMinute, 60_000);
-        await this.reserve(`channel:${channel}`, chars, 6000, 60_000);
-        await this.reserve("server", chars, 12_000, 60_000);
-        await this.reserve(`user:${by}`, chars, this.userDailyChars, 86400_000);
-        await this.reserve("server", chars, this.dailyChars, 86400_000);
-    }
-    checkRequest(by) {
-        if (!this.requests.check(`audio:${by}`, { allowed: 60, windowMs: 60_000 }).ok)
-            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, meter = this.billing) {
-        this.checkRequest(by);
-        await meter?.require(by, ask.channel);
-        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);
-        const voices = await this.voices();
-        signal?.throwIfAborted();
-        // The browser chooses unique voices for speakers. Legacy callers get a
-        // stable stock voice; pitch is not used to infer gender.
-        const seed = createHash("sha256").update(`${ask.channel ?? ""}|${ask.speaker ?? ""}`).digest().readUInt32BE(0);
-        const voice = ask.voice && ask.voice !== "auto"
-            ? voices.find(voice => voice.id === ask.voice)
-            : voices[seed % voices.length];
-        if (!voice)
-            throw new SpeechError("choose an available voice", 400);
-        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);
-        const pending = this.pending.get(id);
-        if (cached || pending) {
-            const bytes = cached?.bytes ?? await pending;
-            signal?.throwIfAborted();
-            const paid = await meter?.reserve(by, "voice", text.length, ask.channel);
-            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.
-        let done;
-        let fail;
-        const finished = new Promise((resolve, reject) => { done = resolve; fail = reject; });
-        this.pending.set(id, finished);
-        this.activeBy.set(by, (this.activeBy.get(by) ?? 0) + 1);
-        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);
-            this.checkProvider();
-            signal?.throwIfAborted();
-            reservation = await meter?.reserve(by, "voice", text.length, ask.channel);
-            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" },
-                body: JSON.stringify({ text, model_id: LIVE_VOICE_MODEL, language_code: ask.language }),
-                signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(10_000)]) : AbortSignal.timeout(10_000),
-            });
-            if (!response.ok)
-                await this.providerFailed(response, "synthesis");
-            if (!response.body)
-                throw new SpeechError("ElevenLabs returned no audio", 502);
-            // Once the provider accepts, aborting playback cannot refund heard audio.
-            accepted = true;
-            console.info(JSON.stringify({ event: "voice_provider_usage", provider: "elevenlabs", operation: "synthesis", account: createHash("sha256").update(by).digest("hex").slice(0, 16), characters: text.length }));
-            if (reservation)
-                await meter.commit(reservation);
-            const [play, keep] = response.body.tee();
-            void (async () => {
-                const reader = keep.getReader();
-                const chunks = [];
-                let size = 0;
-                try {
-                    while (true) {
-                        const { done: ended, value } = await reader.read();
-                        if (ended)
-                            break;
-                        size += value.length;
-                        if (size > 2 * 1024 * 1024) {
-                            await reader.cancel();
-                            throw new SpeechError("voice response was too long", 502);
-                        }
-                        chunks.push(value);
-                    }
-                    if (!size || size % 2)
-                        throw new SpeechError("voice response contained incomplete audio", 502);
-                    const bytes = new Uint8Array(size);
-                    let at = 0;
-                    for (const chunk of chunks) {
-                        bytes.set(chunk, at);
-                        at += chunk.length;
-                    }
-                    this.cache.set(id, { until: this.now() + 60_000, bytes });
-                    // At most a few MB for recent lines, never a recording archive.
-                    while (this.cache.size > 32)
-                        this.cache.delete(this.cache.keys().next().value);
-                    done(bytes);
-                }
-                catch (error) {
-                    fail(error);
-                }
-                finally {
-                    reader.releaseLock();
-                    release();
-                }
-            })();
-            return new Response(play, { headers: HEADERS });
-        }
-        catch (error) {
-            fail(error);
-            release();
-            if (reservation && !accepted)
-                await meter.refund(reservation);
-            throw error;
-        }
-    }
+/** ElevenLabs Flash/Scribe for live captions, from @profullstack/live-translate.
+ * nixamp keeps its `nxd_` grant tokens: captions.ts and older pages expect them. */
+import { LiveVoice as Base } from "@profullstack/live-translate";
+export { LIVE_VOICE_MODEL, LIVE_VOICE_RATE, LIVE_VOICE_LANGUAGES } from "@profullstack/live-translate";
+export class LiveVoice extends Base {
+    constructor(options = {}) { super({ tokenPrefix: "nxd_", ...options }); }
 }

package/dist/owner.js

@@ -116,6 +116,10 @@ export function needsAdmin(path, method = "GET") {
     // with a catalog entry, and the same question.
     if (/^\/api\/tracks\/\d+\/live$/.test(path))
         return true;
+    // And so is a folder: without this the gate never ran for it, and a
+    // listen link alone could put any folder on the air, uncapped.
+    if (path === "/api/folders/live")
+        return true;
     return false;
 }
 /**

package/dist/paywall.js

@@ -134,7 +134,7 @@ export function paywallFromEnv(env = process.env) {
     return {
         enabled: env["NIXAMP_X402"] === "1",
         payTo: env["NIXAMP_PAY_TO"] ?? "",
-        coinpayKey: env["COINPAY_X402_KEY"] ?? "",
+        coinpayKey: env["COINPAY_API_KEY"] || env["COINPAY_X402_KEY"] || "",
         priceCents: Number.isFinite(price) && price > 0 ? Math.floor(price) : DEFAULT_PAYWALL.priceCents,
         passMinutes: Number.isFinite(minutes) && minutes > 0 ? Math.floor(minutes) : DEFAULT_PAYWALL.passMinutes,
     };

package/dist/pcm-wav.d.ts

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

package/dist/pcm-wav.js

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

package/dist/server.d.ts

@@ -143,6 +143,20 @@ export interface ServeOptions {
      */
     rtmp: string[];
 }
+/**
+ * Read DATABASE_URL the way libpq does.
+ *
+ * node-postgres reads `sslmode=require` as verify-full, so a cluster that
+ * signs its own certificate (dev2's shared Postgres) refuses every query with
+ * "self signed certificate" while the process itself stays up and healthy:
+ * pages serve, accounts and follows and events all fail. libpq, and every
+ * other client, read `require` as "encrypt, do not verify", and pg honours
+ * that reading when the URL carries `uselibpqcompat=true`. Railway's internal
+ * URL had no sslmode at all, which is why this never came up there. Only
+ * `require` and `prefer` are rewritten: `no-verify` is pg's own spelling and
+ * has no libpq meaning, and `verify-*` asks for exactly what pg does anyway.
+ */
+export declare function libpqDatabaseUrl(raw: string | undefined): string | undefined;
 /**
  * Flags are parsed by hand: three of them do not justify a dependency, and the
  * failure mode of a wrong `--port` should be a message rather than NaN.
@@ -723,6 +737,8 @@ export interface HandlerOptions {
     speech?: Speech;
     liveVoice?: LiveVoice;
     translationPasses?: TranslationPasses;
+    /** Signing secret of nixamp's CoinPay business, for /api/v1/webhooks/coinpay. */
+    coinpayWebhookSecret?: string;
     sharedTranslations?: SharedTranslations;
     /** Translation: texts in another language, by a model here. The same optional library. */
     translator?: Translator;

package/dist/server.js

@@ -20,7 +20,7 @@ import { Readable } from "node:stream";
 import { pipeline as pipeStream } from "node:stream/promises";
 import { relative } from "node:path";
 import { SharedTranslations } from "./shared-translation.js";
-import { TranslationPasses } from "./translation-passes.js";
+import { TranslationPasses, coinpayKeyFrom, readCoinpayWebhook, verifyCoinpaySignature } from "./translation-passes.js";
 import { LiveVoice, LIVE_VOICE_LANGUAGES, LIVE_VOICE_MODEL } from "./live-voice.js";
 import { Connections } from "./connections.js";
 import { Broadcaster, DEFAULT_ENCODER, PRESETS, redact, } from "./broadcast.js";
@@ -106,6 +106,24 @@ import { emptySnapshot, parseCommand, } from "./protocol.js";
 const FFT_SIZE = 2048;
 export const SERVE_BAND_COUNT = 24;
 export const DEFAULT_PORT = 4321;
+/**
+ * Read DATABASE_URL the way libpq does.
+ *
+ * node-postgres reads `sslmode=require` as verify-full, so a cluster that
+ * signs its own certificate (dev2's shared Postgres) refuses every query with
+ * "self signed certificate" while the process itself stays up and healthy:
+ * pages serve, accounts and follows and events all fail. libpq, and every
+ * other client, read `require` as "encrypt, do not verify", and pg honours
+ * that reading when the URL carries `uselibpqcompat=true`. Railway's internal
+ * URL had no sslmode at all, which is why this never came up there. Only
+ * `require` and `prefer` are rewritten: `no-verify` is pg's own spelling and
+ * has no libpq meaning, and `verify-*` asks for exactly what pg does anyway.
+ */
+export function libpqDatabaseUrl(raw) {
+    if (!raw || !/[?&]sslmode=(require|prefer)\b/.test(raw) || /[?&]uselibpqcompat=/.test(raw))
+        return raw;
+    return `${raw}${raw.includes("?") ? "&" : "?"}uselibpqcompat=true`;
+}
 /**
  * Flags are parsed by hand: three of them do not justify a dependency, and the
  * failure mode of a wrong `--port` should be a message rather than NaN.
@@ -1906,6 +1924,57 @@ export function createHandler(engine, options) {
             json(response, 404, { error: "no such endpoint" });
             return;
         }
+        // --- CoinPay ----------------------------------------------------------
+        //
+        // Ahead of the share-key check because the caller is CoinPay, which signs
+        // the body instead. The body is only a nudge: settle() asks CoinPay for the
+        // payment itself before anything is credited.
+        if (path === "/api/v1/webhooks/coinpay") {
+            if (request.method !== "POST") {
+                json(response, 405, { error: "POST only" });
+                return;
+            }
+            const secret = options.coinpayWebhookSecret ?? "";
+            if (!secret) {
+                json(response, 503, { error: "CoinPay webhooks are not configured here." });
+                return;
+            }
+            let raw;
+            try {
+                raw = await readBody(request);
+            }
+            catch {
+                json(response, 413, { error: "body too large" });
+                return;
+            }
+            const signature = request.headers["x-coinpay-signature"];
+            if (!verifyCoinpaySignature(raw, Array.isArray(signature) ? signature[0] : signature, secret)) {
+                json(response, 401, { error: "invalid signature" });
+                return;
+            }
+            let event;
+            try {
+                event = readCoinpayWebhook(JSON.parse(raw));
+            }
+            catch {
+                json(response, 400, { error: "invalid JSON" });
+                return;
+            }
+            if (!options.translationPasses) {
+                json(response, 200, { settled: false, reason: "billing is off here" });
+                return;
+            }
+            try {
+                json(response, 200, await options.translationPasses.settle(event.paymentId));
+            }
+            catch (error) {
+                // A 5xx makes CoinPay deliver it again, which is what an unreachable
+                // CoinPay or database needs.
+                console.error(`nixamp: CoinPay webhook for ${event.paymentId} could not settle: ${error instanceof Error ? error.message : String(error)}`);
+                json(response, 500, { error: "could not settle; retry" });
+            }
+            return;
+        }
         // --- the party line ---------------------------------------------------
         //
         // Ahead of the share-key check because the caller is a telephone. Telnyx
@@ -5917,8 +5986,9 @@ export async function serve(argv, version = "0.1.0") {
     // pocket can administer it from anywhere by signing in as the same person.
     // Following outlives every stream, so unlike the rest of this it wants a
     // database. Only where there is one: a nixamp on a laptop has no followers.
-    const pool = options.directory && process.env["DATABASE_URL"]
-        ? new pg.Pool({ connectionString: process.env["DATABASE_URL"] })
+    const databaseUrl = libpqDatabaseUrl(process.env["DATABASE_URL"]);
+    const pool = options.directory && databaseUrl
+        ? new pg.Pool({ connectionString: databaseUrl })
         : undefined;
     const follows = pool ? new Follows(pool) : undefined;
     const favorites = pool ? new Favorites(pool) : undefined;
@@ -5943,9 +6013,9 @@ export async function serve(argv, version = "0.1.0") {
     // the handler options because the authorization server issues its access
     // tokens out of the same table -- an OAuth token IS a nixamp token with a
     // client's name on it, which is why every existing route understands one.
-    const accounts = options.directory && process.env["DATABASE_URL"]
+    const accounts = options.directory && databaseUrl
         ? new Accounts({
-            connectionString: process.env["DATABASE_URL"],
+            connectionString: databaseUrl,
             secret: process.env["NIXAMP_JWT_SECRET"] ?? "",
         })
         : undefined;
@@ -5956,7 +6026,7 @@ export async function serve(argv, version = "0.1.0") {
     // 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;
+        ? new TranslationPasses({ db: pool, key: coinpayKeyFrom(), 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({
@@ -6502,6 +6572,7 @@ export async function serve(argv, version = "0.1.0") {
         ...(speech ? { speech } : {}),
         ...(liveVoice ? { liveVoice } : {}),
         ...(translationPasses ? { translationPasses } : {}),
+        ...(process.env["COINPAY_WEBHOOK_SECRET"] ? { coinpayWebhookSecret: process.env["COINPAY_WEBHOOK_SECRET"] } : {}),
         ...(sharedTranslations ? { sharedTranslations } : {}),
         ...(translator ? { translator } : {}),
         ...(transcripts ? { transcripts } : {}),

package/dist/shared-translation.d.ts

@@ -1,56 +1,9 @@
-import { type Caption } from "./live-interpreter.ts";
-import { LiveVoice } from "./live-voice.ts";
-import type { Translator } from "./translate.ts";
-import type { TranslationMeter } from "./translation-passes.ts";
-export declare function publicStreamAddress(address: string): boolean;
+/** Shared live translation, from @profullstack/live-translate, limited to nixamp channels. */
+import { SharedTranslations as Base, type OpenLiveInput } from "@profullstack/live-translate";
+export { publicStreamAddress, type LiveInput, type OpenLiveInput, type SharedEvent } from "@profullstack/live-translate";
+/** Only a live nixamp channel (`/api/channels/<id>`, optionally `?k=`). */
 export declare function sharedSource(raw: string): 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 declare function liveInput(ffmpeg?: string[]): OpenLiveInput;
-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;
-};
-export declare class SharedTranslations {
-    private readonly options;
-    private readonly feeds;
-    constructor(options: {
-        voice: LiveVoice;
-        translator: Pick<Translator, "translate">;
-        billing?: TranslationMeter;
-        open?: OpenLiveInput;
-    });
-    get size(): number;
-    join(raw: string, language: string, by: string, send: Member["send"], close: () => void): Promise<() => void>;
-    private leave;
-    private checkMembers;
-    private broadcast;
-    private stop;
-    private make;
-    private start;
-    private speak;
+export declare class SharedTranslations extends Base {
+    constructor(options: ConstructorParameters<typeof Base>[0]);
 }
-export {};