nixamp 0.65.1 → 0.67.0

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.65.1",
+  "version": "0.67.0",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",
@@ -50,8 +50,8 @@
     "@profullstack/live-translate": "^0.1.0",
     "@profullstack/notifications": "^0.1.0",
     "@profullstack/synconfig": "^0.1.2",
-    "@profullstack/throttle": "0.2.2",
-    "@profullstack/x402-gateway": "^0.10.1",
+    "@profullstack/throttle": "^0.3.3",
+    "@profullstack/x402-gateway": "^0.11.0",
     "acme-client": "5.4.0",
     "pg": "^8.23.0"
   },
@@ -84,6 +84,6 @@
   "overrides": {
     "https-proxy-agent": "7.0.6",
     "tslib": "2.8.1",
-    "@profullstack/x402-gateway": "^0.10.1"
+    "@profullstack/x402-gateway": "^0.11.0"
   }
 }

package/src/ai-label.ts

@@ -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.ts";
 import { composerFromEnv, OutOfCredit, type Composer } from "./ai-radio.ts";
@@ -127,8 +127,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. */
@@ -385,7 +387,8 @@ export const DEFAULTS: Omit<LabelSettings, "pausedReason"> = {
   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"],
@@ -626,21 +629,58 @@ export async function writeStoryboard(
   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: 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 = askJson,
+): Promise<string[]> {
+  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
@@ -662,7 +702,7 @@ export function veoPrompts(artist: Pick<LabelArtist, "genre" | "sound">, song: P
   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}.` : "",
@@ -1103,8 +1143,10 @@ export class AiLabel {
     if (input["publish"] !== undefined) this.settings.publish = input["publish"] !== false;
     if (input["videos"] !== undefined) 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;
     const perDay = whole("albumsPerDay", 0, 24);
@@ -1347,8 +1389,9 @@ 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 });
@@ -1378,13 +1421,20 @@ 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 });
-        writeFileSync(`${synced}.part`, bytes);
+        let bytes: Buffer | null = 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 as 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 as Error).message)) throw new Error(`lip sync ${i + 1} must wait: ${(error as Error).message}`);
         this.log(`lip sync ${i + 1} for "${song.title}": ${(error as Error).message}; the band plays there instead`);
-        if (error instanceof VeoUnavailable) break;
       } finally {
         rmSync(shot, { force: true });
         rmSync(audio, { force: true });
@@ -1404,41 +1454,64 @@ 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.
    */
-  private async filmShots(artist: LabelArtist, song: LabelSong, keep: string, dir: string): Promise<{ band: Array<{ path: string; seconds: number }>; singer: Array<{ path: string; seconds: number }> }> {
+  private async filmShots(artist: LabelArtist, album: LabelAlbum, song: LabelSong, keep: string, dir: string): Promise<{ band: Array<{ path: string; seconds: number }>; singer: Array<{ path: string; seconds: number }> }> {
     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: Buffer[] = [];
-    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`);
-      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));
-      } catch {
-        // A member without a portrait is described in words only.
+    // 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: Member): boolean => /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: Member[]): Promise<Buffer[]> => {
+      const out: Buffer[] = [];
+      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: Array<{ path: string; seconds: number }> = [];
+    const story: Array<{ path: string; seconds: number }> = [];
     const singer: Array<{ path: string; seconds: number }> = [];
-    // The singer's close-ups only where they can be lip-synced afterwards.
+    // 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: string[] = [];
+    if (storyFiles.some((file) => !existsSync(file)) && this.canAsk()) {
+      try {
+        storyPrompts = await writeVeoStory(artist, members, album, song, storyFiles.length, this.deps.ask ?? askJson);
+      } catch (error) {
+        this.log(`no story for "${song.title}" yet: ${(error as Error).message}`);
+      }
+    }
+    // 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: [] as Buffer[] })),
+      ...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 }); continue; }
       } 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: Buffer | null = null;
         for (let attempt = 0; ; attempt++) {
-          try { bytes = await veo({ prompt, seconds: 8, references }); break; } catch (error) {
-            if (attempt >= 2 || error instanceof VeoUnavailable || !/\b50[234]\b|fetch failed|ECONN|timed? ?out/i.test((error as Error).message)) throw error;
+          try { bytes = await veo({ prompt, seconds: 8, references: refs }); break; } catch (error) {
+            if (attempt >= 2 || error instanceof VeoUnavailable || !TRANSIENT.test((error as Error).message)) throw error;
             await new Promise((done) => setTimeout(done, this.deps.retryMs ?? 60_000));
           }
         }
@@ -1455,8 +1528,14 @@ export class AiLabel {
         this.log(`Veo shot ${i + 1} for "${song.title}": ${(error as 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: Array<{ path: string; seconds: number }> = [];
+    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. */

package/src/discovery.ts

@@ -11,7 +11,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 
 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: ReadonlyArray<{ target: string; label: string; suffix: string }> = [
@@ -39,19 +38,27 @@ export function desktopAsset(release: Release | null, target: string): string |
 }
 
 /**
- * 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: typeof fetch = fetch, now: () => number = Date.now): () => Promise<Release | null> {
   let kept: { at: number; release: Release | null } = { at: -Infinity, release: null };
   return async () => {
     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() as Release;
-      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/src/owner.ts

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