nixamp 0.65.0 → 0.66.3

package/dist/ai-label.js

@@ -492,6 +492,8 @@ export async function writeStoryboard(artist, album, song, scenes, ask = askJson
 /** Thrown by a Veo dependency when this month's budget is spent: no more shots until next month. */
 export class VeoUnavailable extends Error {
 }
+/** nixamp.com briefly away (a deploy: 502-504) or the network: worth asking again. */
+const TRANSIENT = /\b50[234]\b|fetch failed|ECONN|timed? ?out/i;
 // Nobody sings on camera: Veo's singers mouth a melody of their own, never the song's,
 // so a mouth in shot is out of sync. The band plays; the vocalist is far off, from
 // behind, in silhouette or between lines, never a close-up of singing.
@@ -1246,15 +1248,27 @@ export class AiLabel {
                 // The shot made small enough to send (1080p, no sound) and the song's same 8 seconds.
                 await runLow(this.deps.ffmpeg, [...this.deps.ffmpeg.slice(1), "-nostdin", "-hide_banner", "-loglevel", "error", "-y", "-i", singer[i].path, "-an", "-c:v", "libx264", "-preset", "veryfast", "-crf", "21", "-t", "8", shot], 5 * 60_000, "the close-up did not shrink");
                 await runLow(this.deps.ffmpeg, [...this.deps.ffmpeg.slice(1), "-nostdin", "-hide_banner", "-loglevel", "error", "-y", "-ss", at.toFixed(2), "-t", "8", "-i", song.file, "-c:a", "libmp3lame", "-b:a", "192k", audio], 60_000, "the song's seconds did not cut");
-                const bytes = await lipsync({ video: readFileSync(shot), audio: readFileSync(audio), seconds: 8 });
+                let bytes = null;
+                for (let attempt = 0;; attempt++) {
+                    try {
+                        bytes = await lipsync({ video: readFileSync(shot), audio: readFileSync(audio), seconds: 8 });
+                        break;
+                    }
+                    catch (error) {
+                        if (attempt >= 2 || !TRANSIENT.test(error.message))
+                            throw error;
+                        await new Promise((done) => setTimeout(done, this.deps.retryMs ?? 60_000));
+                    }
+                }
                 writeFileSync(`${synced}.part`, bytes);
                 renameSync(`${synced}.part`, synced);
                 pinned.push({ path: synced, at, seconds: 8 });
             }
             catch (error) {
+                // nixamp.com away (a deploy) or the month spent: nothing is cut yet; the shots wait for the next try.
+                if (error instanceof VeoUnavailable || TRANSIENT.test(error.message))
+                    throw new Error(`lip sync ${i + 1} must wait: ${error.message}`);
                 this.log(`lip sync ${i + 1} for "${song.title}": ${error.message}; the band plays there instead`);
-                if (error instanceof VeoUnavailable)
-                    break;
             }
             finally {
                 rmSync(shot, { force: true });
@@ -1318,7 +1332,7 @@ export class AiLabel {
                         break;
                     }
                     catch (error) {
-                        if (attempt >= 2 || error instanceof VeoUnavailable || !/\b50[234]\b|fetch failed|ECONN|timed? ?out/i.test(error.message))
+                        if (attempt >= 2 || error instanceof VeoUnavailable || !TRANSIENT.test(error.message))
                             throw error;
                         await new Promise((done) => setTimeout(done, this.deps.retryMs ?? 60_000));
                     }

package/dist/discovery.d.ts

@@ -29,9 +29,12 @@ export interface Release {
 /** The installer for `target` among a release's files, or null when that build is missing. */
 export declare function desktopAsset(release: Release | null, target: string): string | null;
 /**
- * The latest published release, asked of GitHub at most every ten minutes. A
- * failed ask keeps the last answer; with none, the downloads fall back to the
- * releases page, which is never wrong, only one click longer.
+ * The latest published release, from where github.com/.../releases/latest
+ * redirects (the tag), asked at most every ten minutes. Not the REST API: its
+ * 60 an hour unauthenticated are shared by every site on the box, and ran out.
+ * The installers are named by version (release.yml), and a release is only
+ * published once every one of them is attached. A failed ask keeps the last
+ * answer; with none, the downloads fall back to the releases page.
  */
 export declare function latestRelease(fetcher?: typeof fetch, now?: () => number): () => Promise<Release | null>;
 export declare function llmsTxt(site: string): string;

package/dist/discovery.js

@@ -1,5 +1,4 @@
 export const RELEASES = "https://github.com/profullstack/nixamp/releases";
-const LATEST_API = "https://api.github.com/repos/profullstack/nixamp/releases/latest";
 /** Each installer release.yml builds, by the address /download/<target> gives it. */
 export const DESKTOP_TARGETS = [
     { target: "mac-arm64", label: "macOS (Apple silicon)", suffix: "-mac-arm64.dmg" },
@@ -21,9 +20,12 @@ export function desktopAsset(release, target) {
     return release.assets.find((asset) => asset.name.startsWith("nixamp-") && asset.name.endsWith(spec.suffix))?.browser_download_url ?? null;
 }
 /**
- * The latest published release, asked of GitHub at most every ten minutes. A
- * failed ask keeps the last answer; with none, the downloads fall back to the
- * releases page, which is never wrong, only one click longer.
+ * The latest published release, from where github.com/.../releases/latest
+ * redirects (the tag), asked at most every ten minutes. Not the REST API: its
+ * 60 an hour unauthenticated are shared by every site on the box, and ran out.
+ * The installers are named by version (release.yml), and a release is only
+ * published once every one of them is attached. A failed ask keeps the last
+ * answer; with none, the downloads fall back to the releases page.
  */
 export function latestRelease(fetcher = fetch, now = Date.now) {
     let kept = { at: -Infinity, release: null };
@@ -31,11 +33,16 @@ export function latestRelease(fetcher = fetch, now = Date.now) {
         if (now() - kept.at < 10 * 60_000)
             return kept.release;
         try {
-            const response = await fetcher(LATEST_API, { headers: { accept: "application/vnd.github+json", "user-agent": "nixamp.com" }, signal: AbortSignal.timeout(8_000) });
-            if (!response.ok)
-                throw new Error(`HTTP ${response.status}`);
-            const body = await response.json();
-            kept = { at: now(), release: { tag_name: String(body.tag_name ?? ""), assets: Array.isArray(body.assets) ? body.assets : [] } };
+            const response = await fetcher(`${RELEASES}/latest`, { method: "HEAD", redirect: "manual", headers: { "user-agent": "nixamp.com" }, signal: AbortSignal.timeout(8_000) });
+            const tag = /\/releases\/tag\/(v\d+\.\d+\.\d+)$/.exec(response.headers.get("location") ?? "")?.[1];
+            if (!tag)
+                throw new Error(`no release tag (HTTP ${response.status})`);
+            const version = tag.slice(1);
+            const assets = DESKTOP_TARGETS.map((one) => {
+                const name = `nixamp-${version}${one.suffix}`;
+                return { name, browser_download_url: `${RELEASES}/download/${tag}/${name}` };
+            });
+            kept = { at: now(), release: { tag_name: tag, assets } };
         }
         catch {
             kept = { at: now(), release: kept.release };
@@ -78,7 +85,7 @@ export function llmsTxt(site) {
 ## Desktop app
 Downloads: ${site}/download
 ${desktop}
-- Every release: ${RELEASES}
+Every release: ${RELEASES}
 `;
 }
 const ok = { description: "OK", content: { "application/json": { schema: { type: "object" } } } };

package/dist/owner.d.ts

@@ -42,6 +42,8 @@ export declare class Owner {
     private readonly cache;
     constructor(options: OwnerOptions);
     get claimed(): boolean;
+    /** The owner's account id, or "" when nobody has claimed this server. */
+    get id(): string;
     /** The account a token belongs to, or "" for one nixamp.com does not accept. */
     accountFor(token: string): Promise<string>;
     check(hasControlKey: boolean, token: string): Promise<AdminCheck>;

package/dist/owner.js

@@ -32,6 +32,10 @@ export class Owner {
     get claimed() {
         return this.options.ownerId !== "";
     }
+    /** The owner's account id, or "" when nobody has claimed this server. */
+    get id() {
+        return this.options.ownerId;
+    }
     /** The account a token belongs to, or "" for one nixamp.com does not accept. */
     async accountFor(token) {
         if (!token)

package/dist/server.js

@@ -197,7 +197,8 @@ export function parseServeArgs(argv) {
         tlsCert: process.env["NIXAMP_TLS_CERT"] ?? "",
         tlsKey: process.env["NIXAMP_TLS_KEY"] ?? "",
         x402: false,
-        owner: "",
+        // The account that administers this server, for one with no key but accounts (nixamp.com).
+        owner: process.env["NIXAMP_OWNER"] ?? "",
         ingest: false,
         rtmpIn: 0,
         rtmpStreams: 3,
@@ -1479,6 +1480,10 @@ async function readBytes(request, limit) {
 export function createHandler(engine, options) {
     // One per server, so the counters survive between requests and die with it.
     const guard = new Guard();
+    // --no-key opens a server to whoever reaches it, unless it has an owner: then
+    // anyone may listen and only the owner (or the control key) administers.
+    // nixamp.com is that server; without this every visitor was its admin.
+    const openToAll = (key) => key === null && !options.owner?.claimed;
     // nixamp.com's /download asks GitHub which release is latest; one answer per ten minutes.
     const release = latestRelease();
     const tracker = options.connections ?? new Connections();
@@ -1634,7 +1639,7 @@ export function createHandler(engine, options) {
                 cors: CORS,
                 watch: (incoming, outgoing, track) => watch(incoming, outgoing, "stream", track),
                 controls: async () => {
-                    if (key === null)
+                    if (openToAll(key))
                         return true;
                     if (scopeOf(keyFrom(request, url), key, null) === "control")
                         return true;
@@ -2399,7 +2404,7 @@ export function createHandler(engine, options) {
         // or the owner's nixamp.com session. Asked by the routes that do not go
         // through the admin gate further down.
         const controlOf = async () => {
-            if (key === null)
+            if (openToAll(key))
                 return { allowed: true, account: "" };
             if (scopeOf(keyFrom(request, url), key, listenKey) === "control")
                 return { allowed: true, account: "" };
@@ -3394,6 +3399,18 @@ export function createHandler(engine, options) {
          * OpenProfile. Never awaited by the poster: the phone is a side effect
          * of the chat, and a slow Telnyx must not slow the box.
          */
+        /**
+         * AI work done for a signed-in account, paid as it goes from their credit:
+         * charged first, refunded if the work fails, a 402 with no credit. Only the
+         * admin (the owner) is never charged; with billing off, only the admin may.
+         */
+        const payForAi = (by, kind, units, work) => {
+            if (options.translationPasses)
+                return options.translationPasses.spend(by, kind, units, work);
+            if (by !== "" && by === options.owner?.id)
+                return work();
+            throw new SpeechError("AI on nixamp is pay as you go, and billing is off here.", 402);
+        };
         const readOnThePhone = (where, authorId, handle, body) => {
             const partyLine = options.partyLine;
             const listing = (options.directory?.list() ?? []).find((one) => {
@@ -3414,7 +3431,11 @@ export function createHandler(engine, options) {
                 const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
                 const pools = options.voices ? await options.voices.pools() : { provider: "kokoro", female: [], male: [] };
                 const spoken = spokenVoiceFor({ userId: authorId, voice: persona.voice, profile }, pools);
-                await partyLine.say(code, spokenLine(handle, body), spoken.voice, spoken.settings);
+                const words = spokenLine(handle, body);
+                // Read aloud is AI speech, paid per character from the author's credit (the admin's never is).
+                // No credit: the line stays in the chat and is not read.
+                const say = () => partyLine.say(code, words, spoken.voice, spoken.settings);
+                await payForAi(authorId, "phone_voice", words.length, say);
             })().catch(() => undefined);
         };
         /*
@@ -3733,13 +3754,15 @@ export function createHandler(engine, options) {
                     json(response, 400, { error: "a room is a server address and a channel" });
                     return;
                 }
-                const heard = await speech.transcribe(bytes, {
+                // Pay as you go per second of sound, from the WAV's own byte rate (the admin is never charged).
+                const byteRate = bytes.length > 44 ? new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(28, true) : 0;
+                const heard = await payForAi(who.id, "transcription_local", byteRate > 0 ? (bytes.length - 44) / byteRate : 1, () => speech.transcribe(bytes, {
                     language: languageOf(url.searchParams.get("language")),
                     // Pieces with their timing, for a whole file being written down.
                     timestamps: url.searchParams.get("timestamps") === "1",
                     by: who.id,
                     ...(url.searchParams.get("live") === "1" ? { deadline: Date.now() + 10_000 } : {}),
-                });
+                }));
                 // The language travels back: as told, or as the ear guessed it, so
                 // a captioner can say it next time and a transcript can be kept as it.
                 const said = {
@@ -3959,7 +3982,9 @@ export function createHandler(engine, options) {
                 return;
             }
             try {
-                json(response, 200, await translator.translate(texts, from, to, { by: who.id, ...(url.searchParams.get("live") === "1" ? { deadline: Date.now() + 10_000 } : {}) }));
+                // Pay as you go per character sent (the admin is never charged).
+                const characters = texts.reduce((sum, one) => sum + one.length, 0);
+                json(response, 200, await payForAi(who.id, "translation_local", characters, () => translator.translate(texts, from, to, { by: who.id, ...(url.searchParams.get("live") === "1" ? { deadline: Date.now() + 10_000 } : {}) })));
             }
             catch (error) {
                 if (error instanceof SpeechError)
@@ -4821,10 +4846,10 @@ export function createHandler(engine, options) {
                 (request.method === "DELETE" && channelAction === undefined)) &&
             eventChannelRequest);
         if (options.owner && needsAdmin(path, request.method ?? "GET") && !eventMediaOperation) {
-            // A server started with --no-key has said that anyone who can reach the
-            // port may drive it, and prints exactly that. Locking administration to
-            // nobody would contradict it and leave such a server unadministrable.
-            const holdsControl = key === null || scopeOf(keyFrom(request, url), key, null) === "control";
+            // A server started with --no-key and no owner has said that anyone who
+            // can reach the port may drive it, and prints exactly that. With an owner
+            // (nixamp.com), --no-key only means anyone may listen: the owner drives.
+            const holdsControl = openToAll(key) || scopeOf(keyFrom(request, url), key, null) === "control";
             // A session in the query as well as in a header or a cookie: from
             // nixamp.com's page a server is another origin, and the cookie stays
             // home, so the session travels the way the key does.
@@ -4980,7 +5005,7 @@ export function createHandler(engine, options) {
             if (path === "/api/catalogs" && request.method === "GET") {
                 // Where a list is read from is the administrator's business, not a
                 // listener's: it can carry a provider's credentials in the URL.
-                const holdsControl = key === null || scopeOf(keyFrom(request, url), key, null) === "control";
+                const holdsControl = openToAll(key) || scopeOf(keyFrom(request, url), key, null) === "control";
                 const admin = options.owner
                     ? (await options.owner.check(holdsControl, tokenFrom(request.headers))).allowed
                     : holdsControl;
@@ -7521,7 +7546,8 @@ 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: coinpayKeyFrom(), site: nixampSite }) : undefined;
+        // Every AI use is paid from this credit; only the admin (--owner / NIXAMP_OWNER) is never charged.
+        ? new TranslationPasses({ db: pool, key: coinpayKeyFrom(), site: nixampSite, admins: [options.owner || ""] }) : undefined;
     // Payments to the copyright holders nixamp.com collects for, on its own CoinPay business.
     const supportPayments = accounts ? new Support({ key: coinpayKeyFrom(), site: nixampSite, holders: supportHoldersFrom() }) : undefined;
     // Monthly support: each month a new CoinPay payment and its link by email.
@@ -7603,6 +7629,16 @@ export async function serve(argv, version = "0.1.0") {
             return { status: 403, body: { error: "only the owner of a listed server" } };
         if (request.method === "GET")
             return { status: 200, body: await veoStudio.status() };
+        // Pay as you go from the caller's AI credit, per second made; the admin is never charged.
+        const payer = accounts ? (await accounts.whoIs(tokenFrom(request.headers)).catch(() => null))?.id ?? "" : "";
+        const paid = (kind, seconds, work) => {
+            if (translationPasses)
+                return translationPasses.spend(payer, kind, seconds, work);
+            if (payer !== "" && payer === options.owner)
+                return work();
+            throw new SpeechError("AI on nixamp is pay as you go, and billing is off here.", 402);
+        };
+        const unpaid = (error) => error instanceof SpeechError ? { status: error.status, body: { error: error.message, code: "credit" } } : null;
         if (request.method !== "POST")
             return { status: 405, body: { error: "GET or POST" } };
         let input;
@@ -7621,9 +7657,14 @@ export async function serve(argv, version = "0.1.0") {
             if (video.length < 10_000 || audio.length < 1_000)
                 return { status: 400, body: { error: "a shot and its audio" } };
             try {
-                return { status: 200, body: null, video: await veoStudio.lipsync({ video, audio, seconds: Number(input.seconds ?? 8) }) };
+                // Charged as veo-studio.ts makes it: 1 to 10 s.
+                const seconds = Math.max(1, Math.min(10, Number(input.seconds ?? 8) || 8));
+                return { status: 200, body: null, video: await paid("lipsync", seconds, () => veoStudio.lipsync({ video, audio, seconds })) };
             }
             catch (error) {
+                const owed = unpaid(error);
+                if (owed)
+                    return owed;
                 if (error instanceof VeoBudgetError)
                     return { status: 402, body: { error: error.message, code: "budget", ...(await veoStudio.status()) } };
                 return { status: 422, body: { error: error.message, code: "refused" } };
@@ -7634,9 +7675,14 @@ export async function serve(argv, version = "0.1.0") {
             return { status: 400, body: { error: "describe the shot" } };
         const references = (Array.isArray(input.references) ? input.references : []).slice(0, 3).map((one) => Buffer.from(String(one), "base64")).filter((one) => one.length > 1000);
         try {
-            return { status: 200, body: null, video: await veoStudio.clip({ prompt, seconds: Number(input.seconds ?? 8), references }) };
+            // Charged as veo-studio.ts makes it: 4, 6 or 8 s.
+            const seconds = [4, 6, 8].includes(Number(input.seconds)) ? Number(input.seconds) : 8;
+            return { status: 200, body: null, video: await paid("video", seconds, () => veoStudio.clip({ prompt, seconds, references })) };
         }
         catch (error) {
+            const owed = unpaid(error);
+            if (owed)
+                return owed;
             if (error instanceof VeoBudgetError)
                 return { status: 402, body: { error: error.message, code: "budget", ...(await veoStudio.status()) } };
             return { status: 422, body: { error: error.message, code: "refused" } };
@@ -7699,7 +7745,14 @@ export async function serve(argv, version = "0.1.0") {
     }
     // What was heard, kept: where the accounts are, under the media's identity.
     const transcripts = pool ? new Transcripts(pool, (message) => console.log(message)) : undefined;
-    const translations = transcripts ? new StoredTranslations(transcripts, translator, (message) => console.log(message)) : undefined;
+    // Translating a stored transcript is AI: paid per character by whoever asked; only the admin is never charged.
+    const translations = transcripts ? new StoredTranslations(transcripts, translator, (message) => console.log(message), (by, characters, work) => {
+        if (translationPasses)
+            return translationPasses.spend(by, "translation_local", characters, work);
+        if (by !== "" && by === options.owner)
+            return work();
+        throw new SpeechError("AI on nixamp is pay as you go, and billing is off here.", 402);
+    }) : undefined;
     // The record of every file nixamp has met, by its bytes: nixamp.com/hash/<id>.
     const records = pool ? new Media(pool, (message) => console.log(message)) : undefined;
     // nixamp as an OAuth 2.1 authorization server, and the watch parties a
@@ -8444,7 +8497,10 @@ export async function serve(argv, version = "0.1.0") {
         console.log(`  Nothing outside reaches it until ${port} is forwarded here.`);
     }
     console.log("");
-    if (key === null) {
+    if (key === null && owner.claimed) {
+        console.log("  No key: anyone who can reach this port can hear it; only its owner can drive it.");
+    }
+    else if (key === null) {
         console.log("  No key: anyone who can reach this port can drive it and hear it.");
     }
     else {

package/dist/translate-jobs.d.ts

@@ -4,6 +4,8 @@ export interface Progress {
     done: number;
     total: number;
 }
+/** Runs some translating for an account, paid from its credit (server.ts payForAi). */
+export type PayForTranslation = <T>(by: string, characters: number, work: () => Promise<T>) => Promise<T>;
 /** What a request should answer: the status and the body's extra fields. */
 export type Answer = {
     status: 200;
@@ -13,15 +15,16 @@ export type Answer = {
     transcript: Transcript | null;
     translating: Progress;
 } | {
-    status: 404 | 409 | 503;
+    status: 402 | 404 | 409 | 503;
     error: string;
 };
 export declare class StoredTranslations {
     private readonly store;
     private readonly translator;
     private readonly onEvent;
+    private readonly pay;
     private readonly jobs;
-    constructor(store: Transcripts, translator: Translator | undefined, onEvent?: (message: string) => void);
+    constructor(store: Transcripts, translator: Translator | undefined, onEvent?: (message: string) => void, pay?: PayForTranslation);
     /** The lines of the original that the translation does not yet have. */
     static missing(original: Transcript, translation: Transcript | null): TranscriptLine[];
     /**

package/dist/translate-jobs.js

@@ -20,11 +20,15 @@ export class StoredTranslations {
     store;
     translator;
     onEvent;
+    pay;
     jobs = new Map();
-    constructor(store, translator, onEvent = () => { }) {
+    constructor(store, translator, onEvent = () => { }, 
+    // Pay as you go: each batch is charged to whoever asked, before it is translated.
+    pay = (_by, _characters, work) => work()) {
         this.store = store;
         this.translator = translator;
         this.onEvent = onEvent;
+        this.pay = pay;
     }
     /** The lines of the original that the translation does not yet have. */
     static missing(original, translation) {
@@ -58,7 +62,7 @@ export class StoredTranslations {
         let job = this.jobs.get(key);
         if (job?.error) {
             this.jobs.delete(key);
-            return { status: 503, error: job.error };
+            return { status: job.status ?? 503, error: job.error };
         }
         if (!job) {
             job = this.start(key, original, translation, missing, language, by);
@@ -67,7 +71,7 @@ export class StoredTranslations {
                 await job.finished;
                 if (job.error) {
                     this.jobs.delete(key);
-                    return { status: 503, error: job.error };
+                    return { status: job.status ?? 503, error: job.error };
                 }
                 const made = await this.store.get(id, language);
                 if (made)
@@ -81,6 +85,8 @@ export class StoredTranslations {
         job.finished = this.run(original, translation, missing, language, by, job)
             .catch((error) => {
             job.error = error instanceof SpeechError ? error.message : `translating failed: ${error.message}`;
+            if (error instanceof SpeechError && error.status === 402)
+                job.status = 402;
             this.onEvent(`  translating ${original.title || original.media} to ${language}: ${job.error}`);
         })
             .finally(() => {
@@ -99,7 +105,8 @@ export class StoredTranslations {
             const lines = [];
             for (const source of new Set(batch.map((line) => line.language || original.language))) {
                 const group = batch.filter((line) => (line.language || original.language) === source);
-                const done = await translator.translate(group.map((line) => line.text), source, language);
+                const texts = group.map((line) => line.text);
+                const done = await this.pay(by, texts.reduce((sum, one) => sum + one.length, 0), () => translator.translate(texts, source, language));
                 model = done.model;
                 lines.push(...group.map((line, i) => ({ ...line, language, original: line.text, text: done.texts[i] ?? "" })).filter((line) => line.text !== ""));
             }

package/dist/translation-passes.d.ts

@@ -1,6 +1,58 @@
-/** Prepaid translation credit, from @profullstack/live-translate, sold as nixamp. */
-import { TranslationPasses as Base } from "@profullstack/live-translate";
+/**
+ * Prepaid AI credit, from @profullstack/live-translate, sold as nixamp.
+ *
+ * Every AI feature on nixamp.com is pay as you go out of this one wallet: a
+ * pass adds dollars, each use takes what it costs times the multiplier, and a
+ * use that fails is refunded. There is no free allowance. The one exception is
+ * the site's admin (NIXAMP_OWNER), whose own use is never charged.
+ */
+import { TranslationPasses as Base, type TranslationAccess, type TranslationUsage } 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";
+/** The AI work billed here beyond translated audio, and what one unit costs nixamp.com in dollars. */
+export type AiKind = "video" | "lipsync" | "phone_voice" | "transcription_local" | "translation_local";
+export declare const AI_RATES: Readonly<Record<AiKind, {
+    usd: number;
+    per: string;
+}>>;
+/** A charge taken before AI work runs: kept when the work is done, given back when it fails. */
+export interface AiCharge {
+    commit(): Promise<void>;
+    refund(): Promise<void>;
+}
+export declare const ADMIN_USE = "admin:";
 export declare class TranslationPasses extends Base {
-    constructor(options: ConstructorParameters<typeof Base>[0]);
+    private readonly admins;
+    private readonly db;
+    private readonly clock;
+    constructor(options: ConstructorParameters<typeof Base>[0] & {
+        admins?: string[];
+    });
+    isAdmin(by: string | undefined): boolean;
+    private tables;
+    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>;
+    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>;
+    /** What `units` of `kind` cost, and what is charged for them, in micro-dollars. */
+    static price(kind: AiKind, units: number): {
+        cost: number;
+        charge: number;
+    };
+    /**
+     * Take the price of some AI work from `by`'s credit before it runs, in one
+     * statement, so two tabs cannot both spend the last cent. A 402 when there
+     * is not enough. The admin is never charged.
+     */
+    pay(by: string, kind: AiKind, units: number): Promise<AiCharge>;
+    /** Pay, do the work, and keep the charge only if the work succeeded. */
+    spend<T>(by: string, kind: AiKind, units: number, work: () => Promise<T>): Promise<T>;
 }

package/dist/translation-passes.js

@@ -1,6 +1,141 @@
-/** Prepaid translation credit, from @profullstack/live-translate, sold as nixamp. */
-import { TranslationPasses as Base } from "@profullstack/live-translate";
+/**
+ * Prepaid AI credit, from @profullstack/live-translate, sold as nixamp.
+ *
+ * Every AI feature on nixamp.com is pay as you go out of this one wallet: a
+ * pass adds dollars, each use takes what it costs times the multiplier, and a
+ * use that fails is refunded. There is no free allowance. The one exception is
+ * the site's admin (NIXAMP_OWNER), whose own use is never charged.
+ */
+import { TranslationPasses as Base, TRANSLATION_MULTIPLIER } from "@profullstack/live-translate";
+import { randomUUID } from "node:crypto";
+import { SpeechError } from "./speech.js";
 export { TRANSLATION_MULTIPLIER, TRANSLATION_PLANS, translationCost, verifyTranslationPayment, coinpayKeyFrom, verifyCoinpaySignature, readCoinpayWebhook } from "@profullstack/live-translate";
+const number = (name, fallback) => {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+};
+export const AI_RATES = {
+    // Veo 3.1 Fast and fal.ai lip sync, per second of video: what veo-studio.ts already budgets with.
+    video: { usd: number("NIXAMP_VEO_USD_PER_SECOND", 0.15), per: "second" },
+    lipsync: { usd: number("NIXAMP_LIPSYNC_USD_PER_SECOND", 0.1), per: "second" },
+    // A chat line read aloud on the party line: the ElevenLabs Flash rate, per character.
+    phone_voice: { usd: 0.05 / 1000, per: "character" },
+    // Whisper and OPUS-MT run on nixamp.com's own machine; priced like the hosted kind they replace.
+    transcription_local: { usd: 0.22 / 3600, per: "second" },
+    translation_local: { usd: number("NIXAMP_TRANSLATE_USD_PER_1K", 0.01) / 1000, per: "character" },
+};
+const FREE = { commit: async () => { }, refund: async () => { } };
+export const ADMIN_USE = "admin:";
 export class TranslationPasses extends Base {
-    constructor(options) { super({ app: "nixamp", label: "Nixamp translated audio", ...options }); }
+    admins;
+    db;
+    clock;
+    constructor(options) {
+        const { admins = [], ...rest } = options;
+        super({ app: "nixamp", label: "Nixamp AI credit", ...rest });
+        this.admins = new Set(admins.filter(Boolean));
+        this.db = rest.db;
+        this.clock = rest.now ?? Date.now;
+    }
+    isAdmin(by) {
+        return Boolean(by) && this.admins.has(by);
+    }
+    async tables() {
+        await this.ensure();
+    }
+    async access(by) {
+        const access = await super.access(by);
+        // No free sessions: the page offers credit, never "start a free session".
+        const free = { ...access.free, limit: 0, remaining: 0, activeUntil: null };
+        return this.isAdmin(by) ? { ...access, required: false, free } : { ...access, free };
+    }
+    async begin(by, resource) {
+        await this.require(by, resource);
+    }
+    async require(by, _resource = "") {
+        if (this.isAdmin(by))
+            return;
+        await this.tables();
+        const found = await this.db.query("SELECT 1 FROM translation_wallets WHERE by_account = $1 AND expires_at > $2 AND balance_micros > 0", [by, new Date(this.clock())]);
+        if (!found.rows.length)
+            throw new SpeechError("Buy AI credit: AI on nixamp is pay as you go.", 402);
+    }
+    async eligible(accounts, _resource = "") {
+        await this.tables();
+        const result = await this.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.clock())]);
+        return [...new Set([...accounts.filter((one) => this.isAdmin(one)), ...result.rows.map((row) => String(row["by_account"]))])];
+    }
+    async reserve(by, kind, units, _resource = "") {
+        const [taken] = await this.reserveMany([by], kind, units);
+        if (!taken)
+            throw new SpeechError("Buy AI credit: yours is used up.", 402);
+        return taken.id;
+    }
+    async reserveMany(accounts, kind, units, _resource = "") {
+        const admins = accounts.filter((one) => this.isAdmin(one)).map((by) => ({ by, id: `${ADMIN_USE}${randomUUID()}` }));
+        const paying = accounts.filter((one) => !this.isAdmin(one));
+        // No resource: the package's free-session lookup keys on it, and there are no free sessions here.
+        return [...admins, ...(paying.length ? await super.reserveMany(paying, kind, units, "") : [])];
+    }
+    async commit(id) {
+        if (!id.startsWith(ADMIN_USE))
+            await super.commit(id);
+    }
+    async refund(id) {
+        if (!id.startsWith(ADMIN_USE))
+            await super.refund(id);
+    }
+    async commitMany(ids) {
+        const paid = ids.filter((id) => !id.startsWith(ADMIN_USE));
+        if (paid.length)
+            await super.commitMany(paid);
+    }
+    async refundMany(ids) {
+        const paid = ids.filter((id) => !id.startsWith(ADMIN_USE));
+        if (paid.length)
+            await super.refundMany(paid);
+    }
+    /** What `units` of `kind` cost, and what is charged for them, in micro-dollars. */
+    static price(kind, units) {
+        const cost = Math.max(1, Math.ceil(AI_RATES[kind].usd * units * 1_000_000));
+        return { cost, charge: cost * TRANSLATION_MULTIPLIER };
+    }
+    /**
+     * Take the price of some AI work from `by`'s credit before it runs, in one
+     * statement, so two tabs cannot both spend the last cent. A 402 when there
+     * is not enough. The admin is never charged.
+     */
+    async pay(by, kind, units) {
+        if (this.isAdmin(by))
+            return FREE;
+        if (!by)
+            throw new SpeechError("Sign in to use AI on nixamp.", 401);
+        if (!Number.isFinite(units) || units <= 0)
+            return FREE;
+        await this.tables();
+        const { cost, charge } = TranslationPasses.price(kind, Math.ceil(units));
+        const now = new Date(this.clock());
+        const result = await this.db.query(`WITH debit AS (
+      UPDATE translation_wallets SET balance_micros = balance_micros - $2
+      WHERE by_account = $1 AND expires_at > $3 AND balance_micros >= $2 RETURNING by_account)
+      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, $2, $3 FROM debit RETURNING id`, [by, charge, now, kind, Math.ceil(units), cost]);
+        const id = result.rows[0]?.["id"];
+        if (!id)
+            throw new SpeechError(`Buy AI credit: AI on nixamp is pay as you go, and this costs $${(charge / 1_000_000).toFixed(4)}.`, 402);
+        return { commit: () => super.commit(String(id)), refund: () => super.refund(String(id)) };
+    }
+    /** Pay, do the work, and keep the charge only if the work succeeded. */
+    async spend(by, kind, units, work) {
+        const charge = await this.pay(by, kind, units);
+        try {
+            const done = await work();
+            await charge.commit();
+            return done;
+        }
+        catch (error) {
+            await charge.refund().catch(() => undefined);
+            throw error;
+        }
+    }
 }