nixamp 0.65.1 → 0.67.0

package/dist/ai-label.d.ts

@@ -90,8 +90,10 @@ export interface LabelSettings {
     videos: boolean;
     /** Each album's single (song 1) is filmed with Veo, while the month's Veo budget lasts. */
     veo: boolean;
-    /** How many 8 s Veo shots of the band a single is cut from. */
+    /** How many 8 s Veo shots of the band playing (never the singer) a single is cut from. */
     veoShots: number;
+    /** How many 8 s Veo story scenes (a short film from the song's words, nobody singing) a single gets. */
+    storyShots: number;
     /** How many close-ups of the singer a single gets, lip-synced to the song (0: none, the band only). */
     lipsyncShots: number;
     /** Public, listed and owned, so the genre stations are on the guide. */
@@ -166,6 +168,8 @@ export declare function syncLines(lyrics: string, timed: TimedWord[]): SyncedLin
 export declare function writeStoryboard(artist: Pick<LabelArtist, "name" | "genre" | "sound"> & {
     cast?: string;
 }, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "lyrics">, scenes: number, ask?: typeof askJson): Promise<string[]>;
+/** A single's story scenes for Veo: a short film from its words, nobody singing, people by look not name. */
+export declare function writeVeoStory(artist: Pick<LabelArtist, "genre" | "sound">, members: Array<Pick<Member, "role" | "look">>, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "lyrics">, scenes: number, ask?: typeof askJson): Promise<string[]>;
 /** Thrown by a Veo dependency when this month's budget is spent: no more shots until next month. */
 export declare class VeoUnavailable extends Error {
 }

package/dist/ai-label.js

@@ -28,7 +28,7 @@
  */
 import { execFile } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { aiKey } from "./ai-keys.js";
 import { composerFromEnv, OutOfCredit } from "./ai-radio.js";
@@ -273,7 +273,8 @@ export const DEFAULTS = {
     publish: true,
     videos: true,
     veo: false,
-    veoShots: 6,
+    veoShots: 2,
+    storyShots: 4,
     lipsyncShots: 2,
     parallel: 1,
     genreOrder: ["Punk", "Blues", "Country", "Jazz", "Classic Rock", "Metal", "Hip-Hop", "Pop", "R&B"],
@@ -489,21 +490,49 @@ export async function writeStoryboard(artist, album, song, scenes, ask = askJson
         throw new Error("the model wrote no storyboard");
     return prompts;
 }
+const VEO_STORY_SYSTEM = [
+    "You write the story scenes of a music video for an original song, as prompts for a video model that films 8-second moving shots.",
+    "Tell the song's story in cinematic scenes away from any stage: characters, places, action, weather, small details. Keep the same main character(s), setting and color palette across scenes so it reads as one short film; vary the shots (wide, tracking, close detail, aerial) and say how the camera moves.",
+    "Describe people by how they look, never by name. Nobody sings, speaks or lip-syncs, and nobody holds a microphone. Each prompt at most 350 characters. No text, letters, logos, real people or real brands.",
+    "Answer as JSON: {\"scenes\": [\"prompt\", ...]}.",
+].join(" ");
+/** A single's story scenes for Veo: a short film from its words, nobody singing, people by look not name. */
+export async function writeVeoStory(artist, members, album, song, scenes, ask = askJson) {
+    const cast = members.slice(0, 4).map((one) => `${one.role}: ${one.look.replace(/\b[A-Z][a-z]+ [A-Z][a-z]+\b/g, "")}`).join("; ");
+    const answer = await ask({
+        system: VEO_STORY_SYSTEM,
+        prompt: [
+            `Song: "${song.title}" (${artist.genre}; ${artist.sound}), from "${album.title}"${album.concept ? `: ${album.concept}` : ""}`,
+            cast ? `The band may appear as characters, described by look: ${cast}` : "",
+            `Mood and arrangement: ${song.style}`,
+            song.lyrics ? `Lyrics:\n${song.lyrics.slice(0, 1800)}` : "",
+            `Exactly ${scenes} scenes.`,
+        ].filter(Boolean).join("\n"),
+        maxTokens: 2500,
+        timeoutMs: 90_000,
+    });
+    const list = Array.isArray(answer.value["scenes"]) ? answer.value["scenes"] : [];
+    const prompts = list.map((one) => clean(one, 400)).filter((one) => one.length > 10).slice(0, scenes);
+    if (prompts.length < 1)
+        throw new Error("the model wrote no story");
+    return prompts.map((scene) => `Music video for a fictional ${artist.genre} song. ${scene} Mood: ${song.style}`.slice(0, 900)
+        + " Nobody sings, speaks or lip-syncs on camera. Cinematic, 35mm film look. No text, no logos.");
+}
 /** 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.
 const SHOTS = [
-    "Wide shot of the whole band performing on a big stage at night, seen from the back of the crowd, the players small against the lights",
     "Close-up of the guitarist's hands on the fretboard and the strings, shallow focus, stage lights flaring",
-    "The camera glides behind the band members as they play hard, seen from behind, looking out over the crowd",
     "Low-angle shot of the drummer hitting the cymbals at the song's climax, sticks blurred, sparks of light",
-    "The lead vocalist from behind, arms raised to the crowd between lines, backlit silhouette, no face to camera",
-    "Slow aerial push over the crowd toward the stage, fans with hands up, the band tiny in the distance",
-    "Close-up of the bass player's fingers and the amplifier, then a tilt up to the band in silhouette",
-    "The band walking out on stage before the show, backlit silhouettes, nobody speaking or singing",
+    "Close-up of the bass player's fingers and the amplifier, then a tilt up to the bassist in silhouette",
+    "The guitarist and the bassist seen from behind, playing hard toward a huge crowd, backlit",
+    "Slow push-in on the drummer in a quiet moment, moody light, sweat and smoke",
+    "Slow aerial push over the crowd toward the stage, fans with hands up, the stage tiny in the distance",
 ];
 // The singer's close-ups, which are lip-synced to the song afterwards (fal.ai). The mouth
 // must be clear: whatever covers it (a microphone, a hand) is smeared into the face when
@@ -523,7 +552,7 @@ export function veoPrompts(artist, song, members, count, kind = "band") {
     const cast = members.slice(0, 3).map((one, i) => `the ${one.role} from reference image ${i + 1} (${one.look.replace(/\b[A-Z][a-z]+ [A-Z][a-z]+\b/g, "")})`).join("; ");
     const rule = kind === "singer"
         ? "The vocalist sings clearly, the whole mouth always visible, never covered by a microphone or a hand. Cinematic, 35mm film look. No text, no logos."
-        : "Nobody sings, speaks or lip-syncs on camera: no mouths in close-up. Cinematic, 35mm film look, dynamic camera. No text, no logos.";
+        : "The lead vocalist is not in this shot, and nobody sings, speaks or lip-syncs on camera. Cinematic, 35mm film look, dynamic camera. No text, no logos.";
     return (kind === "singer" ? CLOSE_UPS : SHOTS).slice(0, count).map((shot) => [
         `Music video for a fictional ${artist.genre} band. ${shot}.`,
         cast ? `The performers are exactly the people in the reference images: ${cast}.` : "",
@@ -938,9 +967,12 @@ export class AiLabel {
             this.settings.videos = input["videos"] !== false;
         if (input["veo"] !== undefined)
             this.settings.veo = input["veo"] === true;
-        const shots = whole("veoShots", 1, 8);
+        const shots = whole("veoShots", 0, 8);
         if (shots !== undefined)
             this.settings.veoShots = shots;
+        const story = whole("storyShots", 0, 8);
+        if (story !== undefined)
+            this.settings.storyShots = story;
         const close = whole("lipsyncShots", 0, 4);
         if (close !== undefined)
             this.settings.lipsyncShots = close;
@@ -1206,9 +1238,10 @@ export class AiLabel {
         catch { /* the asked-for length */ }
         // Paid-for shots live beside the album until the video is cut, so nothing filmed is filmed twice.
         const shots = join(_album.folder, `.veo-${song.n}`);
-        const { band: clips, singer } = await this.filmShots(artist, song, shots, scenes);
-        if (clips.length < Math.max(2, Math.ceil(this.settings.veoShots / 2)))
-            throw new Error(`only ${clips.length} of ${this.settings.veoShots} shots filmed so far`);
+        const { band: clips, singer } = await this.filmShots(artist, _album, song, shots, scenes);
+        const wanted = this.settings.veoShots + this.settings.storyShots;
+        if (clips.length < Math.max(2, Math.ceil(wanted / 2)))
+            throw new Error(`only ${clips.length} of ${wanted} shots filmed so far`);
         const pinned = await this.syncCloseUps(song, singer, seconds, shots);
         await (this.deps.filmedVideo ?? ((input) => renderFilmedVideo(this.deps.ffmpeg, input)))({ audio: song.file, clips, seconds, artist: artist.name, title: song.title, out, ...(pinned.length ? { pinned } : {}) });
         rmSync(shots, { recursive: true, force: true });
@@ -1246,15 +1279,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 });
@@ -1274,34 +1319,57 @@ export class AiLabel {
      * Veo's reference images), on stage, in the song's mood. Stops for the
      * month when the budget is spent; a shot Veo will not make is skipped.
      */
-    async filmShots(artist, song, keep, dir) {
+    async filmShots(artist, album, song, keep, dir) {
         const veo = this.deps.veo;
         if (!veo)
             return { band: [], singer: [] };
         mkdirSync(dir, { recursive: true });
         mkdirSync(keep, { recursive: true });
         const members = this.cast(artist);
-        const references = [];
-        for (const member of members.slice(0, 3)) {
-            const portrait = join(this.folderOf(artist), "members", `${member.slug}.jpg`);
-            const small = join(dir, `ref-${member.slug}.jpg`);
+        // The players for the band shots, the voice for the close-ups: a singer's portrait in a band
+        // shot puts the singer at a microphone, singing out of sync.
+        const voice = (member) => /vocal|sing/i.test(member.role);
+        const players = members.filter((member) => !voice(member));
+        const singers = members.filter(voice).length ? members.filter(voice) : members.slice(0, 1);
+        const portraits = async (list) => {
+            const out = [];
+            for (const member of list.slice(0, 3)) {
+                const portrait = join(this.folderOf(artist), "members", `${member.slug}.jpg`);
+                const small = join(dir, `ref-${member.slug}.jpg`);
+                try {
+                    // 512 px is plenty for a face and keeps the request small.
+                    await runLow(this.deps.ffmpeg, [...this.deps.ffmpeg.slice(1), "-hide_banner", "-loglevel", "error", "-y", "-i", portrait, "-vf", "scale=512:-2", "-q:v", "4", small], 60_000, "the portrait did not shrink");
+                    out.push(readFileSync(small));
+                }
+                catch {
+                    // A member without a portrait is described in words only.
+                }
+            }
+            return out;
+        };
+        const [playerRefs, singerRefs] = [await portraits(players), await portraits(singers)];
+        const band = [];
+        const story = [];
+        const singer = [];
+        // The story is written only while some of its scenes are still to film.
+        const storyFiles = Array.from({ length: this.settings.storyShots }, (_, i) => join(keep, `story-${i}.mp4`));
+        let storyPrompts = [];
+        if (storyFiles.some((file) => !existsSync(file)) && this.canAsk()) {
             try {
-                // 512 px is plenty for a face and keeps the request small.
-                await runLow(this.deps.ffmpeg, [...this.deps.ffmpeg.slice(1), "-hide_banner", "-loglevel", "error", "-y", "-i", portrait, "-vf", "scale=512:-2", "-q:v", "4", small], 60_000, "the portrait did not shrink");
-                references.push(readFileSync(small));
+                storyPrompts = await writeVeoStory(artist, members, album, song, storyFiles.length, this.deps.ask ?? askJson);
             }
-            catch {
-                // A member without a portrait is described in words only.
+            catch (error) {
+                this.log(`no story for "${song.title}" yet: ${error.message}`);
             }
         }
-        const band = [];
-        const singer = [];
-        // The singer's close-ups only where they can be lip-synced afterwards.
+        // The singer's close-ups only where they can be lip-synced afterwards. Story scenes go without
+        // the portraits: they would pull the whole band into every scene.
         const plan = [
-            ...veoPrompts(artist, song, members, this.settings.veoShots).map((prompt, i) => ({ prompt, file: join(keep, `shot-${i}.mp4`), into: band })),
-            ...(this.deps.lipsync ? veoPrompts(artist, song, members, this.settings.lipsyncShots, "singer").map((prompt, i) => ({ prompt, file: join(keep, `singer-${i}.mp4`), into: singer })) : []),
+            ...storyFiles.map((file, i) => ({ prompt: storyPrompts[i] ?? "", file, into: story, refs: [] })),
+            ...veoPrompts(artist, song, players, this.settings.veoShots).map((prompt, i) => ({ prompt, file: join(keep, `shot-${i}.mp4`), into: band, refs: playerRefs })),
+            ...(this.deps.lipsync ? veoPrompts(artist, song, singers, this.settings.lipsyncShots, "singer").map((prompt, i) => ({ prompt, file: join(keep, `singer-${i}.mp4`), into: singer, refs: singerRefs })) : []),
         ];
-        for (const [i, { prompt, file, into }] of plan.entries()) {
+        for (const [i, { prompt, file, into, refs }] of plan.entries()) {
             try {
                 if (statSync(file).size > 10_000) {
                     into.push({ path: file, seconds: 8 });
@@ -1309,16 +1377,18 @@ export class AiLabel {
                 }
             }
             catch { /* not filmed yet */ }
+            if (!prompt)
+                continue;
             try {
                 // nixamp.com briefly away (a deploy: 502/503) or the network: twice more, a minute apart.
                 let bytes = null;
                 for (let attempt = 0;; attempt++) {
                     try {
-                        bytes = await veo({ prompt, seconds: 8, references });
+                        bytes = await veo({ prompt, seconds: 8, references: refs });
                         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));
                     }
@@ -1337,9 +1407,17 @@ export class AiLabel {
                 this.log(`Veo shot ${i + 1} for "${song.title}": ${error.message}`);
             }
         }
-        if (band.length || singer.length)
-            this.log(`Veo: ${band.length + singer.length} filmed shots for "${song.title}" (${artist.name})`);
-        return { band, singer };
+        if (band.length || story.length || singer.length)
+            this.log(`Veo: ${band.length + story.length + singer.length} filmed shots for "${song.title}" (${artist.name})`);
+        // The cut takes them in turn: a story scene, then the band playing, and so on.
+        const mixed = [];
+        for (let i = 0; i < Math.max(story.length, band.length); i++) {
+            if (story[i])
+                mixed.push(story[i]);
+            if (band[i])
+                mixed.push(band[i]);
+        }
+        return { band: mixed, singer };
     }
     /** The label's music videos as one TV station: free to watch, with its breaks. */
     placeVideos() {

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 };

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

@@ -3399,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) => {
@@ -3419,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);
         };
         /*
@@ -3738,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 = {
@@ -3964,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)
@@ -7526,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.
@@ -7608,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;
@@ -7626,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" } };
@@ -7639,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" } };
@@ -7704,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

package/dist/station-cli.js

@@ -541,6 +541,7 @@ async function labelCommand(argv, call, show) {
                 veo: has(argv, "--veo") ? true : has(argv, "--no-veo") ? false : undefined,
                 veoShots: number("--veo-shots"),
                 lipsyncShots: number("--lipsync-shots"),
+                storyShots: number("--story-shots"),
                 genreOrder: flag(argv, "--genres"),
                 enabled: has(argv, "--off") ? false : has(argv, "--on") ? true : undefined,
                 publish: has(argv, "--unlisted") ? false : has(argv, "--public") ? true : undefined,

package/dist/station-mcp.d.ts

@@ -53,6 +53,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -132,6 +133,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -234,6 +236,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -333,6 +336,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -414,6 +418,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -502,6 +507,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -590,6 +596,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -695,6 +702,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -829,6 +837,10 @@ export declare const STATION_TOOLS: ({
                 type: string;
                 description: string;
             };
+            storyShots: {
+                type: string;
+                description: string;
+            };
             genreOrder: {
                 type: string;
                 items: {
@@ -903,6 +915,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             server: {
                 type: "string";
@@ -1000,6 +1013,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -1099,6 +1113,7 @@ export declare const STATION_TOOLS: ({
             veo?: undefined;
             veoShots?: undefined;
             lipsyncShots?: undefined;
+            storyShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;

package/dist/station-mcp.js

@@ -125,6 +125,7 @@ export const STATION_TOOLS = [
                 veo: { type: "boolean", description: "Each album's single gets filmed Veo shots of the band (nixamp.com's monthly Veo cap applies)." },
                 veoShots: { type: "integer", description: "8 s Veo shots of the band per single (1-8); nobody sings in them." },
                 lipsyncShots: { type: "integer", description: "Close-ups of the singer per single, lip-synced to the song on nixamp.com (0-4; 0 = the band only)." },
+                storyShots: { type: "integer", description: "Cinematic story scenes per single, a short film from the song's words, nobody singing (0-8)." },
                 genreOrder: { type: "array", items: STRING, description: "Genres whose artists get albums first, in order." },
             },
         },
@@ -244,7 +245,7 @@ export async function callStationTool(name, args, options = {}) {
             const key = typeof args["key"] === "string" && /^[a-f0-9]{10}$/.test(args["key"]) ? args["key"] : "";
             const answer = action === "status" ? await call("GET", "/api/v1/stations/label")
                 : action === "sign" ? await call("POST", "/api/v1/stations/label/artists", pick(["preset", "roster", "name", "genre", "sound", "voice", "bio", "themes", "enabled"]))
-                    : action === "configure" ? await call("POST", "/api/v1/stations/label", pick(["holder", "monthlySeconds", "everyDays", "seedAlbums", "songsPerAlbum", "songSeconds", "parallel", "genreOrder", "albumsPerDay", "newArtistChance", "resetDay", "veo", "veoShots", "lipsyncShots", "enabled", "publish"]))
+                    : action === "configure" ? await call("POST", "/api/v1/stations/label", pick(["holder", "monthlySeconds", "everyDays", "seedAlbums", "songsPerAlbum", "songSeconds", "parallel", "genreOrder", "albumsPerDay", "newArtistChance", "resetDay", "veo", "veoShots", "lipsyncShots", "storyShots", "enabled", "publish"]))
                         : action === "run" ? await call("POST", "/api/v1/stations/label/run", {})
                             : action === "resume" ? await call("POST", "/api/v1/stations/label", { resume: true })
                                 : !key ? null