nixamp 0.48.1 → 0.50.1

package/dist/ai-label.js

@@ -0,0 +1,774 @@
+/**
+ * The AI label: a roster of original artists who put out albums on their own.
+ *
+ * Where AI radio (ai-radio.ts) is a station that grows a track at a time, the
+ * label is a record company in miniature. Each artist has a name, a genre, a
+ * sound and a voice. When an artist is due -- its first albums at once, then
+ * one every `everyDays` -- a language model plans an album (a title, a
+ * concept, a running order with a brief per song), writes each song's words
+ * in English, and a music model sings them. Every song lands as
+ *
+ *     <root>/<genre>/<artist>/<year>-<album>/001. <title>.mp3
+ *     <root>/<genre>/<artist>/<year>-<album>/001. <title>.lyrics.txt
+ *
+ * with the album's cover.jpg and album.json beside them, tagged with the
+ * artist, album, track number, the words (so lyrics-publish.ts sends them to
+ * nichedb) and the label's rights holder as publisher and copyright. Each
+ * genre is one station on the public guide, kept in step as songs land, and
+ * the whole catalogue has a page anybody can read and play (label-routes.ts).
+ *
+ * Planning is saved before anything is composed, and each song is composed on
+ * its own, so a restart, a failure or a month's cap resumes where it stopped.
+ * Composition is metered in seconds a month like AI radio, and a provider out
+ * of credit pauses the label until the owner resumes it.
+ *
+ * The rights holder's declaration is what makes the music "owned" here; it is
+ * not legal clearance, and how much of a machine's work copyright covers is
+ * the holder's question to settle.
+ */
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, 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";
+import { askJson, hasModel } from "./ai-text.js";
+import { StationError } from "./stations.js";
+/**
+ * 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 const ROSTER = {
+    "velvet-ruckus": {
+        name: "Velvet Ruckus", genre: "Rock",
+        sound: "gritty alternative rock, crunchy overdriven guitars, big room drums, melodic bass, anthemic choruses, 120-150 BPM",
+        voice: "raspy, powerful female alto with a wide belt and a little growl",
+        bio: "A four-piece that sounds like a basement show that got too big for the basement.",
+        themes: "small-town escape, late shifts, loyalty, burning bridges and building better ones",
+    },
+    "juno-kincaid": {
+        name: "Juno Kincaid", genre: "Hip-Hop",
+        sound: "modern boom-bap hip hop, dusty sampled-sounding keys, hard swung drums, deep 808s, vinyl texture, 85-95 BPM",
+        voice: "confident male rapper, clear diction, warm low register, conversational flow with sung hooks",
+        bio: "A night-bus storyteller who raps like he is reading you his diary on the last train home.",
+        themes: "ambition, city nights, family, hustle and doubt, coming up from nothing",
+    },
+    "chrome-orchard": {
+        name: "Chrome Orchard", genre: "Synthwave",
+        sound: "retro 80s synthwave, gated reverb drums, analog bass arpeggios, lush neon pads, soaring lead synth, 100-118 BPM",
+        voice: "airy male tenor, slightly reverbed, wistful and cinematic",
+        bio: "Soundtracks for a film about driving that nobody has made yet.",
+        themes: "night drives, neon cities, lost summers, the future we were promised",
+    },
+    "delta-wren": {
+        name: "Delta Wren", genre: "Country",
+        sound: "modern country and Americana, acoustic and electric guitars, pedal steel, fiddle, warm bass, steady backbeat, 80-110 BPM",
+        voice: "clear, twangy female soprano with heart and a little grit",
+        bio: "A porch-light songwriter with a pickup truck full of second chances.",
+        themes: "back roads, hometowns, heartbreak and healing, working hands, Saturday nights",
+    },
+    "ashen-cartography": {
+        name: "Ashen Cartography", genre: "Metal",
+        sound: "melodic metalcore, down-tuned chugging riffs, twin lead guitars, blast beats into half-time breakdowns, cinematic synths, 140-180 BPM",
+        voice: "male vocalist alternating fierce harsh screams in the verses with soaring clean singing in the choruses",
+        bio: "Maps of places that burned down, drawn at full volume.",
+        themes: "ruins, resilience, storms, rebuilding from ashes, defiance",
+    },
+    "lumi-kestrel": {
+        name: "Lumi Kestrel", genre: "Pop",
+        sound: "bright modern dance pop, punchy four-on-the-floor drums, glossy synths, plucky guitar, big pre-chorus lifts, 110-124 BPM",
+        voice: "bright, agile female pop soprano with breathy verses and a powerful chorus",
+        bio: "Glitter on the outside, journal entries on the inside.",
+        themes: "first nights out, confidence, crushes, friendship, dancing it off",
+    },
+};
+export const DEFAULTS = {
+    holder: "Profullstack, Inc.",
+    enabled: true,
+    monthlySeconds: 3600,
+    everyDays: 30,
+    seedAlbums: 2,
+    songsPerAlbum: 8,
+    songSeconds: 150,
+    publish: true,
+};
+const DAY = 86_400_000;
+/** Between tries after a failure: 5 min, doubling, at most 6 h. */
+const BACKOFF_MS = [5 * 60_000, 10 * 60_000, 20 * 60_000, 40 * 60_000, 80 * 60_000, 6 * 3600_000];
+/** A name as a folder or file name: what a filesystem or a zip refuses is dropped. */
+export function fileName(text) {
+    return text.normalize("NFC").replace(/[/\\:*?"<>|\u0000-\u001f\u007f]/g, "").replace(/\s+/g, " ").trim().replace(/^\.+/, "").slice(0, 100).trim() || "Untitled";
+}
+/** A genre's folder and station key: "Hip-Hop" is hip-hop, "R&B" is rnb. */
+export function genreSlug(genre) {
+    return genre.normalize("NFKD").toLowerCase().replace(/&/g, "n").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "music";
+}
+/** "001. Title", the start of a song's file names. */
+export function songBase(song) {
+    return `${String(song.n).padStart(3, "0")}. ${fileName(song.title)}`;
+}
+function clean(value, max) {
+    return String(value ?? "").replace(/[\r\n]+/g, " ").replace(/[\u0000-\u001f]/g, " ").trim().slice(0, max);
+}
+/** Words as a singer gets them: section lines kept, the model's own notes and fences dropped. */
+export function cleanLyrics(text) {
+    return text
+        .replace(/\r\n?/g, "\n")
+        .replace(/^```[a-z]*\n?|```$/gm, "")
+        .split("\n")
+        .map((line) => line.replace(/[\u0000-\u0008\u000b-\u001f]/g, "").trimEnd())
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim()
+        .slice(0, 3000);
+}
+const PLAN_SYSTEM = [
+    "You are the A&R director and lead songwriter of an independent record label whose artists are AI.",
+    "Everything is original: never name, quote or imitate a real artist, band, song, album or label. Write in English.",
+    "Plan one album. Answer as JSON: {\"title\": \"1-6 words\", \"concept\": \"what the album is about, at most 300 characters\",",
+    "\"songs\": [{\"title\": \"1-6 words\", \"style\": \"the production brief for this song, at most 300 characters: tempo in BPM, mood, key or mode, featured instruments, arrangement\"}]}.",
+    "Vary tempo, mood and arrangement across the running order, within the artist's sound; open strong, end memorable.",
+].join(" ");
+const LYRICS_SYSTEM = [
+    "You write original English song lyrics for an AI singer. Never quote or imitate an existing song and never name a real artist.",
+    "Put each section tag on its own line: [Intro], [Verse 1], [Pre-Chorus], [Chorus], [Verse 2], [Bridge], [Outro].",
+    "Use two verses of four lines, a four-line chorus sung two or three times, a pre-chorus of two lines and a bridge of two to four lines; vivid, specific, singable lines that rhyme where it sounds natural. Never just one line under a section.",
+    "Only the words that are sung, no stage directions or notes. Answer as JSON: {\"lyrics\": \"the lyrics, lines separated by \\n\"}.",
+].join(" ");
+export async function planAlbum(artist, songs, ask = askJson) {
+    const before = artist.albums.slice(-4).map((one) => `"${one.title}" (${one.songs.map((song) => song.title).join("; ")})`);
+    const answer = await ask({
+        system: PLAN_SYSTEM,
+        prompt: [
+            `Artist: ${artist.name}`,
+            `Genre: ${artist.genre}`,
+            `Sound: ${artist.sound}`,
+            `Voice: ${artist.voice}`,
+            artist.bio ? `Who they are: ${artist.bio}` : "",
+            artist.themes ? `What they sing about: ${artist.themes}` : "",
+            before.length ? `Albums already out (do not reuse their titles or song titles; take the story somewhere new): ${before.join(" | ")}` : "This is the artist's debut album.",
+            `The album has exactly ${songs} songs.`,
+        ].filter(Boolean).join("\n"),
+        maxTokens: 2048,
+        timeoutMs: 90_000,
+    });
+    const title = clean(answer.value["title"], 80).replace(/"/g, "");
+    const concept = clean(answer.value["concept"], 400);
+    const list = Array.isArray(answer.value["songs"]) ? answer.value["songs"] : [];
+    const seen = new Set();
+    const planned = list
+        .map((one) => ({ title: clean(one?.["title"], 80).replace(/"/g, ""), style: clean(one?.["style"], 400) }))
+        .filter((one) => one.title && one.style && !seen.has(one.title.toLowerCase()) && seen.add(one.title.toLowerCase()))
+        .slice(0, songs);
+    if (!title || planned.length < Math.min(3, songs))
+        throw new Error("the model planned no album (a title and at least three songs)");
+    return { title, concept, songs: planned, model: answer.model };
+}
+export async function writeLyrics(artist, album, song, ask = askJson) {
+    const answer = await ask({
+        system: LYRICS_SYSTEM,
+        prompt: [
+            `Artist: ${artist.name} (${artist.genre}); voice: ${artist.voice}`,
+            artist.themes ? `What they sing about: ${artist.themes}` : "",
+            `Album: "${album.title}"${album.concept ? `: ${album.concept}` : ""}`,
+            `Song: "${song.title}": ${song.style}`,
+            `The song lasts about ${song.seconds} seconds: keep the words under ${Math.max(600, Math.round(song.seconds * 10))} characters.`,
+        ].filter(Boolean).join("\n"),
+        maxTokens: 1500,
+        timeoutMs: 90_000,
+    });
+    const lyrics = cleanLyrics(String(answer.value["lyrics"] ?? ""));
+    if (lyrics.replace(/\[[^\]]*\]/g, "").trim().length < 40)
+        throw new Error("the model wrote no lyrics");
+    return { lyrics, model: answer.model };
+}
+/**
+ * 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 async function workersAiCover(prompt, env = process.env, fetcher = fetch) {
+    const account = /^https:\/\/api\.cloudflare\.com\/client\/v4\/accounts\/([A-Za-z0-9]+)\/ai\/v1\/?$/.exec(aiKey("NIXAMP_OPENAI_URL", env))?.[1];
+    const token = aiKey("OPENAI_API_KEY", env);
+    if (!account || !token)
+        return null;
+    const response = await fetcher(`https://api.cloudflare.com/client/v4/accounts/${account}/ai/run/@cf/black-forest-labs/flux-1-schnell`, {
+        method: "POST",
+        signal: AbortSignal.timeout(120_000),
+        headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+        body: JSON.stringify({ prompt: prompt.slice(0, 2000), steps: 8 }),
+    });
+    if (!response.ok)
+        throw new Error(`the cover model answered HTTP ${response.status}`);
+    const body = await response.json();
+    const image = body.result?.image ? Buffer.from(body.result.image, "base64") : null;
+    if (!image || image.length < 1024)
+        throw new Error("the cover model answered with no picture");
+    return image;
+}
+/** Writes the tags (and the cover, as the attached picture) into a copy of the file. */
+function tagFile(ffmpeg, from, to, tags, cover) {
+    const args = [...ffmpeg.slice(1), "-hide_banner", "-loglevel", "error", "-y", "-i", from];
+    if (cover)
+        args.push("-i", cover, "-map", "0:a", "-map", "1:v", "-c", "copy", "-disposition:v", "attached_pic");
+    else
+        args.push("-map", "0:a", "-c", "copy");
+    args.push("-id3v2_version", "3");
+    for (const [name, value] of Object.entries(tags))
+        args.push("-metadata", `${name}=${value}`);
+    args.push(to);
+    return new Promise((done, fail) => {
+        execFile(ffmpeg[0], args, { timeout: 120_000 }, (error) => (error ? fail(new Error(`tagging failed: ${error.message}`)) : done()));
+    });
+}
+function monthOf(at) {
+    return new Date(at).toISOString().slice(0, 7);
+}
+export class AiLabel {
+    file;
+    deps;
+    artists = new Map();
+    settings = { ...DEFAULTS, pausedReason: "" };
+    usage = {};
+    busy = "";
+    timer = null;
+    constructor(file, deps) {
+        this.file = file;
+        this.deps = deps;
+        try {
+            const parsed = JSON.parse(readFileSync(file, "utf8"));
+            for (const one of parsed.artists ?? [])
+                if (one?.key)
+                    this.artists.set(one.key, { ...one, albums: one.albums ?? [] });
+            this.settings = { ...this.settings, ...(parsed.settings ?? {}) };
+            this.usage = parsed.usage ?? {};
+        }
+        catch {
+            // Nothing yet.
+        }
+    }
+    static fileFor(stateDir, port) {
+        return join(stateDir, `ai-label-${port}.json`);
+    }
+    now() {
+        return this.deps.now?.() ?? Date.now();
+    }
+    log(line) {
+        this.deps.log?.(`  ai label: ${line}`);
+    }
+    save() {
+        mkdirSync(dirname(this.file), { recursive: true });
+        const temporary = `${this.file}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${JSON.stringify({ version: 1, settings: this.settings, usage: this.usage, artists: [...this.artists.values()] }, null, 2)}\n`, { mode: 0o600 });
+        renameSync(temporary, this.file);
+    }
+    composer() {
+        return this.deps.composer ? this.deps.composer() : composerFromEnv();
+    }
+    canAsk() {
+        return (this.deps.canAsk ?? hasModel)();
+    }
+    /** The library source the root is in: the one that already holds it, else a managed one of its own. */
+    source() {
+        const root = resolve(this.deps.root);
+        mkdirSync(root, { recursive: true });
+        const holding = this.deps.index.sources().find((one) => one.enabled && (root === one.root || root.startsWith(one.root + sep)));
+        return (holding ?? this.deps.index.addManagedSource(root)).id;
+    }
+    get root() {
+        return resolve(this.deps.root);
+    }
+    list() {
+        return [...this.artists.values()].sort((a, b) => a.createdAt - b.createdAt);
+    }
+    get(key) {
+        return this.artists.get(key);
+    }
+    holder() {
+        return this.settings.holder;
+    }
+    budgetLeft() {
+        if (this.settings.monthlySeconds === 0)
+            return Number.POSITIVE_INFINITY;
+        return this.settings.monthlySeconds - (this.usage[monthOf(this.now())] ?? 0);
+    }
+    /** When this artist's next album is due: its first ones at once, then every `everyDays`, staggered by artist. */
+    dueAt(artist) {
+        if (!artist.enabled)
+            return -1;
+        if (artist.albums.length < this.settings.seedAlbums)
+            return 0;
+        const last = artist.albums[artist.albums.length - 1];
+        const stagger = (parseInt(artist.key.slice(0, 6), 16) % Math.max(1, Math.floor(this.settings.everyDays / 4))) * DAY;
+        return last.plannedAt + this.settings.everyDays * DAY + stagger;
+    }
+    backingOff(artist, now) {
+        return artist.failures > 0 && now < artist.lastAttemptAt + BACKOFF_MS[Math.min(artist.failures, BACKOFF_MS.length) - 1];
+    }
+    status() {
+        const month = monthOf(this.now());
+        const composer = this.composer();
+        const why = !this.settings.enabled ? "the label is switched off"
+            : this.settings.pausedReason
+                || (composer ? "" : "no composer: set ELEVENLABS_API_KEY (nixamp station ai key ELEVENLABS_API_KEY) or NIXAMP_AI_MUSIC_COMMAND")
+                || (this.canAsk() ? "" : "no language model to write the albums: set GEMINI_API_KEY, OPENAI_API_KEY (or NIXAMP_OPENAI_URL) or ANTHROPIC_API_KEY")
+                || (this.budgetLeft() < this.settings.songSeconds ? `this month's ${this.settings.monthlySeconds} s are used` : "");
+        return {
+            root: this.root,
+            composer: composer?.name ?? null,
+            writer: this.canAsk() ? "language model" : null,
+            busy: this.busy,
+            month,
+            secondsThisMonth: this.usage[month] ?? 0,
+            settings: this.settings,
+            waiting: why,
+            roster: Object.entries(ROSTER).map(([key, one]) => ({ key, name: one.name, genre: one.genre, signed: this.list().some((artist) => artist.name === one.name) })),
+            stations: this.genres().map((genre) => ({ genre, station: this.stationFor(genre)?.id ?? "" })),
+            artists: this.list().map((one) => ({
+                key: one.key, name: one.name, genre: one.genre, enabled: one.enabled, lastError: one.lastError, failures: one.failures,
+                nextAlbumAt: this.dueAt(one),
+                albums: one.albums.map((album) => ({
+                    key: album.key, title: album.title, year: album.year, plannedAt: album.plannedAt, doneAt: album.doneAt,
+                    songs: album.songs.length, composed: album.songs.filter((song) => song.file).length, cover: Boolean(album.cover),
+                })),
+            })),
+        };
+    }
+    configure(input) {
+        const whole = (name, min, max) => {
+            if (input[name] === undefined)
+                return undefined;
+            const value = Number(input[name]);
+            if (!Number.isInteger(value) || value < min || value > max)
+                throw new StationError(`invalid_${name}`, `${name} is a whole number from ${min} to ${max}`);
+            return value;
+        };
+        const monthly = whole("monthlySeconds", 0, 1_000_000);
+        const every = whole("everyDays", 1, 365);
+        const seed = whole("seedAlbums", 0, 10);
+        const songs = whole("songsPerAlbum", 3, 20);
+        const seconds = whole("songSeconds", 30, 300);
+        if (monthly !== undefined)
+            this.settings.monthlySeconds = monthly;
+        if (every !== undefined)
+            this.settings.everyDays = every;
+        if (seed !== undefined)
+            this.settings.seedAlbums = seed;
+        if (songs !== undefined)
+            this.settings.songsPerAlbum = songs;
+        if (seconds !== undefined)
+            this.settings.songSeconds = seconds;
+        if (typeof input["holder"] === "string" && input["holder"].trim())
+            this.settings.holder = clean(input["holder"], 120);
+        if (input["enabled"] !== undefined)
+            this.settings.enabled = input["enabled"] !== false;
+        if (input["publish"] !== undefined)
+            this.settings.publish = input["publish"] !== false;
+        if (input["resume"] === true)
+            this.settings.pausedReason = "";
+        this.save();
+        if (this.settings.enabled)
+            void this.tick();
+        return this.settings;
+    }
+    /** Sign an artist: a preset from the roster, or a name, genre and sound of the owner's own. */
+    sign(input) {
+        const preset = typeof input["preset"] === "string" ? ROSTER[input["preset"]] : undefined;
+        if (input["preset"] !== undefined && !preset)
+            throw new StationError("unknown_preset", `presets: ${Object.keys(ROSTER).join(", ")}`);
+        const name = clean(input["name"] ?? preset?.name, 80);
+        const genre = clean(input["genre"] ?? preset?.genre, 40);
+        const sound = clean(input["sound"] ?? preset?.sound, 600);
+        if (!name)
+            throw new StationError("name_required", "an artist needs a name (or a preset)");
+        if (!genre)
+            throw new StationError("genre_required", "an artist needs a genre");
+        if (sound.length < 10)
+            throw new StationError("sound_required", "describe the music in a few words: instruments, tempo, mood");
+        if (this.list().some((one) => one.name.toLowerCase() === name.toLowerCase()))
+            throw new StationError("already_signed", `${name} is already on the label`, 409);
+        const artist = {
+            key: randomBytes(5).toString("hex"),
+            name, genre, sound,
+            voice: clean(input["voice"] ?? preset?.voice ?? "expressive lead vocal", 300),
+            bio: clean(input["bio"] ?? preset?.bio ?? "", 400),
+            themes: clean(input["themes"] ?? preset?.themes ?? "", 300),
+            enabled: input["enabled"] !== false,
+            albums: [],
+            createdAt: this.now(),
+            lastAttemptAt: 0,
+            lastError: "",
+            failures: 0,
+        };
+        this.artists.set(artist.key, artist);
+        this.save();
+        void this.tick();
+        return artist;
+    }
+    update(key, input) {
+        const artist = this.require(key);
+        for (const [field, max] of [["sound", 600], ["voice", 300], ["bio", 400], ["themes", 300]]) {
+            if (typeof input[field] === "string")
+                artist[field] = clean(input[field], max);
+        }
+        if (input["enabled"] !== undefined)
+            artist.enabled = input["enabled"] !== false;
+        artist.failures = 0;
+        artist.lastError = "";
+        this.save();
+        return artist;
+    }
+    /** Let an artist go. Its music stays (and stays on the air) unless `files` is true. */
+    async drop(key, files = false) {
+        const artist = this.require(key);
+        this.artists.delete(key);
+        this.save();
+        if (files) {
+            rmSync(join(this.root, genreSlug(artist.genre), fileName(artist.name)), { recursive: true, force: true });
+            await this.place(artist.genre);
+        }
+    }
+    /** Plan the next album for this artist now, whatever its schedule; it is composed song by song from here. */
+    async plan(key) {
+        const artist = this.require(key);
+        if (!this.canAsk())
+            throw new StationError("no_writer", "no language model to write the album: set GEMINI_API_KEY, OPENAI_API_KEY (or NIXAMP_OPENAI_URL) or ANTHROPIC_API_KEY", 409);
+        const pending = artist.albums.find((one) => !one.doneAt);
+        if (pending)
+            throw new StationError("album_in_progress", `"${pending.title}" is still being made`, 409);
+        const plan = await planAlbum(artist, this.settings.songsPerAlbum, this.deps.ask ?? askJson);
+        const year = new Date(this.now()).getUTCFullYear();
+        let title = plan.title;
+        if (artist.albums.some((one) => one.title.toLowerCase() === title.toLowerCase()))
+            title = `${title} II`;
+        const album = {
+            key: randomBytes(4).toString("hex"),
+            title,
+            year,
+            concept: plan.concept,
+            folder: join(this.root, genreSlug(artist.genre), fileName(artist.name), `${year}-${fileName(title)}`),
+            cover: "",
+            coverTried: false,
+            songs: plan.songs.map((one, index) => ({ n: index + 1, title: one.title, style: one.style, lyrics: "", seconds: this.settings.songSeconds, file: "", lyricsFile: "", made: "", composedAt: 0 })),
+            writer: plan.model,
+            plannedAt: this.now(),
+            doneAt: 0,
+        };
+        artist.albums.push(album);
+        this.save();
+        this.writeAlbumJson(artist, album);
+        this.log(`${artist.name} has a new album planned: "${album.title}" (${album.songs.length} songs)`);
+        return album;
+    }
+    startSchedule(everyMs = 5 * 60_000) {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => void this.tick(), everyMs);
+        this.timer.unref?.();
+        void this.tick();
+    }
+    stopSchedule() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    /** Everything that is due, one song at a time, until nothing is or something stops it. */
+    async tick(limit = 200) {
+        if (this.busy || !this.settings.enabled || this.settings.pausedReason)
+            return;
+        this.busy = "starting";
+        try {
+            for (let steps = 0; steps < limit; steps++) {
+                if (this.settings.pausedReason)
+                    break;
+                if ((await this.step().catch(() => "idle")) === "idle")
+                    break;
+            }
+        }
+        finally {
+            this.busy = "";
+        }
+    }
+    async step() {
+        const now = this.now();
+        const composer = this.composer();
+        if (!composer)
+            return "idle";
+        // A song of an album already planned, oldest album first.
+        const making = this.list()
+            .filter((one) => one.enabled && !this.backingOff(one, now))
+            .flatMap((artist) => artist.albums.filter((album) => !album.doneAt).map((album) => ({ artist, album })))
+            .sort((a, b) => a.album.plannedAt - b.album.plannedAt);
+        for (const { artist, album } of making) {
+            const song = album.songs.find((one) => !one.file);
+            if (!song) {
+                album.doneAt = now;
+                this.save();
+                continue;
+            }
+            if (song.seconds > this.budgetLeft())
+                return "idle";
+            await this.compose(artist, album, song, composer);
+            return "composed";
+        }
+        // Nothing half-made anywhere: the artist most overdue gets its next album.
+        if (this.list().some((one) => one.albums.some((album) => !album.doneAt)))
+            return "idle";
+        if (!this.canAsk() || this.settings.songSeconds > this.budgetLeft())
+            return "idle";
+        const due = this.list()
+            .filter((one) => !this.backingOff(one, now))
+            .map((one) => ({ one, at: this.dueAt(one) }))
+            .filter(({ at }) => at !== -1 && at <= now)
+            .sort((a, b) => a.one.albums.length - b.one.albums.length || a.at - b.at)[0];
+        if (!due)
+            return "idle";
+        try {
+            await this.plan(due.one.key);
+            due.one.failures = 0;
+            due.one.lastError = "";
+            this.save();
+            return "planned";
+        }
+        catch (error) {
+            this.failed(due.one, error);
+            throw error;
+        }
+    }
+    failed(artist, error) {
+        artist.lastAttemptAt = this.now();
+        artist.failures += 1;
+        artist.lastError = error.message;
+        if (error instanceof OutOfCredit)
+            this.settings.pausedReason = `${artist.lastError}; resume with \`nixamp station label resume\` once there is credit`;
+        this.save();
+        this.log(`${artist.name}: ${artist.lastError}`);
+    }
+    async compose(artist, album, song, composer) {
+        this.busy = `${artist.name}: ${album.title}: ${song.title}`;
+        artist.lastAttemptAt = this.now();
+        mkdirSync(album.folder, { recursive: true });
+        const raw = join(album.folder, `.${randomBytes(4).toString("hex")}.raw.mp3`);
+        try {
+            let writer = song.made || album.writer;
+            if (!song.lyrics) {
+                const written = await writeLyrics(artist, album, song, this.deps.ask ?? askJson);
+                song.lyrics = written.lyrics;
+                writer = written.model;
+                song.made = writer;
+                this.save();
+            }
+            await this.ensureCover(artist, album);
+            this.log(`composing "${song.title}" (${artist.name}, ${album.title}, ${song.seconds} s, ${composer.name})`);
+            const prompt = `${artist.sound}. ${song.style}. Lead vocal: ${artist.voice}. Sung in English.`.slice(0, 1500);
+            await composer.compose({ prompt, seconds: song.seconds, vocals: true, out: raw, lyrics: song.lyrics });
+            const month = monthOf(this.now());
+            this.usage[month] = (this.usage[month] ?? 0) + song.seconds;
+            const base = songBase(song);
+            const file = join(album.folder, `${base}.mp3`);
+            const lyricsFile = join(album.folder, `${base}.lyrics.txt`);
+            writeFileSync(lyricsFile, `${song.lyrics}\n`);
+            const holder = this.settings.holder;
+            const tags = {
+                title: song.title,
+                artist: artist.name,
+                album_artist: artist.name,
+                album: album.title,
+                genre: artist.genre,
+                track: `${song.n}/${album.songs.length}`,
+                date: String(album.year),
+                publisher: holder,
+                copyright: `℗ ${album.year} ${holder}`,
+                comment: `Made with AI for ${holder}: music by ${composer.name}, words by ${writer}`,
+                "lyrics-eng": song.lyrics,
+            };
+            await (this.deps.tag ?? ((from, to, values, cover) => tagFile(this.deps.ffmpeg, from, to, values, cover)))(raw, file, tags, album.cover);
+            song.file = file;
+            song.lyricsFile = lyricsFile;
+            song.made = `${writer} + ${composer.name}`;
+            song.composedAt = this.now();
+            artist.failures = 0;
+            artist.lastError = "";
+            if (album.songs.every((one) => one.file)) {
+                album.doneAt = this.now();
+                this.log(`${artist.name} released "${album.title}"`);
+            }
+            this.save();
+            this.writeAlbumJson(artist, album);
+            await this.place(artist.genre);
+        }
+        catch (error) {
+            this.failed(artist, error);
+            throw error;
+        }
+        finally {
+            rmSync(raw, { force: true });
+            this.busy = "starting";
+        }
+    }
+    async ensureCover(artist, album) {
+        if (album.cover || album.coverTried)
+            return;
+        album.coverTried = true;
+        const prompt = `Album cover art for "${album.title}", a ${artist.genre} album by ${artist.name}. ${album.concept} Style: ${artist.sound}. Striking, original, square composition. No text, no letters, no logos, no watermark.`;
+        try {
+            const picture = await (this.deps.cover ?? ((text) => workersAiCover(text)))(prompt);
+            if (picture) {
+                const file = join(album.folder, "cover.jpg");
+                writeFileSync(file, picture);
+                album.cover = file;
+            }
+        }
+        catch (error) {
+            this.log(`no cover for "${album.title}": ${error.message}`);
+        }
+        this.save();
+    }
+    /** album.json beside the songs: what the album is, for anybody who copies the folder. */
+    writeAlbumJson(artist, album) {
+        try {
+            mkdirSync(album.folder, { recursive: true });
+            writeFileSync(join(album.folder, "album.json"), `${JSON.stringify({
+                artist: artist.name, genre: artist.genre, album: album.title, year: album.year, concept: album.concept,
+                label: this.settings.holder, copyright: `℗ ${album.year} ${this.settings.holder}`, madeWithAi: true,
+                songs: album.songs.map((one) => ({ n: one.n, title: one.title, seconds: one.seconds, file: one.file ? `${songBase(one)}.mp3` : null, lyrics: one.file ? `${songBase(one)}.lyrics.txt` : null })),
+            }, null, 2)}\n`);
+        }
+        catch {
+            // The folder may be read-only; the state file still has it all.
+        }
+    }
+    genres() {
+        return [...new Set(this.list().map((one) => one.genre))].sort();
+    }
+    stationFor(genre) {
+        return this.deps.store.byAuto(`ai:label:${genreSlug(genre)}`);
+    }
+    /** The genre's station gets every song of that genre: made with the first, then kept in step. */
+    async place(genre) {
+        await this.deps.index.scan(this.source(), this.deps.probe).done;
+        const artists = this.list().filter((one) => genreSlug(one.genre) === genreSlug(genre));
+        const files = artists
+            .flatMap((one) => one.albums.flatMap((album) => album.songs.map((song) => song.file)))
+            .filter((file) => file && this.deps.index.itemAt(file)?.state === "ready");
+        const existing = this.stationFor(genre);
+        if (existing) {
+            if (files.length > 0)
+                this.deps.store.update(existing.id, {}, files);
+            return;
+        }
+        if (files.length === 0)
+            return;
+        const holder = this.settings.holder;
+        const label = holder.replace(/,?\s+(inc|llc|ltd|gmbh|co)\.?$/i, "");
+        const made = this.deps.store.create({
+            name: `${label} AI · ${genre}`,
+            description: `Original ${genre} by ${label}'s AI artists: ${artists.map((one) => one.name).join(", ")}.`,
+            shuffle: true,
+            repeat: true,
+            bitrate: 192,
+        }, files, this.deps.owner);
+        this.deps.store.markAuto(made.id, `ai:label:${genreSlug(genre)}`);
+        if (this.settings.publish) {
+            this.deps.store.setAccess(made.id, {
+                visibility: "public",
+                listed: true,
+                rights: { basis: "owned", note: `Original music by ${holder}'s AI artists, composed for ${holder} by AI (${this.composer()?.name ?? "a music model"}) from words written by AI; no third-party recordings. ℗ ${holder}.` },
+            }, this.deps.owner || "ai-label");
+        }
+        else {
+            this.deps.store.setAccess(made.id, { visibility: "unlisted" }, this.deps.owner || "ai-label");
+        }
+        if (this.deps.mayStart())
+            await this.deps.runner.start(made.id).catch(() => undefined);
+    }
+    /** The catalogue anybody may see: artists, their released songs, the words, and where each genre plays. */
+    publicView() {
+        const genres = this.genres().map((genre) => ({
+            genre,
+            station: this.stationFor(genre)?.id ?? "",
+            artists: this.list()
+                .filter((one) => one.genre === genre)
+                .map((one) => ({
+                key: one.key, name: one.name, genre: one.genre, bio: one.bio,
+                albums: one.albums
+                    .filter((album) => album.songs.some((song) => song.file))
+                    .map((album) => ({
+                    key: album.key, title: album.title, year: album.year, concept: album.concept, cover: Boolean(album.cover), complete: album.doneAt > 0,
+                    songs: album.songs.filter((song) => song.file).map((song) => ({ n: song.n, title: song.title, seconds: song.seconds, lyrics: song.lyrics })),
+                }))
+                    .reverse(),
+            }))
+                .filter((one) => one.albums.length > 0),
+        })).filter((one) => one.artists.length > 0);
+        return { holder: this.settings.holder, genres };
+    }
+    /** A released file anybody may fetch: a song, its words, or its album's cover. */
+    publicFile(artistKey, albumKey, what) {
+        const album = this.artists.get(artistKey)?.albums.find((one) => one.key === albumKey);
+        if (!album)
+            return null;
+        if (what === "cover.jpg")
+            return album.cover ? { path: album.cover, type: "image/jpeg" } : null;
+        const match = /^(\d{1,3})\.(mp3|txt)$/.exec(what);
+        const song = match ? album.songs.find((one) => one.n === Number(match[1]) && one.file) : undefined;
+        if (!song)
+            return null;
+        return match[2] === "mp3" ? { path: song.file, type: "audio/mpeg" } : { path: song.lyricsFile, type: "text/plain; charset=utf-8" };
+    }
+    /** The label song at this path, for the now-playing card's Download buttons. */
+    songAt(file) {
+        for (const artist of this.artists.values()) {
+            for (const album of artist.albums) {
+                const song = album.songs.find((one) => one.file === file);
+                if (song)
+                    return { artist: artist.key, album: album.key, n: song.n, title: song.title, artistName: artist.name, albumTitle: album.title };
+            }
+        }
+        return null;
+    }
+    /** A released song's MP3, when this grant's scope covers it. */
+    songFile(artistKey, albumKey, n) {
+        return this.artists.get(artistKey)?.albums.find((one) => one.key === albumKey)?.songs.find((one) => one.n === n && one.file)?.file ?? "";
+    }
+    /**
+     * What a purchase's zip holds: every released song in scope with its words,
+     * and each album's cover and album.json, under <artist>/<year>-<album>/.
+     * Null when there is nothing (or no such artist).
+     */
+    zipFor(scope) {
+        const artist = this.artists.get(scope.artist);
+        if (!artist)
+            return null;
+        const albums = artist.albums.filter((one) => scope.kind === "artist" || one.key === scope.album);
+        const entries = [];
+        const top = fileName(artist.name);
+        for (const album of albums) {
+            const songs = album.songs.filter((one) => one.file && (scope.kind !== "song" || one.n === scope.n));
+            if (songs.length === 0)
+                continue;
+            const folder = `${top}/${album.year}-${fileName(album.title)}`;
+            for (const song of songs) {
+                entries.push({ name: `${folder}/${songBase(song)}.mp3`, path: song.file });
+                entries.push({ name: `${folder}/${songBase(song)}.lyrics.txt`, bytes: Buffer.from(`${song.lyrics}\n`) });
+            }
+            if (album.cover)
+                entries.push({ name: `${folder}/cover.jpg`, path: album.cover });
+            entries.push({ name: `${folder}/album.json`, bytes: Buffer.from(`${JSON.stringify({
+                    artist: artist.name, genre: artist.genre, album: album.title, year: album.year, concept: album.concept,
+                    label: this.settings.holder, copyright: `℗ ${album.year} ${this.settings.holder}`, madeWithAi: true,
+                    songs: songs.map((one) => ({ n: one.n, title: one.title, seconds: one.seconds, file: `${songBase(one)}.mp3`, lyrics: `${songBase(one)}.lyrics.txt` })),
+                }, null, 2)}\n`) });
+        }
+        if (entries.length === 0)
+            return null;
+        const what = scope.kind === "artist" ? "Discography" : scope.kind === "album" ? albums[0].title : this.songFile(scope.artist, scope.album, scope.n) ? albums[0].songs.find((one) => one.n === scope.n).title : "Song";
+        return { name: `${fileName(artist.name)} - ${fileName(what)}.zip`, entries };
+    }
+    require(key) {
+        const artist = this.artists.get(key);
+        if (!artist)
+            throw new StationError("not_found", "no such artist on the label", 404);
+        return artist;
+    }
+}