nixamp 0.54.0 → 0.55.1

package/dist/ai-label.d.ts

@@ -1,5 +1,6 @@
 import { type Composer } from "./ai-radio.ts";
 import { askJson } from "./ai-text.ts";
+import { type SyncedLine } from "./lyrics.ts";
 import type { LibraryIndex, Probed } from "./library-index.ts";
 import type { StationRunner } from "./station-runner.ts";
 import { type StationStore } from "./stations.ts";
@@ -15,6 +16,8 @@ export interface LabelSong {
     /** The MP3, "" until composed. */
     file: string;
     lyricsFile: string;
+    /** Its words timed to the recording (001. <title>.lrc, enhanced LRC), for karaoke on the station page; absent until aligned. */
+    lrc?: 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). */
@@ -127,6 +130,21 @@ 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>;
+/** A timed word from an aligner: seconds from the start of the song. */
+export interface TimedWord {
+    text: string;
+    start: number;
+    end: number;
+}
+/** ElevenLabs forced alignment: the song and its words in, each word's time out. */
+export declare function elevenLabsAligner(key: string, fetcher?: typeof fetch): (audio: string, text: string) => Promise<TimedWord[]>;
+/** The sung lines of a song's words: section tags ([Chorus]) and blank lines are not sung. */
+export declare function sungLines(lyrics: string): string[];
+/**
+ * Timed words laid back onto the lines they were written in, in order, so
+ * each line and each word knows when it is sung.
+ */
+export declare function syncLines(lyrics: string, timed: TimedWord[]): SyncedLine[];
 /** 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[]>;
 /**
@@ -169,6 +187,8 @@ 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>;
+    /** Times each sung word in a recording; ElevenLabs forced alignment by default, null without a key. */
+    align?: ((audio: string, text: string) => Promise<TimedWord[]>) | null;
     /** Renders a storyboard music video; ffmpeg by default (renderStoryVideo). */
     storyVideo?: (input: {
         audio: string;
@@ -200,6 +220,8 @@ export declare class AiLabel {
     private filming;
     /** Songs whose video failed since this server started. */
     private videoFailed;
+    /** Songs whose words were already sent to the aligner since this server started. */
+    private alignTried;
     /** 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. */
@@ -246,6 +268,10 @@ export declare class AiLabel {
      * song's tags (seconds each), then old cover-and-waveform videos made again
      * as storyboards.
      */
+    /** The aligner this server can use: the dependency, else ElevenLabs with its key, else none. */
+    private aligner;
+    /** A song's words timed to its recording, written as 001. <title>.lrc beside it. Once per song (a failure is not retried this run). */
+    private sync;
     private filmPass;
     /**
      * One song's video: a storyboard of scenes when a model can write it and an

package/dist/ai-label.js

@@ -33,6 +33,7 @@ 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 { formatLrc } from "./lyrics.js";
 import { StationError } from "./stations.js";
 /**
  * The label's first roster: invented names, one genre each, sung in English.
@@ -408,6 +409,53 @@ export async function workersAiCover(prompt, env = process.env, fetcher = fetch)
         throw new Error("the cover model answered with no picture");
     return image;
 }
+/** ElevenLabs forced alignment: the song and its words in, each word's time out. */
+export function elevenLabsAligner(key, fetcher = fetch) {
+    return async (audio, text) => {
+        const form = new FormData();
+        form.append("file", new Blob([readFileSync(audio)], { type: "audio/mpeg" }), "song.mp3");
+        form.append("text", text);
+        const response = await fetcher("https://api.elevenlabs.io/v1/forced-alignment", {
+            method: "POST",
+            headers: { "xi-api-key": key },
+            body: form,
+            signal: AbortSignal.timeout(5 * 60_000),
+        });
+        if (response.status === 401 || response.status === 402)
+            throw new OutOfCredit(`elevenlabs answered HTTP ${response.status} to the alignment`);
+        if (!response.ok)
+            throw new Error(`the alignment answered HTTP ${response.status}`);
+        const body = await response.json();
+        return (body.words ?? [])
+            .map((one) => ({ text: String(one.text ?? "").trim(), start: Number(one.start), end: Number(one.end) }))
+            .filter((one) => one.text && Number.isFinite(one.start) && Number.isFinite(one.end));
+    };
+}
+/** The sung lines of a song's words: section tags ([Chorus]) and blank lines are not sung. */
+export function sungLines(lyrics) {
+    return lyrics.split("\n").map((line) => line.trim()).filter((line) => line && !/^\[[^\]]*\]$/.test(line));
+}
+/**
+ * Timed words laid back onto the lines they were written in, in order, so
+ * each line and each word knows when it is sung.
+ */
+export function syncLines(lyrics, timed) {
+    const out = [];
+    let at = 0;
+    for (const line of sungLines(lyrics)) {
+        const words = line.split(/\s+/).filter(Boolean);
+        const placed = words.map((word) => {
+            const hit = timed[at];
+            if (hit)
+                at += 1;
+            return hit ? { text: word, start: hit.start, end: hit.end } : null;
+        }).filter((one) => one !== null);
+        if (placed.length === 0)
+            break;
+        out.push({ start: placed[0].start, end: placed[placed.length - 1].end, text: line, words: placed });
+    }
+    return out;
+}
 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).",
@@ -555,6 +603,8 @@ export class AiLabel {
     filming = null;
     /** Songs whose video failed since this server started. */
     videoFailed = new Set();
+    /** Songs whose words were already sent to the aligner since this server started. */
+    alignTried = 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. */
@@ -844,7 +894,43 @@ export class AiLabel {
      * song's tags (seconds each), then old cover-and-waveform videos made again
      * as storyboards.
      */
+    /** The aligner this server can use: the dependency, else ElevenLabs with its key, else none. */
+    aligner() {
+        if (this.deps.align !== undefined)
+            return this.deps.align;
+        const key = aiKey("ELEVENLABS_API_KEY");
+        return key ? elevenLabsAligner(key) : null;
+    }
+    /** A song's words timed to its recording, written as 001. <title>.lrc beside it. Once per song (a failure is not retried this run). */
+    async sync(artist, album, song) {
+        const align = this.aligner();
+        if (!align || !song.file || !song.lyrics || song.lrc || this.alignTried.has(song.file))
+            return false;
+        this.alignTried.add(song.file);
+        try {
+            const timed = await align(song.file, sungLines(song.lyrics).join("\n"));
+            const lines = syncLines(song.lyrics, timed);
+            if (lines.length === 0)
+                throw new Error("the aligner placed no words");
+            const file = join(album.folder, `${songBase(song)}.lrc`);
+            writeFileSync(file, formatLrc(lines, { title: song.title, artist: artist.name, album: album.title }));
+            song.lrc = file;
+            this.save();
+            return true;
+        }
+        catch (error) {
+            this.log(`could not time the words of "${song.title}": ${error.message}`);
+            return false;
+        }
+    }
     async filmPass() {
+        // Words timed first: quick, and what the station page's karaoke needs.
+        for (const artist of this.list()) {
+            for (const album of artist.albums) {
+                for (const song of album.songs)
+                    await this.sync(artist, album, song);
+            }
+        }
         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 }))));
@@ -1184,7 +1270,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.
+            // Its words timed to the recording, then its video, without holding up the next song.
+            await this.sync(artist, album, song).catch(() => undefined);
             void this.videos();
         }
         catch (error) {
@@ -1364,6 +1451,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.lrc)
+                    entries.push({ name: `${folder}/${songBase(song)}.lrc`, path: song.lrc });
                 if (song.video)
                     entries.push({ name: `${folder}/${songBase(song)}.mp4`, path: song.video });
             }

package/dist/label-routes.d.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type AiLabel } from "./ai-label.ts";
 import { type GrantVerifier } from "./music-store.ts";
+import { type GuideAds } from "./station-guide.ts";
 /** Whether this path is the label's public face (an MP3 or the zip still asks for its grant). */
 export declare function isPublicLabelPath(path: string): boolean;
 /** nixamp.com's page that sells this: a song, an album or everything by the artist. */
@@ -13,6 +14,8 @@ export interface LabelRoutesContext {
     /** nixamp.com, where the store is, and this server's public address (for Buy links). */
     site?: string;
     publicBase?: string;
+    /** The one text_link ad /label carries (station-guide.ts withPageAd); none when unset. */
+    ads?: GuideAds;
     json: (response: ServerResponse, status: number, body: unknown) => void;
     readBody: (request: IncomingMessage) => Promise<string>;
 }

package/dist/label-routes.js

@@ -12,6 +12,7 @@ import { ROSTER } from "./ai-label.js";
 import { covers, PRICES } from "./music-store.js";
 import { writeZip, zipSize } from "./zip-stream.js";
 import { StationError } from "./stations.js";
+import { adCsp, withPageAd } from "./station-guide.js";
 // Listening is free on the live stations (with their breaks); the songs as
 // files are sold, so only the words and the cover are public here, and an
 // MP3 or a zip needs a grant from nixamp.com's store (music-store.ts).
@@ -88,8 +89,8 @@ export async function handleLabelRoutes(request, response, path, ctx) {
             }
             if (path === "/label") {
                 const shop = ctx.grants && ctx.site && /^https:\/\//.test(ctx.publicBase ?? "") ? { site: ctx.site, server: ctx.publicBase } : undefined;
-                const page = renderLabel(label.publicView(), shop);
-                response.writeHead(200, { "content-type": "text/html; charset=utf-8", "content-security-policy": LABEL_CSP, "cache-control": "public, max-age=300" });
+                const page = withPageAd(renderLabel(label.publicView(), shop), ctx.ads ?? {});
+                response.writeHead(200, { "content-type": "text/html; charset=utf-8", "content-security-policy": adCsp(LABEL_CSP, ctx.ads ?? {}), "cache-control": "public, max-age=300" });
                 response.end(method === "HEAD" ? undefined : page);
                 return true;
             }

package/dist/lyrics.d.ts

@@ -1,18 +1,3 @@
-/**
- * The words of the song on the air, for a station's page.
- *
- * Two places they come from, in this order:
- *  1. the file itself: an ID3 USLT frame (ffprobe calls it `lyrics-eng`, or
- *     `lyrics-<description>-<lang>`), a Vorbis/APE `LYRICS` or
- *     `UNSYNCEDLYRICS` tag. Suno writes the words it sang into USLT, so our
- *     own catalog carries them already;
- *  2. nichedb.dev's lyrics, asked by artist and title, which is where a file
- *     without the tag gets them (and where ours are published back to:
- *     lyrics-publish.ts).
- * Each answer is kept: the tags with the file (by size and time, TagReader),
- * nichedb's for ten minutes, misses included, so a station of tracks nobody
- * has words for asks once per track per ten minutes and never waits long.
- */
 export interface Lyrics {
     title: string;
     artist: string;
@@ -21,7 +6,32 @@ export interface Lyrics {
     source: string;
     /** ISO 639-1 where we know the mapping, else what the tag said; "" when unsaid. */
     language: string;
+    /** When a .lrc beside the file says when each line (and word) is sung: seconds from the file's start. */
+    synced?: SyncedLine[];
+}
+export interface SyncedLine {
+    start: number;
+    end: number;
+    text: string;
+    words: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
 }
+/**
+ * Enhanced LRC: `[mm:ss.xx]` before each sung line, and `<mm:ss.xx>` before
+ * each word when the words are timed. Tags like `[ar:...]` and lines without a
+ * time are skipped. Ends are the next start (the last line runs 4 s).
+ */
+export declare function parseLrc(text: string): SyncedLine[];
+export declare function formatLrc(lines: SyncedLine[], head?: {
+    title?: string;
+    artist?: string;
+    album?: string;
+}): string;
+/** The .lrc that sits beside a file (same name, .lrc), or "". */
+export declare function lrcBeside(file: string): string;
 export declare const NICHEDB_LYRICS = "https://nichedb.dev";
 /** Text as it may be shown: newlines kept, control characters gone, trimmed, capped. */
 export declare function cleanLyrics(text: string): string;

package/dist/lyrics.js

@@ -13,6 +13,67 @@
  * nichedb's for ten minutes, misses included, so a station of tracks nobody
  * has words for asks once per track per ten minutes and never waits long.
  */
+import { readFileSync } from "node:fs";
+const STAMP = /^(\d{1,3}):(\d{2})(?:[.:](\d{1,3}))?$/;
+function seconds(stamp) {
+    const match = STAMP.exec(stamp);
+    if (!match)
+        return Number.NaN;
+    const fraction = match[3] ? Number(`0.${match[3]}`) : 0;
+    return Number(match[1]) * 60 + Number(match[2]) + fraction;
+}
+function stamp(at) {
+    const whole = Math.max(0, at);
+    const minutes = Math.floor(whole / 60);
+    const rest = whole - minutes * 60;
+    return `${String(minutes).padStart(2, "0")}:${rest.toFixed(2).padStart(5, "0")}`;
+}
+/**
+ * Enhanced LRC: `[mm:ss.xx]` before each sung line, and `<mm:ss.xx>` before
+ * each word when the words are timed. Tags like `[ar:...]` and lines without a
+ * time are skipped. Ends are the next start (the last line runs 4 s).
+ */
+export function parseLrc(text) {
+    const lines = [];
+    for (const raw of text.replace(/\r\n?/g, "\n").split("\n")) {
+        const head = /^\[([^\]]+)\](.*)$/.exec(raw.trim());
+        if (!head)
+            continue;
+        const start = seconds(head[1]);
+        if (!Number.isFinite(start))
+            continue;
+        const body = head[2];
+        const words = [];
+        const parts = body.split(/<([^>]+)>/);
+        if (parts.length > 1) {
+            for (let i = 1; i < parts.length; i += 2) {
+                const at = seconds(parts[i]);
+                const word = (parts[i + 1] ?? "").trim();
+                if (Number.isFinite(at) && word)
+                    words.push({ start: at, end: at, text: word });
+            }
+        }
+        const plain = (parts.length > 1 ? words.map((one) => one.text).join(" ") : body).trim();
+        if (!plain)
+            continue;
+        lines.push({ start, end: start, text: plain, words });
+    }
+    lines.sort((a, b) => a.start - b.start);
+    lines.forEach((line, i) => {
+        line.end = lines[i + 1]?.start ?? line.start + 4;
+        line.words.forEach((word, j) => { word.end = line.words[j + 1]?.start ?? line.end; });
+    });
+    return lines;
+}
+export function formatLrc(lines, head = {}) {
+    const tags = [head.artist ? `[ar:${head.artist}]` : "", head.title ? `[ti:${head.title}]` : "", head.album ? `[al:${head.album}]` : ""].filter(Boolean);
+    const body = lines.map((line) => `[${stamp(line.start)}]${line.words.length ? line.words.map((word) => ` <${stamp(word.start)}>${word.text}`).join("") : line.text}`);
+    return `${[...tags, ...body].join("\n")}\n`;
+}
+/** The .lrc that sits beside a file (same name, .lrc), or "". */
+export function lrcBeside(file) {
+    return file.replace(/\.[^./]+$/, "") + ".lrc";
+}
 export const NICHEDB_LYRICS = "https://nichedb.dev";
 const MAX_TEXT = 20_000;
 /** ID3 / ISO 639-2 codes for the languages we are likely to meet, as 639-1. */
@@ -94,8 +155,18 @@ export class LyricsFinder {
         const title = tags["title"] || known?.title || "";
         const artist = tags["artist"] || tags["album_artist"] || known?.artist || "";
         const own = lyricsFromTags(tags);
+        // Timed words beside the file (karaoke): the page follows along with them.
+        let synced = [];
+        try {
+            synced = parseLrc(readFileSync(lrcBeside(file), "utf8"));
+        }
+        catch {
+            synced = [];
+        }
         if (own)
-            return { title, artist, text: own.text, source: "embedded", language: own.language };
+            return { title, artist, text: own.text, source: "embedded", language: own.language, ...(synced.length ? { synced } : {}) };
+        if (synced.length)
+            return { title, artist, text: synced.map((line) => line.text).join("\n"), source: "embedded", language: "", synced };
         if (!title || !artist || !this.base)
             return null;
         return this.lookup(artist, title);

package/dist/server.js

@@ -78,7 +78,7 @@ import { handleVods, VodProbe, vodEntries, VodStore, vodView } from "./guide-vod
 import { withPitFooter } from "./pit-footer.js";
 import { handleFollowPage } from "./follow-page.js";
 import { asRadioPage, buildCatalogue, isRadioPath, NAV_STYLE, RADIO_ALBUM, RADIO_ARTIST, RADIO_CSP, RADIO_STATION, RADIO_SUB, radioNav, radioPeers, radioRewriter, radioStations, renderAlbum, renderArtist, renderDirectory, renderMissing, rewriteResponse, } from "./radio-pages.js";
-import { guideAds, guideCsp, guideHosts, guidePeers, peerBase, PeerGuides, renderGuide } from "./station-guide.js";
+import { adCsp, guideAds, guideCsp, withPageAd, guideHosts, guidePeers, peerBase, PeerGuides, renderGuide } from "./station-guide.js";
 import { StationRunner } from "./station-runner.js";
 import { StationError, StationStore, channelOf, stationOfChannel } from "./stations.js";
 import { STATION_CONTROL_LIMIT, StationUsage, limitsFromEnv } from "./station-metering.js";
@@ -2529,7 +2529,7 @@ export function createHandler(engine, options) {
             });
             // Behind a guide name (live.streaming) the page asks its own origin, so no server address shows in it.
             const apiBase = guideHosts().has(requestHost) ? "" : options.stations.publicBase?.() ?? "";
-            const page = renderGuide([...rooms, ...entries, ...named], apiBase, ads, label && label.publicView().genres.length > 0 ? "/label" : "");
+            const page = renderGuide([...rooms, ...entries, ...named], apiBase, ads, label && label.publicView().genres.length > 0 ? "/label" : "", path === "/");
             response.writeHead(200, {
                 "content-type": "text/html; charset=utf-8",
                 "cache-control": "no-cache",
@@ -2546,7 +2546,7 @@ export function createHandler(engine, options) {
         // stream address>. The built page plays it in @profullstack/player, as a
         // film or as radio; nothing about the room passes through here.
         if (options.stations?.rooms && path === "/watch" && (request.method === "GET" || request.method === "HEAD")) {
-            const built = web !== null && isFile(join(web, "watch.html")) ? readFileSync(join(web, "watch.html")) : null;
+            const built = web !== null && isFile(join(web, "watch.html")) ? withPageAd(readFileSync(join(web, "watch.html"), "utf8"), guideAds()) : null;
             if (!built) {
                 json(response, 404, { error: "this server was started without its web pages" });
                 return;
@@ -2554,7 +2554,7 @@ export function createHandler(engine, options) {
             response.writeHead(200, {
                 "content-type": "text/html; charset=utf-8",
                 "cache-control": "no-cache",
-                "content-security-policy": WATCH_APP_CSP,
+                "content-security-policy": adCsp(WATCH_APP_CSP, guideAds()),
                 "referrer-policy": "no-referrer",
                 "x-content-type-options": "nosniff",
             });
@@ -2581,11 +2581,11 @@ export function createHandler(engine, options) {
             response.writeHead(vodPath[1] && !one ? 404 : 200, {
                 "content-type": "text/html; charset=utf-8",
                 "cache-control": "no-cache",
-                "content-security-policy": WATCH_APP_CSP,
+                "content-security-policy": adCsp(WATCH_APP_CSP, guideAds()),
                 "referrer-policy": "no-referrer",
                 "x-content-type-options": "nosniff",
             });
-            response.end(request.method === "HEAD" ? undefined : built.replace(/<title>[^<]*<\/title>/, head));
+            response.end(request.method === "HEAD" ? undefined : withPageAd(built.replace(/<title>[^<]*<\/title>/, head), guideAds()));
             return;
         }
         // /radio: public, listed stations under readable names, and the artists and
@@ -2598,10 +2598,12 @@ export function createHandler(engine, options) {
             const base = radioBaseFor(request, publicBase);
             const nav = radioNav(guideHosts().has(requestHost) ? "/" : "/guide");
             const send = (status, page, csp = RADIO_CSP) => {
+                const ads = guideAds();
+                page = withPageAd(page, ads);
                 response.writeHead(status, {
                     "content-type": "text/html; charset=utf-8",
                     "cache-control": status === 200 ? "public, max-age=60" : "no-cache",
-                    "content-security-policy": csp,
+                    "content-security-policy": adCsp(csp, ads),
                     "referrer-policy": "strict-origin-when-cross-origin",
                     "x-content-type-options": "nosniff",
                 });
@@ -2670,12 +2672,14 @@ export function createHandler(engine, options) {
                     return send(404, renderMissing("station", base, nav));
                 }
                 const built = web !== null && isFile(join(web, "station.html")) ? readFileSync(join(web, "station.html"), "utf8") : null;
-                const page = asRadioPage(built ?? STATION_PAGE_HTML, station, slug, base, nav);
+                // The built page carries the one ad; the inline fallback stays as it is.
+                const ads = built ? guideAds() : {};
+                const page = withPageAd(asRadioPage(built ?? STATION_PAGE_HTML, station, slug, base, nav), ads);
                 response.writeHead(200, {
                     "content-type": "text/html; charset=utf-8",
                     "cache-control": "no-cache",
                     // The inline page names its styles by hash; the header's is one more.
-                    "content-security-policy": built ? STATION_APP_CSP : STATION_PAGE_CSP.replace("style-src ", `style-src 'sha256-${sha("sha256").update(NAV_STYLE).digest("base64")}' `),
+                    "content-security-policy": built ? adCsp(STATION_APP_CSP, ads) : STATION_PAGE_CSP.replace("style-src ", `style-src 'sha256-${sha("sha256").update(NAV_STYLE).digest("base64")}' `),
                     "referrer-policy": "strict-origin-when-cross-origin",
                     "x-content-type-options": "nosniff",
                 });
@@ -2733,11 +2737,12 @@ export function createHandler(engine, options) {
         if (options.stations && STATION_PAGE.test(path) && (request.method === "GET" || request.method === "HEAD")) {
             // The built page plays in @profullstack/player; the inline one is for a
             // server started without the web build.
-            const built = web !== null && isFile(join(web, "station.html")) ? readFileSync(join(web, "station.html")) : null;
+            const ads = guideAds();
+            const built = web !== null && isFile(join(web, "station.html")) ? withPageAd(readFileSync(join(web, "station.html"), "utf8"), ads) : null;
             response.writeHead(200, {
                 "content-type": "text/html; charset=utf-8",
                 "cache-control": "no-cache",
-                "content-security-policy": built ? STATION_APP_CSP : STATION_PAGE_CSP,
+                "content-security-policy": built ? adCsp(STATION_APP_CSP, ads) : STATION_PAGE_CSP,
                 "referrer-policy": "no-referrer",
                 "x-content-type-options": "nosniff",
             });
@@ -2795,7 +2800,7 @@ export function createHandler(engine, options) {
             const control = isPublicLabelPath(path) ? { allowed: false } : await controlOf();
             if (await handleLabelRoutes(request, response, path, {
                 label: options.stations.label, canControl: control.allowed, json, readBody,
-                grants: storeGrants, site: storeSite, publicBase: options.stations.publicBase?.() ?? "",
+                grants: storeGrants, site: storeSite, publicBase: options.stations.publicBase?.() ?? "", ads: guideAds(),
             }))
                 return;
         }

package/dist/station-guide.d.ts

@@ -29,7 +29,7 @@ export interface GuideEntry {
  * gateway that cannot run its script against this server (the Moshpit's
  * /n/<name>), and for a crawler. Everything from a station is escaped.
  */
-export declare function renderGuide(entries: GuideEntry[], apiBase?: string, ads?: GuideAds, labelHref?: string): string;
+export declare function renderGuide(entries: GuideEntry[], apiBase?: string, ads?: GuideAds, labelHref?: string, home?: boolean): string;
 export declare const GUIDE_HTML: string;
 /**
  * The guide's policy. With crawlproof configured (guideAds below) its tracker
@@ -38,6 +38,15 @@ export declare const GUIDE_HTML: string;
  */
 export declare function guideCsp(ads?: GuideAds): string;
 export declare const GUIDE_CSP: string;
+/**
+ * The one ad an inner page carries -- a station, /radio, an artist, an album,
+ * /label, /vod, /watch -- and never a home page: a single text_link line at
+ * the top of its content, sized by attributes so a page whose CSP hashes its
+ * styles needs no new one. The page as it was without a slot.
+ */
+export declare function withPageAd(html: string, ads: GuideAds): string;
+/** A page's CSP with room for that ad's frame. */
+export declare function adCsp(csp: string, ads: GuideAds): string;
 /** crawlproof analytics and an ad on the guide: a project id (tracker data-site) and an ad slot. */
 export interface GuideAds {
     site?: string;

package/dist/station-guide.js

@@ -151,7 +151,7 @@ const GROUPS = ["rooms", "vod", "ai", "shared", "radio", "tv"];
  * gateway that cannot run its script against this server (the Moshpit's
  * /n/<name>), and for a crawler. Everything from a station is escaped.
  */
-export function renderGuide(entries, apiBase = "", ads = {}, labelHref = "") {
+export function renderGuide(entries, apiBase = "", ads = {}, labelHref = "", home = false) {
     const groupOf = (one) => one.group ?? (one.kind === "video" ? "tv" : "radio");
     const cards = (group) => entries
         .filter((one) => groupOf(one) === group && /^https?:\/\//.test(one.page))
@@ -166,7 +166,8 @@ export function renderGuide(entries, apiBase = "", ads = {}, labelHref = "") {
     }
     if (ads.site)
         page = page.replace("</head>", `<script data-site="${escape(ads.site)}" src="${CRAWLPROOF}/stats.js" async></script>\n</head>`);
-    if (ads.slot) {
+    // A home page carries no ad (live.streaming's / is this guide); nixamp.com/guide is an inner page.
+    if (ads.slot && !home) {
         // One line by default: a 300x250 box above the stations pushed the guide itself off the first screen.
         const format = ads.format ?? "text_link";
         const slot = ads.slot;
@@ -249,6 +250,22 @@ export function guideCsp(ads = {}) {
     ].join("; ");
 }
 export const GUIDE_CSP = guideCsp();
+/**
+ * The one ad an inner page carries -- a station, /radio, an artist, an album,
+ * /label, /vod, /watch -- and never a home page: a single text_link line at
+ * the top of its content, sized by attributes so a page whose CSP hashes its
+ * styles needs no new one. The page as it was without a slot.
+ */
+export function withPageAd(html, ads) {
+    if (!ads.slot)
+        return html;
+    const unit = `<div class="ad-unit ad-text_link"><iframe src="${CRAWLPROOF}/api/ads/frame?slot=${encodeURIComponent(ads.slot)}&amp;format=text_link" title="Advertisement" width="100%" height="40" frameborder="0" loading="lazy" referrerpolicy="strict-origin-when-cross-origin" sandbox="allow-scripts allow-popups allow-popups-to-escape-sandbox allow-top-navigation-by-user-activation" scrolling="no"></iframe></div>`;
+    return html.replace(/<main\b[^>]*>/, (main) => `${main}\n${unit}`);
+}
+/** A page's CSP with room for that ad's frame. */
+export function adCsp(csp, ads) {
+    return ads.slot ? `${csp}; frame-src 'self' ${CRAWLPROOF}` : csp;
+}
 const AD_ID = /^[A-Za-z0-9-]{1,64}$/;
 /** A setting as the guide may use it: ids that are ids, a format it knows, or nothing. */
 export function cleanGuideAds(value) {

package/dist/station-routes.js

@@ -240,7 +240,7 @@ export async function handleStations(request, response, path, url, ctx) {
                 ctx.json(response, 404, { error: "no lyrics for what is playing", code: "not_found" });
                 return true;
             }
-            ctx.json(response, 200, { lyrics: { title: lyrics.title, artist: lyrics.artist, text: lyrics.text, source: lyrics.source, language: lyrics.language } });
+            ctx.json(response, 200, { lyrics: { title: lyrics.title, artist: lyrics.artist, text: lyrics.text, source: lyrics.source, language: lyrics.language, ...(lyrics.synced ? { synced: lyrics.synced } : {}) } });
             return true;
         }
         if (what === "now") {

package/package.json

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