nixamp 0.28.44 → 0.28.45

package/dist/translation-passes.js

@@ -1,295 +1,6 @@
-/** 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 { SpeechError } from "./speech.js";
-import { UpgradeAllowances } from "./upgrade-allowance.js";
-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 },
-];
-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, units) {
-    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) {
-    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, id, priceCents) {
-    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 = process.env) {
-    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, header, secret, nowMs = Date.now()) {
-    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) {
-    const body = payload && typeof payload === "object" ? payload : {};
-    const data = body["data"] && typeof body["data"] === "object" ? body["data"] : body;
-    return {
-        type: String(body["type"] ?? ""),
-        paymentId: String(data["payment_id"] ?? data["id"] ?? ""),
-        status: String(data["status"] ?? "").toLowerCase(),
-    };
-}
-export class TranslationPasses {
-    options;
-    schema = null;
-    merchant = null;
-    merchantUntil = 0;
-    fetcher;
-    now;
-    free;
-    constructor(options) {
-        this.options = options;
-        this.fetcher = options.fetcher ?? fetch;
-        this.now = options.now ?? Date.now;
-        this.free = new UpgradeAllowances(options.db, this.now);
-    }
-    async ensure() {
-        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;
-    }
-    async provider(path, init = {}) {
-        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;
-    }
-    async settings() {
-        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) => coin.symbol === symbol && coin.is_active && coin.has_wallet));
-                return { business: body.business_id, coins };
-            }).catch(error => { this.merchant = null; throw error; });
-        }
-        return this.merchant;
-    }
-    async access(by) {
-        await this.ensure();
-        const config = await this.settings().catch(() => ({ business: "", coins: [] }));
-        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, resource) {
-        await this.ensure();
-        if (await this.free.begin(by, "translation", resource))
-            return;
-        await this.require(by, resource);
-    }
-    async require(by, resource = "") {
-        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, resource = "") {
-        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, kind, units, resource = "") {
-        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, kind, units, resource = "") {
-        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) {
-        await this.options.db.query("UPDATE translation_usage SET status = 'charged' WHERE id = $1 AND status = 'reserved'", [id]);
-    }
-    async refund(id) {
-        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) {
-        await this.options.db.query("UPDATE translation_usage SET status = 'charged' WHERE id = ANY($1::text[]) AND status = 'reserved'", [ids]);
-    }
-    async refundMany(ids) {
-        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, planId, coin, requestKey) {
-        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]]) {
-                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) {
-        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, id) {
-        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) };
-    }
+/** 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 } from "@profullstack/live-translate";
+export class TranslationPasses extends Base {
+    constructor(options) { super({ app: "nixamp", label: "Nixamp translated audio", ...options }); }
 }

package/dist/upgrade-allowance.d.ts

@@ -1,23 +1 @@
-import type { Queryable } from "./follows.ts";
-export declare const FREE_UPGRADE_SESSIONS = 10;
-export declare const FREE_UPGRADE_RECONNECT_SECONDS = 90;
-export interface UpgradeAllowance {
-    limit: number;
-    remaining: number;
-    reconnectSeconds: number;
-    resets: string;
-    activeUntil: string | null;
-}
-export declare class UpgradeAllowances {
-    private readonly db;
-    private readonly now;
-    private schema;
-    constructor(db: Queryable, now?: () => number);
-    ensure(): Promise<void>;
-    key(product: string, resource: string): string;
-    access(by?: string): Promise<UpgradeAllowance>;
-    /** One atomic row serializes concurrent starts across tabs, products and replicas.
-     * Active use renews a short lease. Reconnecting reuses it; idle leases expire. */
-    begin(by: string, product: string, resource: string): Promise<boolean>;
-    active(accounts: string[], product: string, resource: string, renew?: boolean): Promise<string[]>;
-}
+export { UpgradeAllowances, FREE_UPGRADE_SESSIONS, FREE_UPGRADE_RECONNECT_SECONDS, type UpgradeAllowance } from "@profullstack/live-translate";

package/dist/upgrade-allowance.js

@@ -1,73 +1 @@
-/** Daily free access shared by Nixamp's paid panels and upgrades.
- * Claim only on explicit use, never from balance polling or provider chunks. */
-import { createHash } from "node:crypto";
-import { SpeechError } from "./speech.js";
-export const FREE_UPGRADE_SESSIONS = 10;
-export const FREE_UPGRADE_RECONNECT_SECONDS = 90;
-const DAY = 86_400_000;
-export class UpgradeAllowances {
-    db;
-    now;
-    schema = null;
-    constructor(db, now = Date.now) {
-        this.db = db;
-        this.now = now;
-    }
-    async ensure() {
-        this.schema ??= this.db.query(`CREATE TABLE IF NOT EXISTS upgrade_daily_uses (
-      by_account TEXT NOT NULL, day BIGINT NOT NULL,
-      uses INTEGER NOT NULL CHECK (uses >= 1),
-      sessions JSONB NOT NULL, PRIMARY KEY (by_account, day))`)
-            .then(() => this.db.query(`ALTER TABLE upgrade_daily_uses DROP CONSTRAINT IF EXISTS upgrade_daily_uses_uses_check`))
-            .then(() => this.db.query(`ALTER TABLE upgrade_daily_uses ADD CONSTRAINT upgrade_daily_uses_uses_check CHECK (uses BETWEEN 1 AND 10)`))
-            .then(() => undefined)
-            .catch(error => { this.schema = null; throw error; });
-        await this.schema;
-    }
-    key(product, resource) {
-        if (!/^[a-z][a-z0-9-]{0,63}$/.test(product) || !/^[\w-]{1,80}$/.test(resource))
-            throw new SpeechError("Choose a panel session.", 400);
-        return createHash("sha256").update(`${product}|${resource}`).digest("hex");
-    }
-    async access(by) {
-        await this.ensure();
-        const now = this.now(), day = Math.floor(now / DAY);
-        const rows = by ? (await this.db.query("SELECT uses, day, sessions FROM upgrade_daily_uses WHERE by_account = $1", [by])).rows : [];
-        const today = rows.find(row => Number(row["day"]) === day);
-        const active = Math.max(0, ...rows.flatMap(row => Object.values(row["sessions"]).map(Number)));
-        return { limit: FREE_UPGRADE_SESSIONS, remaining: Math.max(0, FREE_UPGRADE_SESSIONS - Number(today?.["uses"] ?? 0)),
-            reconnectSeconds: FREE_UPGRADE_RECONNECT_SECONDS, resets: new Date((day + 1) * DAY).toISOString(), activeUntil: active > now ? new Date(active).toISOString() : null };
-    }
-    /** One atomic row serializes concurrent starts across tabs, products and replicas.
-     * Active use renews a short lease. Reconnecting reuses it; idle leases expire. */
-    async begin(by, product, resource) {
-        if (!by)
-            throw new SpeechError("Sign in to use your free sessions.", 401);
-        const key = this.key(product, resource);
-        if ((await this.active([by], product, resource, true)).length)
-            return true;
-        await this.ensure();
-        const now = this.now(), day = Math.floor(now / DAY), until = now + FREE_UPGRADE_RECONNECT_SECONDS * 1000;
-        const result = await this.db.query(`INSERT INTO upgrade_daily_uses AS daily (by_account, day, uses, sessions)
-      VALUES ($1, $2, 1, jsonb_build_object($3::text, $5::bigint))
-      ON CONFLICT (by_account, day) DO UPDATE SET
-        uses = CASE WHEN COALESCE((daily.sessions->>$3)::bigint, 0) > $4 THEN daily.uses ELSE daily.uses + 1 END,
-        sessions = daily.sessions || EXCLUDED.sessions
-      WHERE COALESCE((daily.sessions->>$3)::bigint, 0) > $4 OR daily.uses < $6
-      RETURNING uses`, [by, day, key, now, until, FREE_UPGRADE_SESSIONS]);
-        return result.rows.length > 0;
-    }
-    async active(accounts, product, resource, renew = false) {
-        if (!resource || !accounts.length)
-            return [];
-        const key = this.key(product, resource);
-        await this.ensure();
-        const now = this.now();
-        const result = renew
-            ? await this.db.query(`UPDATE upgrade_daily_uses SET sessions = sessions || jsonb_build_object($2::text, $4::bigint)
-          WHERE by_account = ANY($1::text[]) AND (sessions->>$2)::bigint > $3 RETURNING by_account`, [accounts, key, now, now + FREE_UPGRADE_RECONNECT_SECONDS * 1000])
-            : await this.db.query(`SELECT by_account FROM upgrade_daily_uses
-          WHERE by_account = ANY($1::text[]) AND (sessions->>$2)::bigint > $3`, [accounts, key, now]);
-        return result.rows.map(row => String(row["by_account"]));
-    }
-}
+export { UpgradeAllowances, FREE_UPGRADE_SESSIONS, FREE_UPGRADE_RECONNECT_SECONDS } from "@profullstack/live-translate";

package/dist/voice-profile.d.ts

@@ -1,7 +1 @@
-/** Acoustic matching only: pitch does not establish a speaker's gender or identity. */
-export type VoiceProfile = "lower" | "higher" | "unknown";
-/** Median fundamental frequency from periodic voiced frames, sampled at 8 kHz.
- * Ambiguous pitch, overlapping voices and unvoiced sound use the selected default.
- * This is deliberately inexpensive and does not load another model beside ASR.
- */
-export declare function voiceProfile(pcm: Buffer): VoiceProfile;
+export { voiceProfile, type VoiceProfile } from "@profullstack/live-translate";

package/dist/voice-profile.js

@@ -1,53 +1 @@
-/** Median fundamental frequency from periodic voiced frames, sampled at 8 kHz.
- * Ambiguous pitch, overlapping voices and unvoiced sound use the selected default.
- * This is deliberately inexpensive and does not load another model beside ASR.
- */
-export function voiceProfile(pcm) {
-    const pitches = [];
-    const frame = 320;
-    const samples = Math.floor(pcm.length / 4);
-    for (let start = 0; start + frame < samples; start += 1600) {
-        const values = new Float32Array(frame);
-        let mean = 0;
-        for (let i = 0; i < frame; i++)
-            mean += values[i] = pcm.readInt16LE((start + i) * 4) / 32768;
-        mean /= frame;
-        let energy = 0;
-        for (let i = 0; i < frame; i++) {
-            values[i] = values[i] - mean;
-            energy += values[i] ** 2;
-        }
-        if (Math.sqrt(energy / frame) < 0.01)
-            continue;
-        let best = 0;
-        let period = 0;
-        // Prefer the first strong peak; a later multiple of the period has the same correlation.
-        const correlations = [];
-        for (let lag = 20; lag <= 114; lag++) {
-            let cross = 0, left = 0, right = 0;
-            for (let i = 0; i < frame - lag; i++) {
-                const a = values[i], b = values[i + lag];
-                cross += a * b;
-                left += a * a;
-                right += b * b;
-            }
-            correlations[lag] = cross / Math.sqrt(left * right || 1);
-        }
-        for (let lag = 21; lag < 114; lag++) {
-            const score = correlations[lag];
-            if (score > 0.8 && score > correlations[lag - 1] && score >= correlations[lag + 1] && score > best + 0.03) {
-                best = score;
-                period = lag;
-            }
-        }
-        if (period)
-            pitches.push(8000 / period);
-    }
-    if (pitches.length < 3)
-        return "unknown";
-    pitches.sort((a, b) => a - b);
-    const median = pitches[Math.floor(pitches.length / 2)];
-    const lower = pitches.filter((pitch) => pitch < 155).length / pitches.length;
-    const higher = pitches.filter((pitch) => pitch > 185).length / pitches.length;
-    return median < 155 && lower >= 0.75 ? "lower" : median > 185 && higher >= 0.75 ? "higher" : "unknown";
-}
+export { voiceProfile } from "@profullstack/live-translate";

package/dist/voice-provider.d.ts

@@ -1,9 +1 @@
-import { SpeechError } from "./speech.ts";
-/** Only fixed messages/codes leave this boundary: provider bodies can contain
- * account information. Authorization and billing errors must not be retried
- * as transient 502s by the live player. */
-export declare function voiceProviderFailure(response: Response): Promise<{
-    error: SpeechError;
-    code: string;
-    cooldownMs: number;
-}>;
+export { voiceProviderFailure } from "@profullstack/live-translate";

package/dist/voice-provider.js

@@ -1,27 +1 @@
-import { SpeechError } from "./speech.js";
-/** Only fixed messages/codes leave this boundary: provider bodies can contain
- * account information. Authorization and billing errors must not be retried
- * as transient 502s by the live player. */
-export async function voiceProviderFailure(response) {
-    let code = "unknown";
-    try {
-        const body = await response.json();
-        const status = body?.detail?.status;
-        if (typeof status === "string" && ["quota_exceeded", "invalid_api_key", "missing_permissions", "subscription_required", "subscription_expired", "payment_required", "payment_issue", "too_many_concurrent_requests", "rate_limit_exceeded"].includes(status))
-            code = status;
-    }
-    catch { /* Non-JSON provider failures still have an HTTP status. */ }
-    if (code === "quota_exceeded")
-        return { code, cooldownMs: 300_000, error: new SpeechError("ElevenLabs credits are exhausted. The site owner needs to check the provider balance.", 402) };
-    if (code === "payment_issue")
-        return { code, cooldownMs: 300_000, error: new SpeechError("ElevenLabs blocked transcription because its subscription payment failed. The site owner needs to complete the outstanding ElevenLabs invoice.", 402) };
-    if (["subscription_required", "subscription_expired", "payment_required"].includes(code) || response.status === 402)
-        return { code, cooldownMs: 300_000, error: new SpeechError("ElevenLabs billing needs attention. The site owner needs to check the provider subscription.", 402) };
-    if (["invalid_api_key", "missing_permissions"].includes(code) || [401, 403].includes(response.status))
-        return { code, cooldownMs: 300_000, error: new SpeechError("ElevenLabs rejected transcription or voice access. The site owner needs to check the provider key, permissions, and billing.", 424) };
-    if (response.status === 429) {
-        const retry = Number(response.headers.get("retry-after"));
-        return { code, cooldownMs: Math.min(300_000, Math.max(30_000, Number.isFinite(retry) ? retry * 1000 : 0)), error: new SpeechError("ElevenLabs is rate limited. Wait before enabling translated audio again.", 429) };
-    }
-    return { code, cooldownMs: 10_000, error: new SpeechError("ElevenLabs is temporarily unavailable. Try translated audio again shortly.", 502) };
-}
+export { voiceProviderFailure } from "@profullstack/live-translate";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.28.44",
+  "version": "0.28.45",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",
@@ -47,6 +47,7 @@
   "dependencies": {
     "@profullstack/auth-system": "^0.8.3",
     "@profullstack/hqtui": "^0.5.0",
+    "@profullstack/live-translate": "^0.1.0",
     "@profullstack/notifications": "^0.1.0",
     "@profullstack/synconfig": "^0.1.2",
     "@profullstack/throttle": "0.2.2",