nixamp 0.48.0 → 0.49.0

package/dist/ai-keys.d.ts

@@ -1,4 +1,4 @@
-export declare const AI_KEY_NAMES: readonly ["ELEVENLABS_API_KEY", "GEMINI_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "NIXAMP_OPENAI_URL", "NIXAMP_OPENAI_MODEL", "NIXAMP_LYRICS_KEY"];
+export declare const AI_KEY_NAMES: readonly ["ELEVENLABS_API_KEY", "GEMINI_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "NIXAMP_OPENAI_URL", "NIXAMP_OPENAI_MODEL", "NIXAMP_MUSIC_MODEL", "NIXAMP_LYRICS_KEY"];
 export type AiKeyName = (typeof AI_KEY_NAMES)[number];
 export declare function aiKeysFile(): string;
 /** The key, from the environment or ai.json; "" when neither has it. */

package/dist/ai-keys.js

@@ -13,6 +13,8 @@ export const AI_KEY_NAMES = [
     "ELEVENLABS_API_KEY", "GEMINI_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY",
     // Any OpenAI-compatible endpoint in OpenAI's place (Cloudflare Workers AI, Ollama, ...) and its model.
     "NIXAMP_OPENAI_URL", "NIXAMP_OPENAI_MODEL",
+    // Which ElevenLabs music model composes: music_v1, music_v2 or music_v2_5 (the default).
+    "NIXAMP_MUSIC_MODEL",
     // nichedb.dev's key for publishing our own songs' words (lyrics-publish.ts).
     "NIXAMP_LYRICS_KEY",
 ];

package/dist/ai-label.d.ts

@@ -0,0 +1,210 @@
+import { type Composer } from "./ai-radio.ts";
+import { askJson } from "./ai-text.ts";
+import type { LibraryIndex, Probed } from "./library-index.ts";
+import type { StationRunner } from "./station-runner.ts";
+import { type StationStore } from "./stations.ts";
+export interface LabelSong {
+    /** Its place on the album, from 1. */
+    n: number;
+    title: string;
+    /** The production brief the music model is given beside the artist's sound. */
+    style: string;
+    /** The words, with [Verse]/[Chorus] section lines; "" until written. */
+    lyrics: string;
+    seconds: number;
+    /** The MP3, "" until composed. */
+    file: string;
+    lyricsFile: string;
+    /** Who wrote the words and who sang them, e.g. "llama-3.3 + elevenlabs/music_v2_5". */
+    made: string;
+    composedAt: number;
+}
+export interface LabelAlbum {
+    key: string;
+    title: string;
+    year: number;
+    concept: string;
+    /** The album's folder. */
+    folder: string;
+    /** cover.jpg in the folder, "" when there is none. */
+    cover: string;
+    coverTried: boolean;
+    songs: LabelSong[];
+    /** Which model planned it. */
+    writer: string;
+    plannedAt: number;
+    /** When its last song landed; 0 while it is being made. */
+    doneAt: number;
+}
+export interface LabelArtist {
+    key: string;
+    name: string;
+    genre: string;
+    /** The music in words: every song's brief starts from it. */
+    sound: string;
+    /** The lead voice. */
+    voice: string;
+    bio: string;
+    /** What the songs are about. */
+    themes: string;
+    enabled: boolean;
+    albums: LabelAlbum[];
+    createdAt: number;
+    lastAttemptAt: number;
+    lastError: string;
+    failures: number;
+}
+export interface LabelSettings {
+    /** Who holds the rights: publisher and copyright on every file, and the station's declaration. */
+    holder: string;
+    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. */
+    everyDays: number;
+    /** Albums every artist gets as soon as it can. */
+    seedAlbums: number;
+    songsPerAlbum: number;
+    songSeconds: number;
+    /** Public, listed and owned, so the genre stations are on the guide. */
+    publish: boolean;
+    /** Set by a provider that is out of credit; cleared by `resume`. */
+    pausedReason: string;
+}
+export type ArtistPreset = Pick<LabelArtist, "name" | "genre" | "sound" | "voice" | "bio" | "themes">;
+/**
+ * The label's first roster: invented names, one genre each, sung in English.
+ * `nixamp station label artist add --preset KEY`, or all of them with `--roster`.
+ */
+export declare const ROSTER: Record<string, ArtistPreset>;
+export declare const DEFAULTS: Omit<LabelSettings, "pausedReason">;
+/** A name as a folder or file name: what a filesystem or a zip refuses is dropped. */
+export declare function fileName(text: string): string;
+/** A genre's folder and station key: "Hip-Hop" is hip-hop, "R&B" is rnb. */
+export declare function genreSlug(genre: string): string;
+/** "001. Title", the start of a song's file names. */
+export declare function songBase(song: Pick<LabelSong, "n" | "title">): string;
+/** Words as a singer gets them: section lines kept, the model's own notes and fences dropped. */
+export declare function cleanLyrics(text: string): string;
+export declare function planAlbum(artist: Pick<LabelArtist, "name" | "genre" | "sound" | "voice" | "bio" | "themes" | "albums">, songs: number, ask?: typeof askJson): Promise<{
+    title: string;
+    concept: string;
+    songs: Array<{
+        title: string;
+        style: string;
+    }>;
+    model: string;
+}>;
+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;
+}>;
+/**
+ * A cover from Cloudflare Workers AI (flux-1-schnell), when the language model
+ * slot is Workers AI (NIXAMP_OPENAI_URL is an account's /ai/v1 and
+ * 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>;
+export interface AiLabelDeps {
+    index: LibraryIndex;
+    store: StationStore;
+    runner: StationRunner;
+    probe: (path: string) => Promise<Probed>;
+    ffmpeg: string[];
+    /** Where the label's music goes: <root>/<genre>/<artist>/<year>-<album>/. */
+    root: string;
+    owner: string;
+    mayStart: () => boolean;
+    composer?: () => Composer | null;
+    ask?: typeof askJson;
+    canAsk?: () => boolean;
+    /** 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>;
+    now?: () => number;
+    log?: (line: string) => void;
+}
+export declare class AiLabel {
+    private readonly file;
+    private readonly deps;
+    private artists;
+    private settings;
+    private usage;
+    private busy;
+    private timer;
+    constructor(file: string, deps: AiLabelDeps);
+    static fileFor(stateDir: string, port: number): string;
+    private now;
+    private log;
+    private save;
+    private composer;
+    private canAsk;
+    /** The library source the root is in: the one that already holds it, else a managed one of its own. */
+    private source;
+    get root(): string;
+    list(): LabelArtist[];
+    get(key: string): LabelArtist | undefined;
+    holder(): string;
+    private budgetLeft;
+    /** When this artist's next album is due: its first ones at once, then every `everyDays`, staggered by artist. */
+    dueAt(artist: LabelArtist): number;
+    private backingOff;
+    status(): Record<string, unknown>;
+    configure(input: Record<string, unknown>): LabelSettings;
+    /** Sign an artist: a preset from the roster, or a name, genre and sound of the owner's own. */
+    sign(input: Record<string, unknown>): LabelArtist;
+    update(key: string, input: Record<string, unknown>): LabelArtist;
+    /** Let an artist go. Its music stays (and stays on the air) unless `files` is true. */
+    drop(key: string, files?: boolean): Promise<void>;
+    /** 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;
+    stopSchedule(): void;
+    /** Everything that is due, one song at a time, until nothing is or something stops it. */
+    tick(limit?: number): Promise<void>;
+    private step;
+    private failed;
+    private compose;
+    private ensureCover;
+    /** 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;
+    /** The catalogue anybody may see: artists, their released songs, the words, and where each genre plays. */
+    publicView(): {
+        holder: string;
+        genres: Array<{
+            genre: string;
+            station: string;
+            artists: PublicArtist[];
+        }>;
+    };
+    /** A released file anybody may fetch: a song, its words, or its album's cover. */
+    publicFile(artistKey: string, albumKey: string, what: string): {
+        path: string;
+        type: string;
+    } | null;
+    private require;
+}
+export interface PublicArtist {
+    key: string;
+    name: string;
+    genre: string;
+    bio: string;
+    albums: Array<{
+        key: string;
+        title: string;
+        year: number;
+        concept: string;
+        cover: boolean;
+        complete: boolean;
+        songs: Array<{
+            n: number;
+            title: string;
+            seconds: number;
+            lyrics: string;
+        }>;
+    }>;
+}