nixamp 0.52.1 → 0.53.2

package/dist/ai-label.d.ts

@@ -17,6 +17,10 @@ export interface LabelSong {
     lyricsFile: string;
     /** Its music video (001. <title>.mp4), "" until made; absent on songs from before videos. */
     video?: string;
+    /** Whether the video carries its song's tags (videos from 0.52.1 and before do not, until retagged). */
+    videoTagged?: boolean;
+    /** 2 for a storyboard video (scenes that move); absent or 1 for the cover-and-waveform kind, which is made again. */
+    videoVersion?: number;
     /** Who wrote the words and who sang them, e.g. "llama-3.3 + elevenlabs/music_v2_5". */
     made: string;
     composedAt: number;
@@ -123,13 +127,30 @@ 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. */
+/** Image prompts for a song's video, one a scene, from its words and mood. */
+export declare function writeStoryboard(artist: Pick<LabelArtist, "name" | "genre" | "sound">, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "lyrics">, scenes: number, ask?: typeof askJson): Promise<string[]>;
 /**
- * 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.
+ * A song's music video from its storyboard: each scene's picture moves (a
+ * slow zoom in, a pan, a zoom out, a pan back, in turn), scenes cross-fade,
+ * 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 declare function renderStoryVideo(ffmpeg: string[], input: {
+    audio: string;
+    images: string[];
+    seconds: number;
+    artist: string;
+    title: string;
+    out: string;
+}): Promise<void>;
+/**
+ * A song's music video without a storyboard: its album cover over a blurred
+ * copy of itself, the song's waveform along the bottom, 720p H.264 with the
+ * MP3's audio and tags copied in. Without a cover, a dark plate.
  */
 export declare function renderVideo(ffmpeg: string[], audio: string, cover: string, out: string): Promise<void>;
+/** A video made before videos carried tags, given its song's: streams copied, nothing re-encoded. */
+export declare function retagVideo(ffmpeg: string[], video: string, audio: string, out: string): Promise<void>;
 export interface AiLabelDeps {
     index: LibraryIndex;
     store: StationStore;
@@ -148,6 +169,17 @@ export interface AiLabelDeps {
     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>;
+    /** 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>;
+    /** A scene's picture for this prompt, or null when nothing can draw one; Workers AI by default. */
+    image?: (prompt: string) => Promise<Buffer | null>;
     /** The day's pick (artist, genre, new or not); Math.random by default. */
     random?: () => number;
     now?: () => number;
@@ -168,6 +200,8 @@ export declare class AiLabel {
     private filming;
     /** Songs whose video failed since this server started. */
     private videoFailed;
+    /** Old videos already tried as storyboards since this server started. */
+    private upgradeTried;
     /** 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. */
@@ -207,7 +241,17 @@ export declare class AiLabel {
      */
     videos(): Promise<number>;
     private film;
+    /**
+     * One pass: songs without a video first, then old videos given their
+     * song's tags (seconds each), then old cover-and-waveform videos made again
+     * as storyboards.
+     */
     private filmPass;
+    /**
+     * One song's video: a storyboard of scenes when a model can write it and an
+     * image model can draw it (version 2), else the cover-and-waveform kind (1).
+     */
+    private filmSong;
     /** The label's music videos as one TV station: free to watch, with its breaks. */
     private placeVideos;
     stopSchedule(): void;
@@ -262,6 +306,8 @@ export declare class AiLabel {
         artistName: string;
         albumTitle: string;
     } | null;
+    /** The song's MP3 when `file` is one of the label's music videos (it holds the tags, cover and words); else `file`. */
+    audioFor(file: string): string;
     /** A released song's MP3, when this grant's scope covers it. */
     songFile(artistKey: string, albumKey: string, n: number): string;
     /**

package/dist/ai-label.js

@@ -28,7 +28,7 @@
  */
 import { execFile } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, renameSync, rmSync, statSync, 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";
@@ -408,11 +408,97 @@ export async function workersAiCover(prompt, env = process.env, fetcher = fetch)
         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. */
+const STORYBOARD_SYSTEM = [
+    "You storyboard music videos for original songs. Write one image prompt per scene, in order, following the song's story and mood.",
+    "Keep the same main character(s), setting and color palette across scenes so it reads as one video; vary the shots (wide, close-up, action, detail).",
+    "Each prompt: cinematic, photorealistic or stylized to suit the genre, at most 300 characters. No text, letters, logos, real people or real brands.",
+    "Answer as JSON: {\"scenes\": [\"prompt\", ...]}.",
+].join(" ");
+/** Image prompts for a song's video, one a scene, from its words and mood. */
+export async function writeStoryboard(artist, album, song, scenes, ask = askJson) {
+    const answer = await ask({
+        system: STORYBOARD_SYSTEM,
+        prompt: [
+            `Song: "${song.title}" by ${artist.name} (${artist.genre}; ${artist.sound}), from "${album.title}"${album.concept ? `: ${album.concept}` : ""}`,
+            `Mood and arrangement: ${song.style}`,
+            song.lyrics ? `Lyrics:\n${song.lyrics.slice(0, 1800)}` : "",
+            `Exactly ${scenes} scenes.`,
+        ].filter(Boolean).join("\n"),
+        maxTokens: 2500,
+        timeoutMs: 90_000,
+    });
+    const list = Array.isArray(answer.value["scenes"]) ? answer.value["scenes"] : [];
+    const prompts = list.map((one) => clean(one, 400)).filter((one) => one.length > 10).slice(0, scenes);
+    if (prompts.length < 2)
+        throw new Error("the model wrote no storyboard");
+    return prompts;
+}
+/** The DejaVu bold face most Linux boxes have, for the title card; "" when there is none. */
+function titleFont() {
+    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"]) {
+        try {
+            if (statSync(file).isFile())
+                return file;
+        }
+        catch { /* next */ }
+    }
+    return "";
+}
+/** ffmpeg at the lowest priority, so the stations it shares the machine with come first. */
+function runLow(ffmpeg, args, timeout, what) {
+    const nice = process.platform === "linux" ? (() => { try {
+        return statSync("/usr/bin/nice").isFile();
+    }
+    catch {
+        return false;
+    } })() : false;
+    const [bin, rest] = nice ? ["/usr/bin/nice", ["-n", "19", ffmpeg[0], ...args]] : [ffmpeg[0], args];
+    return new Promise((done, fail) => {
+        execFile(bin, rest, { timeout, maxBuffer: 4 * 1024 * 1024 }, (error) => (error ? fail(new Error(`${what}: ${error.message}`)) : done()));
+    });
+}
 /**
- * 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.
+ * A song's music video from its storyboard: each scene's picture moves (a
+ * slow zoom in, a pan, a zoom out, a pan back, in turn), scenes cross-fade,
+ * 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, input) {
+    const fade = 1;
+    const count = input.images.length;
+    const each = input.seconds / count + fade;
+    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)'`,
+        `z='1.15':x='(iw-iw/zoom)*on/${frames}':y='ih/2-(ih/zoom/2)'`,
+        `z='1.15-0.15*on/${frames}':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'`,
+        `z='1.15':x='(iw-iw/zoom)*(1-on/${frames})':y='(ih-ih/zoom)*on/${frames}'`,
+    ];
+    const parts = [];
+    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}]`);
+    });
+    let last = "v0";
+    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}]`);
+        last = `x${i}`;
+    }
+    const font = titleFont();
+    const card = `${input.artist} — ${input.title}`.replace(/[\\':%]/g, " ").slice(0, 80);
+    parts.push(font
+        ? `[${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]),
+        "-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];
+    return runLow(ffmpeg, [...ffmpeg.slice(1), ...args], 60 * 60_000, "the video failed");
+}
+/**
+ * A song's music video without a storyboard: its album cover over a blurred
+ * copy of itself, the song's waveform along the bottom, 720p H.264 with the
+ * MP3's audio and tags 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"];
@@ -424,11 +510,19 @@ export function renderVideo(ffmpeg, audio, cover, out) {
         "[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];
+        "-map", "[v]", "-map", "1:a", "-map_metadata", "1", "-c:v", "libx264", "-preset", "veryfast", "-crf", "26", "-r", "25", "-c:a", "copy", "-shortest",
+        "-movflags", "+faststart+use_metadata_tags", out];
+    return runLow(ffmpeg, args, 20 * 60_000, "the video failed");
+}
+/** A video made before videos carried tags, given its song's: streams copied, nothing re-encoded. */
+export function retagVideo(ffmpeg, video, audio, out) {
+    const args = [...ffmpeg.slice(1), "-hide_banner", "-loglevel", "error", "-y", "-i", video, "-i", audio,
+        "-map", "0:v", "-map", "0:a", "-map_metadata", "1", "-c", "copy", "-movflags", "+faststart+use_metadata_tags", 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()));
+        execFile(ffmpeg[0], args, { timeout: 5 * 60_000 }, (error) => (error ? fail(new Error(`retagging the video failed: ${error.message}`)) : done()));
     });
 }
+/** 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)
@@ -461,6 +555,8 @@ export class AiLabel {
     filming = null;
     /** Songs whose video failed since this server started. */
     videoFailed = new Set();
+    /** Old videos already tried as storyboards since this server started. */
+    upgradeTried = 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. */
@@ -743,40 +839,115 @@ export class AiLabel {
             total += made;
         return total;
     }
+    /**
+     * One pass: songs without a video first, then old videos given their
+     * song's tags (seconds each), then old cover-and-waveform videos made again
+     * as storyboards.
+     */
     async filmPass() {
+        const songs = this.list().flatMap((artist) => artist.albums
+            .filter((album) => album.cover || album.coverTried)
+            .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));
         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();
-                            // On the air as soon as it is made, not after the whole pass.
-                            await this.placeVideos().catch(() => undefined);
-                        }
-                        catch (error) {
-                            this.videoFailed.add(song.file);
-                            this.log(`no video for "${song.title}": ${error.message}`);
-                        }
-                        finally {
-                            rmSync(partial, { force: true });
-                        }
-                    }
-                }
+        for (const { album, song } of untagged) {
+            if (!this.settings.videos)
+                break;
+            // Made before videos carried tags: give it its song's, in place.
+            const partial = join(album.folder, `.${randomBytes(4).toString("hex")}.retag.mp4`);
+            try {
+                await retagVideo(this.deps.ffmpeg, song.video, song.file, partial);
+                renameSync(partial, song.video);
+                song.videoTagged = true;
+                made += 1;
+                this.save();
+            }
+            catch (error) {
+                this.log(`could not tag the video of "${song.title}": ${error.message}`);
+                song.videoTagged = true; // a storyboard remake brings the tags anyway
+            }
+            finally {
+                rmSync(partial, { force: true });
+            }
+        }
+        for (const { artist, album, song } of [...missing, ...old]) {
+            if (!this.settings.videos)
+                break;
+            // An old video is only made again as a storyboard, and tried once a run.
+            const upgrade = Boolean(song.video);
+            if (upgrade)
+                this.upgradeTried.add(song.file);
+            const out = join(album.folder, `${songBase(song)}.mp4`);
+            const partial = join(album.folder, `.${randomBytes(4).toString("hex")}.video.mp4`);
+            const scenes = join(album.folder, `.scenes-${song.n}-${randomBytes(3).toString("hex")}`);
+            try {
+                song.videoVersion = await this.filmSong(artist, album, song, scenes, partial, upgrade);
+                renameSync(partial, out);
+                song.video = out;
+                song.videoTagged = true;
+                made += 1;
+                this.save();
+                // On the air as soon as it is made, not after the whole pass.
+                await this.placeVideos().catch(() => undefined);
+            }
+            catch (error) {
+                if (!upgrade)
+                    this.videoFailed.add(song.file);
+                this.log(`no ${upgrade ? "storyboard " : ""}video for "${song.title}": ${error.message}`);
+            }
+            finally {
+                rmSync(partial, { force: true });
+                rmSync(scenes, { recursive: true, force: true });
             }
         }
         return made;
     }
+    /**
+     * One song's video: a storyboard of scenes when a model can write it and an
+     * image model can draw it (version 2), else the cover-and-waveform kind (1).
+     */
+    async filmSong(artist, album, song, scenes, out, storyOnly = false) {
+        let seconds = song.seconds;
+        try {
+            const probed = await this.deps.probe(song.file);
+            if (probed.duration > 5)
+                seconds = probed.duration;
+        }
+        catch { /* the asked-for length */ }
+        const images = [];
+        if (this.canAsk()) {
+            try {
+                const count = Math.max(4, Math.min(16, Math.round(seconds / 9)));
+                const prompts = await writeStoryboard(artist, album, song, count, this.deps.ask ?? askJson);
+                mkdirSync(scenes, { recursive: true });
+                const draw = this.deps.image ?? ((prompt) => workersAiCover(prompt));
+                // A few at a time: the image model is quick, the machine is shared.
+                for (let i = 0; i < prompts.length; i += 3) {
+                    const drawn = await Promise.all(prompts.slice(i, i + 3).map((prompt) => draw(`${prompt} Cinematic 16:9 music video still, no text.`).catch(() => null)));
+                    drawn.forEach((picture, j) => {
+                        if (!picture)
+                            return;
+                        const file = join(scenes, `${String(i + j).padStart(2, "0")}.jpg`);
+                        writeFileSync(file, picture);
+                        images.push(file);
+                    });
+                }
+            }
+            catch (error) {
+                this.log(`no storyboard for "${song.title}" (${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;
+        }
+        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;
+    }
     /** The label's music videos as one TV station: free to watch, with its breaks. */
     placeVideos() {
         const next = this.placing.then(async () => {
@@ -874,7 +1045,8 @@ export class AiLabel {
             return "composed";
         }
         // 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;
+        // A paused artist's unfinished album waits without holding a slot.
+        const inProgress = this.list().filter((one) => one.enabled && 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 + claimedSeconds > this.budgetLeft())
@@ -1155,6 +1327,19 @@ export class AiLabel {
         }
         return null;
     }
+    /** The song's MP3 when `file` is one of the label's music videos (it holds the tags, cover and words); else `file`. */
+    audioFor(file) {
+        if (!file.endsWith(".mp4"))
+            return file;
+        for (const artist of this.artists.values()) {
+            for (const album of artist.albums) {
+                const song = album.songs.find((one) => one.video === file);
+                if (song)
+                    return song.file;
+            }
+        }
+        return file;
+    }
     /** 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 ?? "";

package/dist/ai-radio.js

@@ -60,7 +60,19 @@ export function elevenLabsComposer(key, fetcher = fetch, model = "music_v2_5") {
                     ...(words ? { lyrics_text: words } : { force_instrumental: !vocals }),
                 }),
             });
-            let response = await ask(prompt);
+            // Too many at once (several songs are made in parallel): wait and ask again, a few times.
+            const patient = async (text) => {
+                let answer = await ask(text);
+                for (const wait of [15_000, 30_000, 60_000]) {
+                    if (answer.status !== 429)
+                        break;
+                    await answer.body?.cancel().catch(() => undefined);
+                    await new Promise((done) => setTimeout(done, wait));
+                    answer = await ask(text);
+                }
+                return answer;
+            };
+            let response = await patient(prompt);
             if (response.status === 400) {
                 // A brief it will not make (an artist's name, a lyric) comes back
                 // with one it will; take it once.
@@ -68,7 +80,7 @@ export function elevenLabsComposer(key, fetcher = fetch, model = "music_v2_5") {
                 const suggestion = body.detail?.data?.prompt_suggestion;
                 if (!suggestion)
                     throw new Error(`elevenlabs refused the brief (${body.detail?.status ?? "HTTP 400"})`);
-                response = await ask(suggestion);
+                response = await patient(suggestion);
             }
             if (response.status === 401 || response.status === 402)
                 throw new OutOfCredit(`elevenlabs answered HTTP ${response.status}: the key or the plan's credit`);

package/dist/ai-text.d.ts

@@ -18,6 +18,11 @@ export interface Answer {
 export declare class NoModel extends Error {
     constructor();
 }
+/**
+ * Raw line breaks and tabs inside JSON strings, escaped: models writing song
+ * words often break the lines for real inside the quotes, which JSON refuses.
+ */
+export declare function escapeInStrings(text: string): string;
 /** The first JSON object in a model's answer. */
 export declare function firstObject(text: string): Record<string, unknown>;
 /** Whether any model can be asked. */

package/dist/ai-text.js

@@ -14,9 +14,51 @@ export class NoModel extends Error {
         super("no language model key is set (GEMINI_API_KEY, OPENAI_API_KEY or ANTHROPIC_API_KEY)");
     }
 }
+/**
+ * Raw line breaks and tabs inside JSON strings, escaped: models writing song
+ * words often break the lines for real inside the quotes, which JSON refuses.
+ */
+export function escapeInStrings(text) {
+    let out = "";
+    let inString = false;
+    let escaped = false;
+    for (const char of text) {
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === "\"")
+                inString = false;
+            else if (char === "\n") {
+                out += "\\n";
+                continue;
+            }
+            else if (char === "\r")
+                continue;
+            else if (char === "\t") {
+                out += "\\t";
+                continue;
+            }
+        }
+        else if (char === "\"")
+            inString = true;
+        out += char;
+    }
+    return out;
+}
 /** The first JSON object in a model's answer. */
 export function firstObject(text) {
-    const cleaned = text.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "");
+    const fenced = text.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "");
+    const cleaned = (() => {
+        try {
+            JSON.parse(fenced);
+            return fenced;
+        }
+        catch {
+            return escapeInStrings(fenced);
+        }
+    })();
     try {
         const parsed = JSON.parse(cleaned);
         if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed))

package/dist/server.js

@@ -2623,6 +2623,7 @@ export function createHandler(engine, options) {
                 },
                 trackFor: (file) => trackFor(engine, file),
                 ...(options.library ? { isVideo: (file) => options.library.index.itemAt(file)?.video === true } : {}),
+                ...(options.library ? { durationOf: (file) => options.library.index.itemAt(file)?.duration ?? 0 } : {}),
                 base: `${scheme}://${request.headers.host ?? "localhost"}`,
                 publicBase: options.stations.publicBase?.() ?? "",
                 json,
@@ -6862,7 +6863,9 @@ export async function serve(argv, version = "0.1.0") {
     stations.holders = holderStore;
     // Covers read once per file (and its size and time), a few hundred kept.
     const covers = new Map();
-    stations.cover = async (file) => {
+    stations.cover = async (playing) => {
+        // A label music video's cover is its song's.
+        const file = aiLabel.audioFor(playing);
         let key = "";
         try {
             const info = statSync(file);
@@ -6883,7 +6886,7 @@ export async function serve(argv, version = "0.1.0") {
     };
     // The words of what is on: the file's own tag, else nichedb.dev's.
     const lyricsFinder = new LyricsFinder({ tags: (file) => tagReader.read(file), known: (file) => trackFor(engine, file) });
-    stations.lyrics = (_station, file) => lyricsFinder.find(file);
+    stations.lyrics = (_station, file) => lyricsFinder.find(aiLabel.audioFor(file));
     // Our own songs' words, back to nichedb, when a key is set: on any station
     // change, after a library scan, and once at start.
     const lyricsPublisher = new LyricsPublisher({
@@ -6914,9 +6917,11 @@ export async function serve(argv, version = "0.1.0") {
             stamp = "";
         }
         const art = picture ? `/api/v1/stations/${station.id}/art?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` : "";
-        const words = await lyricsFinder.find(file).catch(() => null);
+        // A label music video is told about as its song: the MP3 holds the tags and the words.
+        const audio = aiLabel.audioFor(file);
+        const words = await lyricsFinder.find(audio).catch(() => null);
         // A label song is for sale on nixamp.com: the song, its album, everything by the artist.
-        const song = aiLabel.songAt(file);
+        const song = aiLabel.songAt(audio);
         const here = stations.publicBase?.() ?? "";
         const shop = (process.env["NIXAMP_SITE"] || "https://nixamp.com").replace(/\/+$/, "");
         const store = song && /^https:\/\//.test(here) ? {
@@ -6930,8 +6935,8 @@ export async function serve(argv, version = "0.1.0") {
                 art,
                 ...(words ? { lyrics: `/api/v1/stations/${station.id}/lyrics?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` } : {}),
                 station, file,
-                tags: await tagReader.read(file),
-                known: trackFor(engine, file),
+                tags: await tagReader.read(audio),
+                known: trackFor(engine, audio),
                 holders: holderStore.list(),
                 share: share ? { basis: share.rights.basis, note: share.rights.note, by: share.by } : null,
                 aiTrack: composed ? { made: composed.made } : null,

package/dist/station-routes.d.ts

@@ -64,6 +64,8 @@ export interface StationContext {
     } | null;
     /** What a listener may know about the track on the air (track-facts.ts). */
     facts?: (station: Station, file: string) => Promise<TrackFacts>;
+    /** How long a file is, in seconds (the library's probe); 0 when unknown. For the page's progress bar. */
+    durationOf?: (file: string) => number;
     /** The cover picture inside a file (JPEG/PNG bytes), or null. */
     cover?: (file: string) => Promise<{
         bytes: Buffer;

package/dist/station-routes.js

@@ -41,6 +41,10 @@ export function publicView(ctx, station) {
     // What the channel is carrying wins over the flag: a station made by hand
     // from films streams video whether or not anyone said so.
     const video = station.video || ctx.channels.kindOf(channelOf(station.id)) === "video";
+    // How far into the song (or film) on the air, by the encoder's clock, and how long it is.
+    const position = file ? ctx.channels.info(channelOf(station.id))?.position : undefined;
+    const duration = file && ctx.durationOf ? ctx.durationOf(file) : 0;
+    const progress = typeof position === "number" && duration > 0 ? { position: Math.round(Math.min(position, duration) * 10) / 10, duration: Math.round(duration * 10) / 10 } : null;
     return {
         id: station.id,
         name: station.name,
@@ -49,6 +53,7 @@ export function publicView(ctx, station) {
         state,
         // Tags, or nothing: a bare file name is the owner's, not the public's.
         nowPlaying: track && (track.title || track.artist) ? track : null,
+        progress,
         kind: video ? "video" : "audio",
         format: state === "stopped" || state === "offline" ? null : video
             ? { codec: "h264+aac", bitrateKbps: station.bitrate, sampleRate: 48_000, channels: 2 }

package/dist/stations.d.ts

@@ -149,6 +149,11 @@ export interface PublicStation {
         artist: string;
         album: string;
     } | null;
+    /** Seconds into what is on and how long it is, when both are known. */
+    progress?: {
+        position: number;
+        duration: number;
+    } | null;
     format: {
         codec: string;
         bitrateKbps: number;

package/dist/stations.js

@@ -284,6 +284,10 @@ export class StationStore {
         let listed = access.listed === undefined ? station.listed : access.listed === true;
         if (visibility !== "public")
             listed = false;
+        // Made private, a station forgets what was declared for it: going public
+        // again asks afresh, so a stale (or false) declaration cannot republish it.
+        if (visibility === "private" && !access.rights)
+            station.rights = null;
         if (access.rights) {
             const basis = access.rights.basis;
             if (typeof basis !== "string" || !RIGHTS_BASES.includes(basis)) {

package/package.json

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