nixamp 0.28.44 → 0.28.45

package/dist/shared-translation.js

@@ -1,27 +1,7 @@
-/** 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.js";
-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 } from "./live-interpreter.js";
-import { LIVE_VOICE_LANGUAGES } from "./live-voice.js";
-import { SpeechError } from "./speech.js";
-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]])
-    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) {
-    const family = isIP(address);
-    return family === 4 ? !blocked.check(address, "ipv4") : family === 6 && v6global.check(address, "ipv6") && !blocked.check(address, "ipv6");
-}
+/** Shared live translation, from @profullstack/live-translate, limited to nixamp channels. */
+import { SharedTranslations as Base, liveInput as baseLiveInput, SpeechError } from "@profullstack/live-translate";
+export { publicStreamAddress } from "@profullstack/live-translate";
+/** Only a live nixamp channel (`/api/channels/<id>`, optionally `?k=`). */
 export function sharedSource(raw) {
     let url;
     try {
@@ -37,316 +17,7 @@ export function sharedSource(raw) {
     url.searchParams.sort();
     return url;
 }
-/** Resolve once and pin that public address; no redirects or ffmpeg URL fetches. */
-export function liveInput(ffmpeg = ["ffmpeg"]) {
-    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 = () => { if (stopped)
-            return; stopped = true; request.destroy(); child.stdin.destroy(); child.kill("SIGKILL"); signal.removeEventListener("abort", stop); };
-        const end = () => { 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 class SharedTranslations {
-    options;
-    feeds = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    get size() { return this.feeds.size; }
-    async join(raw, language, by, send, close) {
-        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 = () => {
-            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);
-    }
-    leave(feed, member) {
-        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 });
-    }
-    async checkMembers(feed) {
-        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();
-                }
-            }
-    }
-    broadcast(feed, event) {
-        for (const member of [...feed.members]) {
-            try {
-                member.send(event);
-            }
-            catch {
-                this.leave(feed, member);
-                member.close();
-            }
-        }
-    }
-    stop(feed, error, retryable = false) {
-        this.broadcast(feed, { type: "error", error, retryable });
-        for (const member of [...feed.members]) {
-            this.leave(feed, member);
-            member.close();
-        }
-    }
-    make(id, source, language) {
-        const feed = { id, source, language, members: new Set(), controller: new AbortController(), reservations: new Map(), queue: [], speaking: false, voiceFailures: 0, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() };
-        // 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, kind, units) => {
-                const ids = [];
-                const accounts = [...new Set([...feed.members].map(member => member.by))];
-                const accepted = new Set();
-                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;
-                    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 = [];
-        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), 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 }));
-            }),
-        });
-        return feed;
-    }
-    async start(feed) {
-        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.");
-        }
-    }
-    async speak(feed) {
-        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 function liveInput(ffmpeg = ["ffmpeg"]) { return baseLiveInput(ffmpeg, "Nixamp shared translated audio"); }
+export class SharedTranslations extends Base {
+    constructor(options) { super({ parse: sharedSource, open: liveInput(), ...options }); }
 }

package/dist/speaker-turns.d.ts

@@ -1,32 +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 { type Wav } from "./speech.ts";
-import { 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;
-    }[];
-}
-export declare function speakerTurns(body: ScribeResult, wav: Wav): SpeakerTranscript;
+export { speakerTurns, type SpeakerTurn, type SpeakerTranscript, type ScribeResult } from "@profullstack/live-translate";

package/dist/speaker-turns.js

@@ -1,30 +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 } from "./speech.js";
-import { voiceProfile } from "./voice-profile.js";
-const ISO = 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, wav) {
-    const seconds = wav.samples.length / wav.rate;
-    const language = ISO[body.language_code ?? ""] ?? body.language_code ?? "";
-    const turns = [];
-    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 } from "@profullstack/live-translate";

package/dist/speech.d.ts

@@ -18,10 +18,9 @@ export declare const QUEUE_LIMIT = 8;
 export declare const DEFAULT_MODEL = "onnx-community/whisper-base";
 /** Stored live lines from older recognition settings must be heard again. */
 export declare const NATIVE_REVISION = "native-v2";
-export declare class SpeechError extends Error {
-    readonly status: number;
-    constructor(message: string, status: number);
-}
+/** 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";
 /** A stretch of the clip and what was said in it, seconds from the clip's start. */
 export interface Segment {
     start: number;
@@ -160,4 +159,3 @@ export declare class Speech {
         deadline?: number;
     }): Promise<Heard>;
 }
-export {};

package/dist/speech.js

@@ -49,13 +49,10 @@ export const QUEUE_LIMIT = 8;
 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 {
-    status;
-    constructor(message, status) {
-        super(message);
-        this.status = status;
-    }
-}
+/** 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";
 /** Whether these bytes are a RIFF/WAVE file, whatever the request called them. */
 export function isWav(bytes) {
     if (bytes.length < 12)

package/dist/translation-passes.d.ts

@@ -1,126 +1,6 @@
-import type { Queryable } from "./follows.ts";
-import { UpgradeAllowances, type UpgradeAllowance } from "./upgrade-allowance.ts";
-export declare const TRANSLATION_MULTIPLIER = 5;
-export declare const TRANSLATION_PLANS: readonly [{
-    readonly id: "day";
-    readonly name: "Day";
-    readonly days: 1;
-    readonly priceCents: 100;
-}, {
-    readonly id: "month";
-    readonly name: "Month";
-    readonly days: 30;
-    readonly priceCents: 500;
-}];
-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;
-}
-/** 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 declare function translationCost(kind: TranslationUsage, units: number): {
-    cost: number;
-    charge: number;
-};
-export declare function verifyTranslationPayment(payment: Record<string, unknown>, id: string, priceCents: number): boolean;
-/** 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 declare function coinpayKeyFrom(env?: NodeJS.ProcessEnv): string;
-/** 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 declare function verifyCoinpaySignature(raw: string, header: string | undefined, secret: string, nowMs?: number): boolean;
-/** 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 declare function readCoinpayWebhook(payload: unknown): {
-    type: string;
-    paymentId: string;
-    status: string;
-};
-export declare class TranslationPasses implements TranslationMeter {
-    private readonly options;
-    private schema;
-    private merchant;
-    private merchantUntil;
-    private readonly fetcher;
-    private readonly now;
-    readonly free: UpgradeAllowances;
-    constructor(options: {
-        db: Queryable;
-        key: string;
-        site: string;
-        fetcher?: typeof fetch;
-        now?: () => number;
-    });
-    private ensure;
-    private provider;
-    private settings;
-    access(by?: string): Promise<TranslationAccess>;
-    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>;
-    /** Batch a shared stream's access charges in one database round trip. */
-    reserveMany(accounts: string[], kind: TranslationUsage, units: number, resource?: string): Promise<{
-        by: string;
-        id: string;
-    }[]>;
-    commit(id: string): Promise<void>;
-    refund(id: string): Promise<void>;
-    commitMany(ids: string[]): Promise<void>;
-    refundMany(ids: string[]): Promise<void>;
-    checkout(by: string, planId: string, coin: string, requestKey: string): Promise<{
-        id: string;
-        url: string;
-    }>;
-    /**
-     * 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.
-     */
-    settle(paymentId: string): Promise<{
-        settled: boolean;
-        status?: string;
-        reason?: string;
-    }>;
-    check(by: string, id: string): Promise<{
-        status: string;
-        access: TranslationAccess;
-    }>;
+/** 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 declare class TranslationPasses extends Base {
+    constructor(options: ConstructorParameters<typeof Base>[0]);
 }