nixamp 0.51.0 → 0.52.0

package/dist/ai-label.d.ts

@@ -15,6 +15,8 @@ export interface LabelSong {
     /** The MP3, "" until composed. */
     file: string;
     lyricsFile: string;
+    /** Its music video (001. <title>.mp4), "" until made; absent on songs from before videos. */
+    video?: string;
     /** Who wrote the words and who sang them, e.g. "llama-3.3 + elevenlabs/music_v2_5". */
     made: string;
     composedAt: number;
@@ -60,14 +62,28 @@ export interface LabelSettings {
     enabled: boolean;
     /** Seconds of music a month across the label; 0 for no cap. */
     monthlySeconds: number;
-    /** Days between an artist's albums once it has its first ones. */
+    /** Days between an artist's albums once it has its first ones (only when albumsPerDay is 0). */
     everyDays: number;
+    /**
+     * Once every artist has its first albums: new albums a day across the label,
+     * each by an artist picked at random or, now and then, a new one invented
+     * in one of the owner's genres. 0 goes back to one per artist every everyDays.
+     */
+    albumsPerDay: number;
+    /** How often (0-1) the day's album is by a newly invented artist. */
+    newArtistChance: number;
     /** Albums every artist gets as soon as it can. */
     seedAlbums: number;
     songsPerAlbum: number;
     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;
     /** 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). */
+    parallel: number;
+    /** Genres whose artists get their albums first, in this order. */
+    genreOrder: string[];
     /** Set by a provider that is out of credit; cleared by `resume`. */
     pausedReason: string;
 }
@@ -95,6 +111,8 @@ export declare function planAlbum(artist: Pick<LabelArtist, "name" | "genre" | "
     }>;
     model: string;
 }>;
+/** A new artist for this genre, unlike the ones already signed. */
+export declare function inventArtist(genre: string, taken: string[], ask?: typeof askJson): Promise<ArtistPreset>;
 export declare function writeLyrics(artist: Pick<LabelArtist, "name" | "genre" | "voice" | "themes">, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "seconds">, ask?: typeof askJson): Promise<{
     lyrics: string;
     model: string;
@@ -105,6 +123,13 @@ export declare function writeLyrics(artist: Pick<LabelArtist, "name" | "genre" |
  * OPENAI_API_KEY its token); null when there is no image model to ask.
  */
 export declare function workersAiCover(prompt: string, env?: Record<string, string | undefined>, fetcher?: typeof fetch): Promise<Buffer | null>;
+/** Writes the tags (and the cover, as the attached picture) into a copy of the file. */
+/**
+ * A song's music video: its album cover over a blurred copy of itself, the
+ * song's waveform along the bottom, 720p H.264 with the MP3's audio copied in.
+ * Without a cover, a dark plate.
+ */
+export declare function renderVideo(ffmpeg: string[], audio: string, cover: string, out: string): Promise<void>;
 export interface AiLabelDeps {
     index: LibraryIndex;
     store: StationStore;
@@ -121,6 +146,10 @@ export interface AiLabelDeps {
     /** A cover picture for this prompt, or null when nothing can draw one. */
     cover?: (prompt: string) => Promise<Buffer | null>;
     tag?: (from: string, to: string, tags: Record<string, string>, cover: string) => Promise<void>;
+    /** Renders a song's music video to `out`; ffmpeg by default (renderVideo). */
+    video?: (audio: string, cover: string, out: string) => Promise<void>;
+    /** The day's pick (artist, genre, new or not); Math.random by default. */
+    random?: () => number;
     now?: () => number;
     log?: (line: string) => void;
 }
@@ -130,7 +159,19 @@ export declare class AiLabel {
     private artists;
     private settings;
     private usage;
-    private busy;
+    private running;
+    /** Songs being made now, by `<album>:<n>`. */
+    private claims;
+    /** Artists whose next album is being planned now. */
+    private planning;
+    private covering;
+    private filming;
+    /** Songs whose video failed since this server started. */
+    private videoFailed;
+    /** The day's album is tried at most every 30 minutes, so a failing model is not hammered. */
+    private dailyTriedAt;
+    /** Genre stations are kept in step one change at a time. */
+    private placing;
     private timer;
     constructor(file: string, deps: AiLabelDeps);
     static fileFor(stateDir: string, port: number): string;
@@ -159,19 +200,45 @@ export declare class AiLabel {
     /** Plan the next album for this artist now, whatever its schedule; it is composed song by song from here. */
     plan(key: string): Promise<LabelAlbum>;
     startSchedule(everyMs?: number): void;
+    /**
+     * Music videos for every released song without one, one at a time (a
+     * video is CPU, not credit), and the TV station of them kept in step. A
+     * video that fails is tried again after the next restart, not in a loop.
+     */
+    videos(): Promise<number>;
+    private film;
+    private filmPass;
+    /** The label's music videos as one TV station: free to watch, with its breaks. */
+    private placeVideos;
     stopSchedule(): void;
-    /** Everything that is due, one song at a time, until nothing is or something stops it. */
+    /**
+     * Everything that is due, `parallel` songs at a time, until nothing is or
+     * something stops it. Each worker claims a song (or an artist to plan for),
+     * so two never make the same one.
+     */
     tick(limit?: number): Promise<void>;
+    /** Where the artist's genre comes in the owner's order (genreOrder); unlisted genres after. */
+    private rank;
     private step;
+    /**
+     * After the first sweep: the day's album. When the last one was planned a
+     * day ago (or 1/albumsPerDay of one), a random artist gets it, or now and
+     * then an artist invented for one of the owner's genres. Nothing until every
+     * enabled artist has its first albums.
+     */
+    private daily;
     private failed;
     private compose;
+    /** The album's cover, drawn once; songs made at the same time wait for the same drawing. */
     private ensureCover;
+    private drawCover;
     /** album.json beside the songs: what the album is, for anybody who copies the folder. */
     private writeAlbumJson;
     private genres;
     private stationFor;
     /** The genre's station gets every song of that genre: made with the first, then kept in step. */
     private place;
+    private placeNow;
     /** The catalogue anybody may see: artists, their released songs, the words, and where each genre plays. */
     publicView(): {
         holder: string;