nixamp 0.51.0 → 0.52.0

package/dist/ai-label.js

@@ -75,12 +75,103 @@ export const ROSTER = {
         themes: "ruins, resilience, storms, rebuilding from ashes, defiance",
     },
     "iron-lantern-society": {
-        name: "Iron Lantern Society", genre: "Rock",
+        name: "Iron Lantern Society", genre: "Classic Rock",
         sound: "bluesy classic hard rock, swaggering riffs, Hammond organ, cowbell grooves, big guitar solos, 100-128 BPM",
         voice: "gravelly male baritone with a wide rasp and a rock-and-roll howl",
         bio: "Five road dogs who think every song should end in a bar fight or a sunrise.",
         themes: "the open road, hard luck, loyalty among misfits, last calls and new starts",
     },
+    "highway-sermon": {
+        name: "Highway Sermon", genre: "Classic Rock",
+        sound: "1970s classic rock, twin harmony lead guitars, warm analog bass, piano, big open drums, arena choruses, 96-124 BPM",
+        voice: "soaring, slightly raspy male tenor with a wide vibrato",
+        bio: "Four friends who found a crate of their fathers' records and never gave them back.",
+        themes: "freedom, the open highway, small-town legends, love and leaving",
+    },
+    "copper-jubilee": {
+        name: "Copper Jubilee", genre: "Classic Rock",
+        sound: "southern classic rock, slide guitar, honky-tonk piano, Hammond organ, swampy groove, gospel backing vocals, 88-116 BPM",
+        voice: "powerful bluesy female belter with grit and gospel runs",
+        bio: "A riverboat revue that plugged in and turned it up.",
+        themes: "rivers, revival nights, rebellion, home cooking and heartbreak",
+    },
+    "the-bent-spokes": {
+        name: "The Bent Spokes", genre: "Punk",
+        sound: "fast melodic skate punk, palm-muted power chords, driving eighth-note bass, snappy double-time drums, gang vocal choruses, 180-210 BPM",
+        voice: "snotty, energetic male tenor with shouted group backing vocals",
+        bio: "Three teenagers who never stopped being teenagers, and a drummer who might be a skateboard.",
+        themes: "boredom, suburbia, friendship, skipping school, refusing to grow up",
+    },
+    "gutter-velvet": {
+        name: "Gutter Velvet", genre: "Punk",
+        sound: "raw street punk, distorted buzzsaw guitars, thumping bass, stomping drums, chant-along choruses, 160-190 BPM",
+        voice: "furious, raspy female shouter with a sneer",
+        bio: "Born in a squat, raised on a photocopier.",
+        themes: "rent, landlords, solidarity, the city at 3 a.m., not backing down",
+    },
+    "no-refunds": {
+        name: "No Refunds", genre: "Punk",
+        sound: "pop punk, bright crunchy guitars, bouncy bass, big singalong hooks, half-time bridges, 160-185 BPM",
+        voice: "catchy, slightly nasal male lead with harmonized choruses",
+        bio: "Mall-parking-lot punk with a heart of gold and a dented van.",
+        themes: "crushes, bad jobs, summer, best friends, second chances",
+    },
+    "muddy-ledger": {
+        name: "Muddy Ledger", genre: "Blues",
+        sound: "electric Chicago blues, stinging lead guitar, harmonica, walking bass, shuffle drums, slow 12-bar and mid-tempo shuffles, 60-110 BPM",
+        voice: "deep, gravelly male baritone with call-and-response guitar",
+        bio: "Plays like he owes the guitar money.",
+        themes: "hard times, trains, lost love, payday, getting even",
+    },
+    "delta-ruby": {
+        name: "Delta Ruby", genre: "Blues",
+        sound: "soulful blues, Hammond organ, horn section, slow-burning guitar, brushed and backbeat drums, 60-100 BPM",
+        voice: "rich, powerful female contralto with soaring gospel-blues phrasing",
+        bio: "A juke-joint queen with a voice that rattles the windows.",
+        themes: "heartbreak, strength, the river, Saturday night, survival",
+    },
+    "rattlesnake-porch": {
+        name: "Rattlesnake Porch", genre: "Blues",
+        sound: "acoustic delta blues, slide resonator guitar, foot stomps, harmonica, hand claps, 70-110 BPM",
+        voice: "weathered male voice, half-sung, half-spoken storytelling",
+        bio: "A porch, a slide and a hundred stories, all of them true enough.",
+        themes: "crossroads, floods, the devil's bargains, home, honest work",
+    },
+    "blue-hour-quartet": {
+        name: "The Blue Hour Quartet", genre: "Jazz",
+        sound: "smoky vocal jazz, upright bass, brushed drums, piano trio comping, muted trumpet solos, swing and ballads, 70-140 BPM",
+        voice: "velvety female jazz alto with relaxed phrasing and occasional scat",
+        bio: "A jazz club that only opens after the last train leaves.",
+        themes: "late nights, rain on windows, old flames, city lights, small joys",
+    },
+    "sterling-hayes": {
+        name: "Sterling Hayes", genre: "Jazz",
+        sound: "big band swing and crooner jazz, brass section, walking bass, swing drums, lush strings on ballads, 100-180 BPM",
+        voice: "smooth, warm male crooner baritone",
+        bio: "A crooner who never got the memo that it isn't 1958.",
+        themes: "romance, dancing, champagne nights, wistful goodbyes",
+    },
+    "nightcap-collective": {
+        name: "Nightcap Collective", genre: "Jazz",
+        sound: "modern soul-jazz, Rhodes piano, tenor sax, laid-back hip hop influenced drums, warm bass, 80-100 BPM",
+        voice: "silky male and female duet vocals trading verses",
+        bio: "A rotating cast of night owls who meet at the same bar every Thursday.",
+        themes: "slow evenings, conversation, love that takes its time, the city after dark",
+    },
+    "satin-avenue": {
+        name: "Satin Avenue", genre: "R&B",
+        sound: "smooth modern R&B, lush chords, deep 808s, crisp snaps, warm synth pads, falsetto ad-libs, 65-90 BPM",
+        voice: "silky female R&B soprano with agile runs",
+        bio: "Late-night R&B for the drive home after a long week.",
+        themes: "love, trust, self-worth, late-night phone calls",
+    },
+    "jalen-reign": {
+        name: "Jalen Reign", genre: "R&B",
+        sound: "neo-soul and contemporary R&B, live bass, Rhodes, tight pocket drums, gospel-tinged harmonies, 70-95 BPM",
+        voice: "warm, soulful male tenor with a smooth falsetto",
+        bio: "Church-raised, club-tested, heart on his sleeve.",
+        themes: "devotion, apologies, growing together, Sunday mornings",
+    },
     "paper-satellites": {
         name: "Paper Satellites", genre: "Rock",
         sound: "jangly indie rock, chorus-drenched guitars, driving eighth-note bass, crisp drums, shout-along choruses, 130-160 BPM",
@@ -171,10 +262,15 @@ export const DEFAULTS = {
     enabled: true,
     monthlySeconds: 3600,
     everyDays: 30,
+    albumsPerDay: 1,
+    newArtistChance: 0.25,
     seedAlbums: 1,
     songsPerAlbum: 8,
     songSeconds: 150,
     publish: true,
+    videos: true,
+    parallel: 1,
+    genreOrder: ["Punk", "Blues", "Country", "Jazz", "Classic Rock", "Metal", "Hip-Hop", "Pop", "R&B"],
 };
 const DAY = 86_400_000;
 /** Between tries after a failure: 5 min, doubling, at most 6 h. */
@@ -248,6 +344,28 @@ export async function planAlbum(artist, songs, ask = askJson) {
         throw new Error("the model planned no album (a title and at least three songs)");
     return { title, concept, songs: planned, model: answer.model };
 }
+const ARTIST_SYSTEM = [
+    "You invent original recording artists for an independent record label whose artists are AI and sing in English.",
+    "The name must be new: never a real artist, band or label, and never imitating one.",
+    "Answer as JSON: {\"name\": \"1-4 words\", \"sound\": \"the music in words, at most 300 characters: subgenre, instruments, production, tempo in BPM\",",
+    "\"voice\": \"the lead voice, at most 150 characters\", \"bio\": \"one striking sentence\", \"themes\": \"what they sing about, at most 150 characters\"}.",
+].join(" ");
+/** A new artist for this genre, unlike the ones already signed. */
+export async function inventArtist(genre, taken, ask = askJson) {
+    const answer = await ask({
+        system: ARTIST_SYSTEM,
+        prompt: `Genre: ${genre}\nAlready on the label (do not reuse or echo these names or sounds): ${taken.slice(-40).join(", ") || "nobody yet"}`,
+        maxTokens: 600,
+        timeoutMs: 60_000,
+    });
+    const name = clean(answer.value["name"], 60).replace(/"/g, "");
+    const sound = clean(answer.value["sound"], 400);
+    if (!name || sound.length < 10)
+        throw new Error("the model invented no artist");
+    if (taken.some((one) => one.toLowerCase() === name.toLowerCase()))
+        throw new Error(`the model reused the name ${name}`);
+    return { name, genre, sound, voice: clean(answer.value["voice"], 200) || "expressive lead vocal", bio: clean(answer.value["bio"], 300), themes: clean(answer.value["themes"], 200) };
+}
 export async function writeLyrics(artist, album, song, ask = askJson) {
     const answer = await ask({
         system: LYRICS_SYSTEM,
@@ -291,6 +409,26 @@ export async function workersAiCover(prompt, env = process.env, fetcher = fetch)
     return image;
 }
 /** 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 function renderVideo(ffmpeg, audio, cover, out) {
+    const picture = cover ? ["-loop", "1", "-framerate", "25", "-i", cover] : ["-f", "lavfi", "-i", "color=c=0x0d1410:s=1280x720:r=25"];
+    const graph = [
+        "[0:v]scale=1280:720:force_original_aspect_ratio=increase,crop=1280:720,boxblur=24:2,eq=brightness=-0.18[bg]",
+        "[0:v]scale=500:500[fg]",
+        "[1:a]showwaves=s=1280x150:mode=cline:rate=25:colors=white@0.85,format=rgba,colorkey=0x000000:0.1:0[viz]",
+        "[bg][fg]overlay=(W-w)/2:40[a]",
+        "[a][viz]overlay=0:H-160,format=yuv420p[v]",
+    ].join(";");
+    const args = [...ffmpeg.slice(1), "-hide_banner", "-loglevel", "error", "-y", ...picture, "-i", audio, "-filter_complex", graph,
+        "-map", "[v]", "-map", "1:a", "-c:v", "libx264", "-preset", "veryfast", "-crf", "26", "-r", "25", "-c:a", "copy", "-shortest", "-movflags", "+faststart", out];
+    return new Promise((done, fail) => {
+        execFile(ffmpeg[0], args, { timeout: 20 * 60_000 }, (error) => (error ? fail(new Error(`the video failed: ${error.message}`)) : done()));
+    });
+}
 function tagFile(ffmpeg, from, to, tags, cover) {
     const args = [...ffmpeg.slice(1), "-hide_banner", "-loglevel", "error", "-y", "-i", from];
     if (cover)
@@ -314,7 +452,19 @@ export class AiLabel {
     artists = new Map();
     settings = { ...DEFAULTS, pausedReason: "" };
     usage = {};
-    busy = "";
+    running = false;
+    /** Songs being made now, by `<album>:<n>`. */
+    claims = new Map();
+    /** Artists whose next album is being planned now. */
+    planning = new Set();
+    covering = new Map();
+    filming = null;
+    /** Songs whose video failed since this server started. */
+    videoFailed = new Set();
+    /** The day's album is tried at most every 30 minutes, so a failing model is not hammered. */
+    dailyTriedAt = 0;
+    /** Genre stations are kept in step one change at a time. */
+    placing = Promise.resolve();
     timer = null;
     constructor(file, deps) {
         this.file = file;
@@ -382,6 +532,9 @@ export class AiLabel {
             return -1;
         if (artist.albums.length < this.settings.seedAlbums)
             return 0;
+        // On the daily schedule an artist's next album is whenever the day's pick lands on it.
+        if (this.settings.albumsPerDay > 0)
+            return -1;
         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;
@@ -401,7 +554,8 @@ export class AiLabel {
             root: this.root,
             composer: composer?.name ?? null,
             writer: this.canAsk() ? "language model" : null,
-            busy: this.busy,
+            busy: this.running ? ([...this.claims.values()].map((one) => one.label).join("; ") || "planning") : "",
+            recording: [...this.claims.values()].map((one) => one.label),
             month,
             secondsThisMonth: this.usage[month] ?? 0,
             settings: this.settings,
@@ -448,6 +602,24 @@ export class AiLabel {
             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;
+        const perDay = whole("albumsPerDay", 0, 24);
+        if (perDay !== undefined)
+            this.settings.albumsPerDay = perDay;
+        if (input["newArtistChance"] !== undefined) {
+            const chance = Number(input["newArtistChance"]);
+            if (!Number.isFinite(chance) || chance < 0 || chance > 1)
+                throw new StationError("invalid_newArtistChance", "newArtistChance is from 0 to 1");
+            this.settings.newArtistChance = chance;
+        }
+        const parallel = whole("parallel", 1, 8);
+        if (parallel !== undefined)
+            this.settings.parallel = parallel;
+        if (input["genreOrder"] !== undefined) {
+            const list = Array.isArray(input["genreOrder"]) ? input["genreOrder"] : String(input["genreOrder"]).split(",");
+            this.settings.genreOrder = list.map((one) => clean(one, 40)).filter(Boolean).slice(0, 30);
+        }
         if (input["resume"] === true)
             this.settings.pausedReason = "";
         this.save();
@@ -547,66 +719,174 @@ export class AiLabel {
     startSchedule(everyMs = 5 * 60_000) {
         if (this.timer)
             return;
-        this.timer = setInterval(() => void this.tick(), everyMs);
+        this.timer = setInterval(() => { void this.tick(); void this.videos(); }, everyMs);
         this.timer.unref?.();
         void this.tick();
+        void this.videos();
+    }
+    /**
+     * 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() {
+        if (!this.settings.videos)
+            return Promise.resolve(0);
+        // One run at a time; asking during one waits for it.
+        this.filming ??= this.film().finally(() => { this.filming = null; });
+        return this.filming;
+    }
+    async film() {
+        let total = 0;
+        // Songs that land while videos are being made are picked up by the next pass.
+        for (let made = await this.filmPass(); made > 0; made = await this.filmPass())
+            total += made;
+        return total;
+    }
+    async filmPass() {
+        let made = 0;
+        {
+            for (const artist of this.list()) {
+                for (const album of artist.albums) {
+                    if (!album.cover && !album.coverTried)
+                        continue;
+                    for (const song of album.songs) {
+                        if (!song.file || song.video || this.videoFailed.has(song.file) || !this.settings.videos)
+                            continue;
+                        const out = join(album.folder, `${songBase(song)}.mp4`);
+                        const partial = join(album.folder, `.${randomBytes(4).toString("hex")}.video.mp4`);
+                        try {
+                            await (this.deps.video ?? ((audio, cover, to) => renderVideo(this.deps.ffmpeg, audio, cover, to)))(song.file, album.cover, partial);
+                            renameSync(partial, out);
+                            song.video = out;
+                            made += 1;
+                            this.save();
+                        }
+                        catch (error) {
+                            this.videoFailed.add(song.file);
+                            this.log(`no video for "${song.title}": ${error.message}`);
+                        }
+                        finally {
+                            rmSync(partial, { force: true });
+                        }
+                    }
+                }
+            }
+            if (made > 0)
+                await this.placeVideos();
+        }
+        return made;
+    }
+    /** The label's music videos as one TV station: free to watch, with its breaks. */
+    placeVideos() {
+        const next = this.placing.then(async () => {
+            await this.deps.index.scan(this.source(), this.deps.probe).done;
+            const files = this.list()
+                .flatMap((artist) => artist.albums.flatMap((album) => album.songs.map((song) => song.video ?? "")))
+                .filter((file) => file && this.deps.index.itemAt(file)?.state === "ready");
+            if (files.length === 0)
+                return;
+            const existing = this.deps.store.byAuto("ai:label:videos");
+            if (existing) {
+                this.deps.store.update(existing.id, {}, files);
+                return;
+            }
+            const label = this.settings.holder.replace(/,?\s+(inc|llc|ltd|gmbh|co)\.?$/i, "");
+            const made = this.deps.store.create({ name: `${label} AI · Music Videos`, description: `Music videos by ${label}'s AI artists, every genre.`, shuffle: true, repeat: true, video: true }, files, this.deps.owner);
+            this.deps.store.markAuto(made.id, "ai:label:videos");
+            if (this.settings.publish) {
+                this.deps.store.setAccess(made.id, {
+                    visibility: "public",
+                    listed: true,
+                    rights: { basis: "owned", note: `Music videos made for ${this.settings.holder} from its AI artists' songs and covers; no third-party material. ℗ ${this.settings.holder}.` },
+                }, this.deps.owner || "ai-label");
+            }
+            if (this.deps.mayStart())
+                await this.deps.runner.start(made.id).catch(() => undefined);
+        });
+        this.placing = next.catch(() => undefined);
+        return next;
     }
     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. */
+    /**
+     * 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.
+     */
     async tick(limit = 200) {
-        if (this.busy || !this.settings.enabled || this.settings.pausedReason)
+        if (this.running || !this.settings.enabled || this.settings.pausedReason)
             return;
-        this.busy = "starting";
-        try {
-            for (let steps = 0; steps < limit; steps++) {
-                if (this.settings.pausedReason)
-                    break;
+        this.running = true;
+        let steps = 0;
+        const worker = async () => {
+            while (steps < limit && !this.settings.pausedReason) {
+                steps += 1;
                 if ((await this.step().catch(() => "idle")) === "idle")
-                    break;
+                    return;
             }
+        };
+        try {
+            await Promise.all(Array.from({ length: Math.max(1, this.settings.parallel) }, worker));
         }
         finally {
-            this.busy = "";
+            this.running = false;
         }
     }
+    /** Where the artist's genre comes in the owner's order (genreOrder); unlisted genres after. */
+    rank(genre) {
+        const at = this.settings.genreOrder.findIndex((one) => genreSlug(one) === genreSlug(genre));
+        return at === -1 ? this.settings.genreOrder.length : at;
+    }
     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 claimedSeconds = [...this.claims.values()].reduce((sum, one) => sum + one.seconds, 0);
+        // A song of an album already planned that nobody is making, 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) {
+            if (album.songs.every((one) => one.file)) {
                 album.doneAt = now;
                 this.save();
                 continue;
             }
-            if (song.seconds > this.budgetLeft())
+            const song = album.songs.find((one) => !one.file && !this.claims.has(`${album.key}:${one.n}`));
+            if (!song)
+                continue;
+            if (song.seconds + claimedSeconds > this.budgetLeft())
                 return "idle";
-            await this.compose(artist, album, song, composer);
+            const claim = `${album.key}:${song.n}`;
+            this.claims.set(claim, { label: `${artist.name}: ${album.title}: ${song.title}`, seconds: song.seconds });
+            try {
+                await this.compose(artist, album, song, composer);
+            }
+            finally {
+                this.claims.delete(claim);
+            }
             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)))
+        // Room for another album: the artist most overdue (in the owner's genre order) gets its next one.
+        const inProgress = this.list().filter((one) => one.albums.some((album) => !album.doneAt)).length + this.planning.size;
+        if (inProgress >= Math.max(1, this.settings.parallel))
             return "idle";
-        if (!this.canAsk() || this.settings.songSeconds > this.budgetLeft())
+        if (!this.canAsk() || this.settings.songSeconds + claimedSeconds > this.budgetLeft())
             return "idle";
         const due = this.list()
-            .filter((one) => !this.backingOff(one, now))
+            .filter((one) => !this.backingOff(one, now) && !this.planning.has(one.key) && !one.albums.some((album) => !album.doneAt))
             .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];
+            .sort((a, b) => a.one.albums.length - b.one.albums.length || this.rank(a.one.genre) - this.rank(b.one.genre) || a.at - b.at)[0];
         if (!due)
-            return "idle";
+            return this.daily(now);
+        this.planning.add(due.one.key);
         try {
             await this.plan(due.one.key);
             due.one.failures = 0;
@@ -618,6 +898,59 @@ export class AiLabel {
             this.failed(due.one, error);
             throw error;
         }
+        finally {
+            this.planning.delete(due.one.key);
+        }
+    }
+    /**
+     * 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.
+     */
+    async daily(now) {
+        const perDay = this.settings.albumsPerDay;
+        if (perDay <= 0)
+            return "idle";
+        const enabled = this.list().filter((one) => one.enabled);
+        if (enabled.some((one) => one.albums.length < this.settings.seedAlbums))
+            return "idle";
+        const last = Math.max(0, ...this.list().flatMap((one) => one.albums.map((album) => album.plannedAt)));
+        if (now < last + Math.floor(DAY / perDay) || now < this.dailyTriedAt + 30 * 60_000)
+            return "idle";
+        this.dailyTriedAt = now;
+        const random = this.deps.random ?? Math.random;
+        const genres = this.settings.genreOrder.length ? this.settings.genreOrder : [...new Set(enabled.map((one) => one.genre))];
+        let artist;
+        if ((enabled.length === 0 || random() < this.settings.newArtistChance) && genres.length > 0) {
+            const genre = genres[Math.floor(random() * genres.length)];
+            try {
+                const invented = await inventArtist(genre, this.list().map((one) => one.name), this.deps.ask ?? askJson);
+                artist = this.sign({ ...invented });
+                this.log(`signed a new artist: ${artist.name} (${genre})`);
+            }
+            catch (error) {
+                this.log(`could not invent a ${genre} artist (${error.message}); an artist already signed gets the album`);
+            }
+        }
+        if (!artist) {
+            const free = enabled.filter((one) => !this.backingOff(one, now) && !this.planning.has(one.key) && !one.albums.some((album) => !album.doneAt));
+            artist = free[Math.floor(random() * free.length)];
+        }
+        if (!artist)
+            return "idle";
+        this.planning.add(artist.key);
+        try {
+            await this.plan(artist.key);
+            return "planned";
+        }
+        catch (error) {
+            this.failed(artist, error);
+            throw error;
+        }
+        finally {
+            this.planning.delete(artist.key);
+        }
     }
     failed(artist, error) {
         artist.lastAttemptAt = this.now();
@@ -629,7 +962,6 @@ export class AiLabel {
         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`);
@@ -680,6 +1012,8 @@ export class AiLabel {
             this.save();
             this.writeAlbumJson(artist, album);
             await this.place(artist.genre);
+            // Its video is made beside it, without holding up the next song.
+            void this.videos();
         }
         catch (error) {
             this.failed(artist, error);
@@ -687,13 +1021,18 @@ export class AiLabel {
         }
         finally {
             rmSync(raw, { force: true });
-            this.busy = "starting";
         }
     }
-    async ensureCover(artist, album) {
+    /** The album's cover, drawn once; songs made at the same time wait for the same drawing. */
+    ensureCover(artist, album) {
         if (album.cover || album.coverTried)
-            return;
+            return this.covering.get(album.key) ?? Promise.resolve();
         album.coverTried = true;
+        const drawing = this.drawCover(artist, album).finally(() => this.covering.delete(album.key));
+        this.covering.set(album.key, drawing);
+        return drawing;
+    }
+    async drawCover(artist, album) {
         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);
@@ -729,7 +1068,12 @@ export class AiLabel {
         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) {
+    place(genre) {
+        const next = this.placing.then(() => this.placeNow(genre));
+        this.placing = next.catch(() => undefined);
+        return next;
+    }
+    async placeNow(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
@@ -835,6 +1179,8 @@ export class AiLabel {
             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 (song.video)
+                    entries.push({ name: `${folder}/${songBase(song)}.mp4`, path: song.video });
             }
             if (album.cover)
                 entries.push({ name: `${folder}/cover.jpg`, path: album.cover });

package/dist/label-routes.js

@@ -94,7 +94,8 @@ export async function handleLabelRoutes(request, response, path, ctx) {
                 return true;
             }
             if (path === "/api/v1/label") {
-                ctx.json(response, 200, label.publicView());
+                // Where this catalogue is sold from, for Buy links built elsewhere (nixamp music, MCP).
+                ctx.json(response, 200, { ...label.publicView(), ...(/^https:\/\//.test(ctx.publicBase ?? "") ? { server: ctx.publicBase } : {}) });
                 return true;
             }
             const url = new URL(request.url ?? "/", "http://x");

package/dist/main.js

@@ -9,6 +9,7 @@ import { t as uiMessage, i18n, terminalUiLanguage, uiLanguage } from "./i18n.js"
  */
 import { USAGE as STATION_USAGE } from "./station-usage.js";
 import { LIBRARY_COMMANDS, LIBRARY_USAGE } from "./library-usage.js";
+import { MUSIC_USAGE } from "./music-cli.js";
 import { createApp, themes } from "@profullstack/hqtui";
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
@@ -209,6 +210,7 @@ keeps serving its browser remote. One per user.
   nixamp attach   put the player back in front of it
   nixamp admin    who is connected, and re-stream to them
   nixamp station  make a folder into a station others can join (see: nixamp station help)
+  nixamp music    the AI label's songs as files: catalog, buy (10¢, $1, $2), what you bought (nixamp music help)
 
 From inside the player, d hands the music to a daemon without stopping it.
 `,
@@ -374,6 +376,8 @@ export function helpFor(topic) {
         return STATION_USAGE;
     if (topic === "library")
         return LIBRARY_USAGE;
+    if (topic === "music")
+        return MUSIC_USAGE;
     return (topic ? TOPICS[topic] : undefined) ?? HELP;
 }
 /**
@@ -531,6 +535,11 @@ export async function main() {
         process.exitCode = await runDaemon(rest);
         return;
     }
+    if (first === "music") {
+        const { music } = await import("./music-cli.js");
+        process.exitCode = await music(rest);
+        return;
+    }
     if (first === "station" || first === "stations") {
         const { station } = await import("./station-cli.js");
         process.exitCode = await station(rest);

package/dist/mcp.js

@@ -218,6 +218,29 @@ export const TOOLS = [
             required: ["server"],
         },
     },
+    {
+        name: "music_catalog",
+        description: "The AI label's catalogue: genres, artists, albums and songs (with lyrics), and each genre's free live station. Read from the server that holds the music, live.streaming by default.",
+        inputSchema: { type: "object", properties: { server: { ...STRING, description: "The music server's https address (default https://live.streaming.pit.world)." } } },
+    },
+    {
+        name: "music_buy",
+        description: "Buy AI label music as files (a song 10¢, an album $1, everything by an artist $2) with crypto via CoinPay. Answers the page to pay on and the receipt link where the zip (MP3s with cover art and lyrics) is downloaded once paid. Pass a nixamp.com/buy link, or server + kind + artist (+ album, + n).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                link: { ...STRING, description: "A nixamp.com/buy?... link." },
+                server: STRING, kind: { type: "string", enum: ["song", "album", "artist"] }, artist: STRING, album: STRING, n: { type: "integer" },
+                email: { ...STRING, description: "Where the receipt goes; the signed-in account's email by default." },
+                coin: { ...STRING, description: "USDC_POL (default), USDC_SOL, SOL, POL, ETH, BTC..." },
+            },
+        },
+    },
+    {
+        name: "music_purchases",
+        description: "The AI label music this account bought, with a fresh download link for each zip. Needs `nixamp login` with the email used to buy.",
+        inputSchema: { type: "object", properties: {} },
+    },
     ...STATION_TOOLS,
     ...PUBLIC_TOOLS,
     ...LIBRARY_TOOLS,
@@ -260,6 +283,25 @@ export async function callTool(name, args, options = {}) {
             ...(options.session?.site ? { site: options.session.site } : {}),
         });
     }
+    // The AI label's music: the catalogue and buying need no sign-in; what was bought does.
+    if (name === "music_catalog" || name === "music_buy" || name === "music_purchases") {
+        const shop = await import("./music-client.js");
+        try {
+            if (name === "music_catalog")
+                return text(JSON.stringify(await shop.catalogue(typeof args["server"] === "string" && args["server"] ? args["server"] : undefined, options.fetcher), null, 2));
+            if (name === "music_purchases")
+                return text(JSON.stringify(await shop.purchases(options.fetcher), null, 2));
+            const link = typeof args["link"] === "string" ? shop.fromBuyLink(args["link"]) : null;
+            if (typeof args["link"] === "string" && !link)
+                return failed("that is not a nixamp.com/buy link");
+            const pick = (keys) => Object.fromEntries(keys.filter((key) => args[key] !== undefined).map((key) => [key, args[key]]));
+            const made = await shop.buy({ ...(link ?? pick(["server", "kind", "artist", "album", "n"])), ...(link?.["n"] ? { n: Number(link["n"]) } : {}), coin: typeof args["coin"] === "string" ? args["coin"] : "USDC_POL", ...pick(["email"]) }, options.fetcher);
+            return text(`Pay here: ${made.url}\nReceipt and download, once paid: ${made.receipt}`);
+        }
+        catch (error) {
+            return failed(error.message);
+        }
+    }
     // Stations first: on this machine they need the daemon, not a sign-in.
     if (isStationTool(name) || isLibraryTool(name)) {
         const local = { ...(options.fetcher ? { fetcher: options.fetcher } : {}), ...(options.session !== undefined ? { session: options.session } : {}), ...(options.stations ?? {}) };