nixamp 0.59.5 → 0.60.0

package/dist/veo-studio.d.ts

@@ -0,0 +1,39 @@
+export declare class VeoBudgetError extends Error {
+}
+export declare class VeoRefused extends Error {
+}
+export interface VeoStudioOptions {
+    key: string;
+    file: string;
+    monthlyUsd?: number;
+    usdPerSecond?: number;
+    model?: string;
+    fetcher?: typeof fetch;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare class VeoStudio {
+    private readonly options;
+    private spent;
+    constructor(options: VeoStudioOptions);
+    static fileFor(stateDir: string, port: number): string;
+    private month;
+    private get cap();
+    private get rate();
+    private save;
+    status(): {
+        month: string;
+        spentUsd: number;
+        capUsd: number;
+        leftUsd: number;
+        usdPerSecond: number;
+        secondsLeft: number;
+    };
+    /** One shot: 4, 6 or 8 seconds, 16:9, with up to three reference images (JPEG). */
+    clip(input: {
+        prompt: string;
+        seconds: number;
+        references: Buffer[];
+    }): Promise<Buffer>;
+    private make;
+}

package/dist/veo-studio.js

@@ -0,0 +1,110 @@
+/**
+ * Veo clips for the AI label's music videos, made on nixamp.com.
+ *
+ * A label server asks for a shot (a prompt, its length, up to three member
+ * portraits as reference images) and gets back an MP4. Google's Veo 3.1 Fast
+ * makes it; nixamp.com keeps the month's spend under a cap in dollars
+ * (NIXAMP_VEO_MONTHLY_USD, $50 by default), counting every second at a
+ * deliberately high rate (NIXAMP_VEO_USD_PER_SECOND, $0.15) so the cap holds
+ * whatever Google's price is today. A shot is reserved before it is asked for
+ * and given back when Google makes nothing (a refusal, a filter, a timeout).
+ *
+ * The key is NIXAMP_VEO_API_KEY, its own name, so nothing else on nixamp.com
+ * starts spending Gemini credit because a Gemini key appeared.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export class VeoBudgetError extends Error {
+}
+export class VeoRefused extends Error {
+}
+const BASE = "https://generativelanguage.googleapis.com/v1beta";
+export class VeoStudio {
+    options;
+    spent = {};
+    constructor(options) {
+        this.options = options;
+        try {
+            this.spent = JSON.parse(readFileSync(options.file, "utf8")).spent ?? {};
+        }
+        catch {
+            this.spent = {};
+        }
+    }
+    static fileFor(stateDir, port) {
+        return join(stateDir, `veo-${port}.json`);
+    }
+    month() {
+        return new Date(this.options.now?.() ?? Date.now()).toISOString().slice(0, 7);
+    }
+    get cap() { return this.options.monthlyUsd ?? 50; }
+    get rate() { return this.options.usdPerSecond ?? 0.15; }
+    save() {
+        mkdirSync(dirname(this.options.file), { recursive: true });
+        const temporary = `${this.options.file}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${JSON.stringify({ version: 1, spent: this.spent }, null, 2)}\n`, { mode: 0o600 });
+        renameSync(temporary, this.options.file);
+    }
+    status() {
+        const spent = this.spent[this.month()] ?? 0;
+        const left = Math.max(0, this.cap - spent);
+        return { month: this.month(), spentUsd: Math.round(spent * 100) / 100, capUsd: this.cap, leftUsd: Math.round(left * 100) / 100, usdPerSecond: this.rate, secondsLeft: Math.floor(left / this.rate) };
+    }
+    /** One shot: 4, 6 or 8 seconds, 16:9, with up to three reference images (JPEG). */
+    async clip(input) {
+        const seconds = [4, 6, 8].includes(input.seconds) ? input.seconds : 8;
+        const cost = seconds * this.rate;
+        const month = this.month();
+        if ((this.spent[month] ?? 0) + cost > this.cap + 1e-9)
+            throw new VeoBudgetError(`this month's $${this.cap} of Veo is spent`);
+        // Reserved first, so two at once cannot both squeeze under the cap.
+        this.spent[month] = (this.spent[month] ?? 0) + cost;
+        this.save();
+        try {
+            return await this.make(input.prompt, seconds, input.references.slice(0, 3));
+        }
+        catch (error) {
+            this.spent[month] = Math.max(0, (this.spent[month] ?? 0) - cost);
+            this.save();
+            throw error;
+        }
+    }
+    async make(prompt, seconds, references) {
+        const send = this.options.fetcher ?? fetch;
+        const headers = { "x-goog-api-key": this.options.key, "content-type": "application/json" };
+        const model = this.options.model ?? "veo-3.1-fast-generate-preview";
+        const started = await send(`${BASE}/models/${model}:predictLongRunning`, {
+            method: "POST",
+            headers,
+            signal: AbortSignal.timeout(60_000),
+            body: JSON.stringify({
+                instances: [{
+                        prompt: prompt.slice(0, 1800),
+                        ...(references.length ? { referenceImages: references.map((bytes) => ({ image: { bytesBase64Encoded: bytes.toString("base64"), mimeType: "image/jpeg" }, referenceType: "asset" })) } : {}),
+                    }],
+                parameters: { aspectRatio: "16:9", durationSeconds: seconds },
+            }),
+        });
+        const operation = await started.json().catch(() => ({}));
+        if (!started.ok || !operation.name)
+            throw new VeoRefused(`Veo refused the shot: ${operation.error?.message?.slice(0, 200) ?? `HTTP ${started.status}`}`);
+        const sleep = this.options.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+        for (let tries = 0; tries < 60; tries++) {
+            await sleep(10_000);
+            const state = await (await send(`${BASE}/${operation.name}`, { headers, signal: AbortSignal.timeout(30_000) })).json().catch(() => ({}));
+            if (!state.done)
+                continue;
+            if (state.error)
+                throw new VeoRefused(`Veo failed: ${state.error.message?.slice(0, 200) ?? "no reason"}`);
+            const uri = state.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri;
+            if (!uri)
+                throw new VeoRefused(`Veo made nothing: ${state.response?.generateVideoResponse?.raiMediaFilteredReasons?.[0]?.slice(0, 200) ?? "no sample"}`);
+            const video = await send(uri, { headers: { "x-goog-api-key": this.options.key }, signal: AbortSignal.timeout(120_000) });
+            const bytes = Buffer.from(await video.arrayBuffer());
+            if (!video.ok || bytes.length < 10_000)
+                throw new VeoRefused(`the Veo clip did not download (HTTP ${video.status})`);
+            return bytes;
+        }
+        throw new VeoRefused("Veo took too long (10 minutes)");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.59.5",
+  "version": "0.60.0",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/ai-label.ts

@@ -125,6 +125,10 @@ export interface LabelSettings {
   songSeconds: number;
   /** A music video for every song (the cover over itself, blurred, and the song's waveform), and a TV station of them. */
   videos: boolean;
+  /** Each album's single (song 1) gets filmed Veo shots of the band, while the month's Veo budget lasts. */
+  veo: boolean;
+  /** How many 8 s Veo shots a single gets. */
+  veoShots: number;
   /** Public, listed and owned, so the genre stations are on the guide. */
   publish: boolean;
   /** Songs made at the same time (ElevenLabs takes several requests at once on a paid plan). */
@@ -378,6 +382,8 @@ export const DEFAULTS: Omit<LabelSettings, "pausedReason"> = {
   songSeconds: 150,
   publish: true,
   videos: true,
+  veo: false,
+  veoShots: 4,
   parallel: 1,
   genreOrder: ["Punk", "Blues", "Country", "Jazz", "Classic Rock", "Metal", "Hip-Hop", "Pop", "R&B"],
 };
@@ -617,6 +623,35 @@ export async function writeStoryboard(
   return prompts;
 }
 
+/** Thrown by a Veo dependency when this month's budget is spent: no more shots until next month. */
+export class VeoUnavailable extends Error {}
+
+const SHOTS = [
+  "Wide shot of the whole band performing on a stage, the crowd in the foreground",
+  "Close-up of the lead singer singing the chorus into the microphone",
+  "The camera moves across the stage between the band members as they play hard",
+  "Low-angle shot of the band at the song's climax, lights flaring behind them",
+  "Over-the-shoulder shot from behind the drums, looking out at the band and the crowd",
+  "Slow push-in on the band in a quieter moment, moody light",
+  "Handheld shot from the crowd, fans with hands up, the band lit on stage",
+  "The band walking out on stage before the show, backlit silhouettes turning into faces",
+];
+
+/**
+ * The prompts for a single's filmed shots. The people are the reference
+ * images, described by role and look only: Veo refuses names with faces
+ * ("we can't create videos with real people's names or likenesses").
+ */
+export function veoPrompts(artist: Pick<LabelArtist, "genre" | "sound">, song: Pick<LabelSong, "style">, members: Array<Pick<Member, "role" | "look">>, count: number): string[] {
+  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("; ");
+  return 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}.` : "",
+    `Mood and sound: ${song.style} ${artist.sound}.`.slice(0, 400),
+    "Cinematic, 35mm film look, dynamic camera. No text, no logos.",
+  ].filter(Boolean).join(" "));
+}
+
 /** The DejaVu bold face most Linux boxes have, for the title card; "" when there is none. */
 function titleFont(): string {
   for (const file of ["/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", "/usr/share/fonts/dejavu/DejaVuSans-Bold.ttf", "/System/Library/Fonts/Supplemental/Arial Bold.ttf"]) {
@@ -640,10 +675,21 @@ function runLow(ffmpeg: string[], args: string[], timeout: number, what: string)
  * the artist and title come up at the start, and the MP3's audio and tags
  * (title, artist, album, words) are copied in. 720p H.264.
  */
-export function renderStoryVideo(ffmpeg: string[], input: { audio: string; images: string[]; seconds: number; artist: string; title: string; out: string }): Promise<void> {
+export function renderStoryVideo(ffmpeg: string[], input: { audio: string; images: string[]; seconds: number; artist: string; title: string; out: string; clips?: Array<{ path: string; seconds: number }> }): Promise<void> {
   const fade = 1;
-  const count = input.images.length;
-  const each = input.seconds / count + fade;
+  const clips = input.clips ?? [];
+  // Stills fill what the filmed shots do not; each gets at least 3 s, so on a short song some are left out.
+  let images = [...input.images];
+  const clipTime = clips.reduce((sum, one) => sum + one.seconds, 0);
+  const stillFor = (count: number): number => (input.seconds + (count + clips.length - 1) * fade - clipTime) / Math.max(1, count);
+  while (images.length > 0 && stillFor(images.length) < 3) images = images.slice(0, -1);
+  const each = images.length ? stillFor(images.length) : 0;
+  // A still, then a filmed shot, in turn; whatever is left of either at the end.
+  const order: Array<{ kind: "image"; path: string } | { kind: "clip"; path: string; seconds: number }> = [];
+  for (let i = 0; i < Math.max(images.length, clips.length); i++) {
+    if (images[i]) order.push({ kind: "image", path: images[i]! });
+    if (clips[i]) order.push({ kind: "clip", ...clips[i]! });
+  }
   const frames = Math.max(25, Math.round(each * 25));
   const moves = [
     `z='1+0.15*on/${frames}':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'`,
@@ -652,12 +698,25 @@ export function renderStoryVideo(ffmpeg: string[], input: { audio: string; image
     `z='1.15':x='(iw-iw/zoom)*(1-on/${frames})':y='(ih-ih/zoom)*on/${frames}'`,
   ];
   const parts: string[] = [];
-  input.images.forEach((_, i) => {
-    parts.push(`[${i}:v]scale=1600:900:force_original_aspect_ratio=increase,crop=1600:900,zoompan=${moves[i % moves.length]}:d=1:s=1280x720:fps=25,setsar=1[v${i}]`);
+  const lengths: number[] = [];
+  let still = 0;
+  order.forEach((item, i) => {
+    if (item.kind === "image") {
+      parts.push(`[${i}:v]scale=1600:900:force_original_aspect_ratio=increase,crop=1600:900,zoompan=${moves[still++ % moves.length]}:d=1:s=1280x720:fps=25,setsar=1[v${i}]`);
+      lengths.push(each);
+    } else {
+      // A filmed shot plays as it was filmed; the last one holds its final frame if the song runs on.
+      const hold = i === order.length - 1 ? `,tpad=stop_mode=clone:stop_duration=${Math.max(0, input.seconds).toFixed(2)}` : "";
+      parts.push(`[${i}:v]scale=1280:720:force_original_aspect_ratio=increase,crop=1280:720,fps=25,setsar=1,trim=duration=${item.seconds},setpts=PTS-STARTPTS${hold}[v${i}]`);
+      lengths.push(item.seconds);
+    }
   });
+  const count = order.length;
   let last = "v0";
+  let at = 0;
   for (let i = 1; i < count; i++) {
-    parts.push(`[${last}][v${i}]xfade=transition=fade:duration=${fade}:offset=${(i * (each - fade)).toFixed(2)}[x${i}]`);
+    at += lengths[i - 1]! - fade;
+    parts.push(`[${last}][v${i}]xfade=transition=fade:duration=${fade}:offset=${at.toFixed(2)}[x${i}]`);
     last = `x${i}`;
   }
   const font = titleFont();
@@ -666,7 +725,7 @@ export function renderStoryVideo(ffmpeg: string[], input: { audio: string; image
     ? `[${last}]drawtext=fontfile=${font}:text='${card}':fontcolor=white:fontsize=44:x=60:y=h-110:enable='between(t,0.5,6)':alpha='if(lt(t,1.5),t-0.5,if(gt(t,5),6-t,1))':shadowcolor=black@0.7:shadowx=2:shadowy=2,format=yuv420p[v]`
     : `[${last}]format=yuv420p[v]`);
   const args = ["-hide_banner", "-loglevel", "error", "-y", "-threads", "2",
-    ...input.images.flatMap((image) => ["-loop", "1", "-t", each.toFixed(2), "-i", image]),
+    ...order.flatMap((item) => (item.kind === "image" ? ["-loop", "1", "-t", each.toFixed(2), "-i", item.path] : ["-i", item.path])),
     "-i", input.audio, "-filter_complex", parts.join(";"),
     "-map", "[v]", "-map", `${count}:a`, "-map_metadata", String(count), "-c:v", "libx264", "-preset", "veryfast", "-crf", "24", "-r", "25", "-c:a", "copy", "-shortest",
     "-movflags", "+faststart+use_metadata_tags", input.out];
@@ -758,8 +817,10 @@ export interface AiLabelDeps {
   video?: (audio: string, cover: string, out: string) => Promise<void>;
   /** Times each sung word in a recording; ElevenLabs forced alignment by default, null without a key. */
   align?: ((audio: string, text: string) => Promise<TimedWord[]>) | null;
+  /** A filmed shot (Veo, through nixamp.com): the MP4, or a VeoUnavailable when the month's budget is spent. */
+  veo?: ((input: { prompt: string; seconds: number; references: Buffer[] }) => Promise<Buffer>) | null;
   /** Renders a storyboard music video; ffmpeg by default (renderStoryVideo). */
-  storyVideo?: (input: { audio: string; images: string[]; seconds: number; artist: string; title: string; out: string }) => Promise<void>;
+  storyVideo?: (input: { audio: string; images: string[]; seconds: number; artist: string; title: string; out: string; clips?: Array<{ path: string; seconds: number }> }) => Promise<void>;
   /** A scene's picture for this prompt, or null when nothing can draw one; Workers AI by default. */
   image?: (prompt: string) => Promise<Buffer | null>;
   /** Tells the world an album landed (nixamp.com tells the artist's followers); never awaited. */
@@ -789,6 +850,8 @@ export class AiLabel {
   private videoFailed = new Set<string>();
   /** Songs whose words were already sent to the aligner since this server started. */
   private alignTried = new Set<string>();
+  /** The month ("YYYY-MM") Veo said its budget was spent; no more shots until the next. */
+  private veoSpentIn = "";
   /** Old videos already tried as storyboards since this server started. */
   private upgradeTried = new Set<string>();
   /** The day's album is tried at most every 30 minutes, so a failing model is not hammered. */
@@ -937,6 +1000,9 @@ export class AiLabel {
     if (input["enabled"] !== undefined) this.settings.enabled = input["enabled"] !== false;
     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);
+    if (shots !== undefined) this.settings.veoShots = shots;
     const perDay = whole("albumsPerDay", 0, 24);
     if (perDay !== undefined) this.settings.albumsPerDay = perDay;
     if (input["newArtistChance"] !== undefined) {
@@ -1114,7 +1180,7 @@ export class AiLabel {
       .flatMap((album) => album.songs.filter((song) => song.file && !this.videoFailed.has(song.file)).map((song) => ({ artist, album, song }))));
     const missing = songs.filter(({ song }) => !song.video);
     const untagged = songs.filter(({ song }) => song.video && !song.videoTagged);
-    const old = songs.filter(({ song }) => song.video && song.videoTagged && (song.videoVersion ?? 1) < 2 && !this.upgradeTried.has(song.file));
+    const old = songs.filter(({ song }) => song.video && song.videoTagged && ((song.videoVersion ?? 1) < 2 || (this.wantsVeo(song) && (song.videoVersion ?? 1) < 3)) && !this.upgradeTried.has(song.file));
     let made = 0;
     for (const { album, song } of untagged) {
       if (!this.settings.videos) break;
@@ -1192,15 +1258,65 @@ export class AiLabel {
         this.log(`no storyboard for "${song.title}" (${(error as Error).message}); the cover video instead`);
       }
     }
-    if (images.length >= 2) {
-      await (this.deps.storyVideo ?? ((input) => renderStoryVideo(this.deps.ffmpeg, input)))({ audio: song.file, images, seconds, artist: artist.name, title: song.title, out });
-      return 2;
+    // An album's single gets filmed shots of the band too, while the month's Veo budget lasts.
+    const clips = this.wantsVeo(song) ? await this.filmShots(artist, song, scenes) : [];
+    if (images.length >= 2 || clips.length > 0) {
+      if (storyOnly && (song.videoVersion ?? 1) >= 2 && clips.length === 0) throw new Error("no filmed shots this time; the video it has stays");
+      await (this.deps.storyVideo ?? ((input) => renderStoryVideo(this.deps.ffmpeg, input)))({ audio: song.file, images, seconds, artist: artist.name, title: song.title, out, ...(clips.length ? { clips } : {}) });
+      return clips.length ? 3 : 2;
     }
     if (storyOnly) throw new Error("no storyboard could be drawn; the video it has stays");
     await (this.deps.video ?? ((audio, cover, to) => renderVideo(this.deps.ffmpeg, audio, cover, to)))(song.file, album.cover, out);
     return 1;
   }
 
+  /** Whether this song gets filmed Veo shots: an album's single, Veo on, and the month's budget not spent. */
+  private wantsVeo(song: Pick<LabelSong, "n">): boolean {
+    return this.settings.veo && song.n === 1 && Boolean(this.deps.veo) && this.veoSpentIn !== new Date(this.now()).toISOString().slice(0, 7);
+  }
+
+  /**
+   * A single's filmed shots: the band, from their portraits (up to three as
+   * 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, dir: string): Promise<Array<{ path: string; seconds: number }>> {
+    const veo = this.deps.veo;
+    if (!veo) return [];
+    mkdirSync(dir, { 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.
+      }
+    }
+    const clips: Array<{ path: string; seconds: number }> = [];
+    for (const [i, prompt] of veoPrompts(artist, song, members, this.settings.veoShots).entries()) {
+      try {
+        const bytes = await veo({ prompt, seconds: 8, references });
+        const file = join(dir, `shot-${i}.mp4`);
+        writeFileSync(file, bytes);
+        clips.push({ path: file, seconds: 8 });
+      } catch (error) {
+        if (error instanceof VeoUnavailable) {
+          this.veoSpentIn = new Date(this.now()).toISOString().slice(0, 7);
+          this.log(`Veo: ${(error as Error).message}; singles get the storyboard until next month`);
+          break;
+        }
+        this.log(`Veo shot ${i + 1} for "${song.title}": ${(error as Error).message}`);
+      }
+    }
+    if (clips.length) this.log(`Veo: ${clips.length} filmed shots for "${song.title}" (${artist.name})`);
+    return clips;
+  }
+
   /** The label's music videos as one TV station: free to watch, with its breaks. */
   private placeVideos(): Promise<void> {
     const next = this.placing.then(async () => {

package/src/music-hub.ts

@@ -149,7 +149,7 @@ export async function musicPageFor(hub: MusicHub, path: string): Promise<string>
 }
 
 export function isMusicPath(path: string): boolean {
-  return path === "/music" || path.startsWith("/music/") || path === "/api/v1/music" || FILE.test(path) || path === "/api/v1/music/released";
+  return path === "/music" || path.startsWith("/music/") || path === "/api/v1/music" || FILE.test(path) || path === "/api/v1/music/released" || path === "/api/v1/music/veo";
 }
 
 export interface MusicRoutesContext {
@@ -160,6 +160,8 @@ export interface MusicRoutesContext {
   page: () => string | null;
   /** A server says something of its label landed; null when nobody may say so. */
   released?: (request: IncomingMessage, body: Record<string, unknown>) => Promise<{ status: number; body: unknown }>;
+  /** Veo shots for a label server's videos: the month's spend (GET), a clip (POST); answers bytes or JSON. */
+  veo?: (request: IncomingMessage) => Promise<{ status: number; body: unknown; video?: Buffer }>;
 }
 
 export async function handleMusicRoutes(request: IncomingMessage, response: ServerResponse, path: string, ctx: MusicRoutesContext): Promise<boolean> {
@@ -173,6 +175,15 @@ export async function handleMusicRoutes(request: IncomingMessage, response: Serv
     ctx.json(response, answer.status, answer.body);
     return true;
   }
+  if (path === "/api/v1/music/veo") {
+    if (!ctx.veo) { ctx.json(response, 404, { error: "Veo is not set up here" }); return true; }
+    const answer = await ctx.veo(request);
+    if (answer.video) {
+      response.writeHead(200, { "content-type": "video/mp4", "content-length": String(answer.video.length), "cache-control": "no-store" });
+      response.end(answer.video);
+    } else ctx.json(response, answer.status, answer.body);
+    return true;
+  }
   if (method !== "GET" && method !== "HEAD") { ctx.json(response, 405, { error: "not like that" }); return true; }
   if (path === "/api/v1/music") {
     ctx.json(response, 200, await ctx.hub.catalogue());

package/src/server.ts

@@ -80,10 +80,11 @@ import { ListenerStore } from "./library-user.ts";
 import { Importer } from "./handoff.ts";
 import { handleHandoffs } from "./handoff-routes.ts";
 import { handleAiRoutes, isPublicSharePath } from "./ai-routes.ts";
-import { AiLabel } from "./ai-label.ts";
+import { AiLabel, VeoUnavailable } from "./ai-label.ts";
 import { buyLink, handleLabelRoutes, isPublicLabelPath } from "./label-routes.ts";
 import { GrantVerifier, MusicStore, PRICES } from "./music-store.ts";
 import { handleMusicRoutes, isMusicPath, MusicHub, musicPageFor, serverId } from "./music-hub.ts";
+import { VeoBudgetError, VeoStudio } from "./veo-studio.ts";
 import { handleStoreRoutes, isStorePath } from "./store-routes.ts";
 import { AiRadio } from "./ai-radio.ts";
 import { ListenerShares } from "./listener-shares.ts";
@@ -1963,7 +1964,7 @@ export interface HandlerOptions {
   /** The AI label's songs for sale, nixamp.com only (music-store.ts). */
   musicStore?: MusicStore;
   /** nixamp.com/music: every server's label in one app (music-hub.ts). */
-  music?: { hub: MusicHub; released: (request: IncomingMessage, body: Record<string, unknown>) => Promise<{ status: number; body: unknown }> };
+  music?: { hub: MusicHub; released: (request: IncomingMessage, body: Record<string, unknown>) => Promise<{ status: number; body: unknown }>; veo?: (request: IncomingMessage) => Promise<{ status: number; body: unknown; video?: Buffer }> };
   sharedTranslations?: SharedTranslations;
   /** Translation: texts in another language, by a model here. The same optional library. */
   translator?: Translator;
@@ -3413,6 +3414,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         readBody,
         page: () => { try { return shell ? readFileSync(shell, "utf8") : null; } catch { return null; } },
         released: music.released,
+        ...(music.veo ? { veo: music.veo } : {}),
       })) return;
     }
 
@@ -7685,6 +7687,21 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     root: process.env["NIXAMP_LABEL_ROOT"] || (labelHome ? join(labelHome.root, "ai") : join(stateDir(), "ai-label")),
     owner: options.owner || "",
     mayStart: mayStartStation,
+    // Filmed shots for singles come from nixamp.com's Veo studio, asked as this server's owner, under its monthly cap.
+    veo: async (shot) => {
+      const session = readSession();
+      const here = stations.publicBase?.() ?? "";
+      if (!session?.token || !/^https:\/\//.test(here)) throw new VeoUnavailable("this server is not signed in to nixamp.com");
+      const answer = await fetch(`${session.site.replace(/\/+$/, "")}/api/v1/music/veo`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${session.token}`, "x-nixamp-server": here },
+        body: JSON.stringify({ prompt: shot.prompt, seconds: shot.seconds, references: shot.references.map((one) => one.toString("base64")) }),
+        signal: AbortSignal.timeout(12 * 60_000),
+      });
+      if (answer.status === 402 || answer.status === 404) throw new VeoUnavailable(((await answer.json().catch(() => ({}))) as { error?: string }).error ?? `HTTP ${answer.status}`);
+      if (!answer.ok) throw new Error(((await answer.json().catch(() => ({}))) as { error?: string }).error ?? `nixamp.com answered ${answer.status}`);
+      return Buffer.from(await answer.arrayBuffer());
+    },
     // A release is told to nixamp.com as this server's owner; nixamp.com tells the artist's followers.
     announce: (release) => {
       const session = readSession();
@@ -7961,6 +7978,36 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
    * followers are told. Only the account that owns a listed server may say
    * so, only for an artist that server's catalogue has, once per release.
    */
+  // Veo shots for label music videos, under a monthly dollar cap (veo-studio.ts). nixamp.com only.
+  const veoStudio = options.directory && process.env["NIXAMP_VEO_API_KEY"] ? new VeoStudio({
+    key: process.env["NIXAMP_VEO_API_KEY"],
+    file: VeoStudio.fileFor(stateDir(), options.port),
+    monthlyUsd: Number(process.env["NIXAMP_VEO_MONTHLY_USD"] ?? 50),
+    usdPerSecond: Number(process.env["NIXAMP_VEO_USD_PER_SECOND"] ?? 0.15),
+  }) : undefined;
+  /** The signed-in account owns a server listed in the directory at this base. */
+  const ownsListed = async (request: IncomingMessage, base: string): Promise<boolean> => {
+    const me = accounts ? await accounts.whoIs(tokenFrom(request.headers)).catch(() => null) : null;
+    return Boolean(me && base && directory?.list().some((one) => one.ownerId === me.id && peerBase(one.url) === base));
+  };
+  const musicVeo = async (request: IncomingMessage): Promise<{ status: number; body: unknown; video?: Buffer }> => {
+    if (!veoStudio) return { status: 404, body: { error: "Veo is not set up here" } };
+    const base = peerBase(String(request.headers["x-nixamp-server"] ?? ""));
+    if (!(await ownsListed(request, base))) return { status: 403, body: { error: "only the owner of a listed server" } };
+    if (request.method === "GET") return { status: 200, body: veoStudio.status() };
+    if (request.method !== "POST") return { status: 405, body: { error: "GET or POST" } };
+    let input: { prompt?: unknown; seconds?: unknown; references?: unknown };
+    try { input = JSON.parse(await readBody(request, 2 * 1024 * 1024)) as typeof input; } catch { return { status: 400, body: { error: "a JSON body under 2 MB" } }; }
+    const prompt = String(input.prompt ?? "").trim();
+    if (prompt.length < 20) 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 }) };
+    } catch (error) {
+      if (error instanceof VeoBudgetError) return { status: 402, body: { error: error.message, code: "budget", ...veoStudio.status() } };
+      return { status: 422, body: { error: (error as Error).message, code: "refused" } };
+    }
+  };
   const announced = new Set<string>();
   const musicReleased = async (request: IncomingMessage, body: Record<string, unknown>): Promise<{ status: number; body: unknown }> => {
     const me = accounts ? await accounts.whoIs(tokenFrom(request.headers)).catch(() => null) : null;
@@ -8544,7 +8591,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ...(supportPayments ? { support: supportPayments } : {}),
     ...(supportMonthly ? { supportSubscriptions: supportMonthly } : {}),
     ...(musicStore ? { musicStore } : {}),
-    ...(musicHub ? { music: { hub: musicHub, released: musicReleased } } : {}),
+    ...(musicHub ? { music: { hub: musicHub, released: musicReleased, veo: musicVeo } } : {}),
     ...(process.env["COINPAY_WEBHOOK_SECRET"] ? { coinpayWebhookSecret: process.env["COINPAY_WEBHOOK_SECRET"] } : {}),
     ...(sharedTranslations ? { sharedTranslations } : {}),
     ...(translator ? { translator } : {}),

package/src/station-cli.ts

@@ -504,6 +504,8 @@ async function labelCommand(argv: string[], call: Call, show: Show): Promise<num
         videos: has(argv, "--no-videos") ? false : has(argv, "--videos") ? true : undefined,
         newArtistChance: number("--new-artists"),
         resetDay: number("--reset-day"),
+        veo: has(argv, "--veo") ? true : has(argv, "--no-veo") ? false : undefined,
+        veoShots: number("--veo-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/src/station-mcp.ts

@@ -124,6 +124,8 @@ export const STATION_TOOLS = [
         albumsPerDay: { type: "integer", description: "After the first sweep: new albums a day, by a random artist or a newly invented one." },
         newArtistChance: { type: "number", description: "0-1: how often the day's album is by a new artist." },
         resetDay: { type: "integer", description: "Day of the month (1-28) the budget renews: the music provider's billing day." },
+        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 per single (1-8)." },
         genreOrder: { type: "array", items: STRING, description: "Genres whose artists get albums first, in order." },
       },
     },
@@ -254,7 +256,7 @@ export async function callStationTool(name: string, args: Record<string, unknown
       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", "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", "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

package/src/station-usage.ts

@@ -50,6 +50,7 @@ export const USAGE = `nixamp station — make a collection into a station
                               [--per-day 1] [--new-artists 0.25]   after the first sweep: albums a day, share by new artists
                               [--videos|--no-videos]   a music video per song and a TV station of them
                               [--reset-day 21]   the day the monthly budget renews (the provider's billing day)
+                              [--veo|--no-veo] [--veo-shots 4]   filmed Veo shots of the band in each album's single (nixamp.com caps the month)
   nixamp station label run                   record whatever is due now
   nixamp station label resume                after the provider ran out of credit