nixamp 0.48.1 → 0.49.0

package/dist/ai-radio.d.ts

@@ -52,22 +52,26 @@ export declare const DEFAULTS: {
 export interface Composer {
     /** e.g. "elevenlabs/music_v1". */
     name: string;
-    /** Writes an MP3 to `out`. Throws OutOfCredit when the account cannot pay. */
+    /** Writes an MP3 to `out`. Throws OutOfCredit when the account cannot pay. `lyrics` are the words to sing, when there are any. */
     compose(input: {
         prompt: string;
         seconds: number;
         vocals: boolean;
         out: string;
+        lyrics?: string;
     }): Promise<void>;
 }
 export declare class OutOfCredit extends Error {
 }
-/** ElevenLabs Music: a paid plan's music may be broadcast. */
-export declare function elevenLabsComposer(key: string, fetcher?: typeof fetch): Composer;
+/** ElevenLabs' music models; NIXAMP_MUSIC_MODEL picks one, the newest by default. */
+export declare const MUSIC_MODELS: readonly ["music_v1", "music_v2", "music_v2_5"];
+/** ElevenLabs Music: a paid plan's music may be broadcast. Given lyrics, it sings those words. */
+export declare function elevenLabsComposer(key: string, fetcher?: typeof fetch, model?: string): Composer;
 /**
  * A model of the owner's own (MusicGen, ACE-Step...): NIXAMP_AI_MUSIC_COMMAND
- * is run with {prompt}, {seconds}, {vocals} and {out} replaced, each as one
- * argument, and must leave an MP3 at {out}.
+ * is run with {prompt}, {seconds}, {vocals}, {lyrics} (a file of the words to
+ * sing, "" when there are none) and {out} replaced, each as one argument, and
+ * must leave an MP3 at {out}.
  */
 export declare function commandComposer(template: string): Composer;
 /** The composer this server can use, or null with the reason. */
@@ -92,6 +96,8 @@ export interface AiRadioDeps {
     /** The folder the music goes in: a managed library source. */
     root: string;
     owner: string;
+    /** Who holds the rights in what is made ("Profullstack, Inc."), written as publisher and copyright; "" for none. */
+    holder?: () => string;
     /** Whether another station may be started now (the server's running limit). */
     mayStart: () => boolean;
     composer?: () => Composer | null;

package/dist/ai-radio.js

@@ -43,16 +43,22 @@ const MAX_TRACKS = 5_000;
 const BACKOFF_MS = [5 * 60_000, 10 * 60_000, 20 * 60_000, 40 * 60_000, 80 * 60_000, 6 * 3600_000];
 export class OutOfCredit extends Error {
 }
-/** ElevenLabs Music: a paid plan's music may be broadcast. */
-export function elevenLabsComposer(key, fetcher = fetch) {
+/** ElevenLabs' music models; NIXAMP_MUSIC_MODEL picks one, the newest by default. */
+export const MUSIC_MODELS = ["music_v1", "music_v2", "music_v2_5"];
+/** ElevenLabs Music: a paid plan's music may be broadcast. Given lyrics, it sings those words. */
+export function elevenLabsComposer(key, fetcher = fetch, model = "music_v2_5") {
     return {
-        name: "elevenlabs/music_v1",
-        async compose({ prompt, seconds, vocals, out }) {
+        name: `elevenlabs/${model}`,
+        async compose({ prompt, seconds, vocals, out, lyrics }) {
+            const words = vocals && lyrics?.trim() ? lyrics.trim() : "";
             const ask = async (text) => fetcher("https://api.elevenlabs.io/v1/music?output_format=mp3_44100_192", {
                 method: "POST",
                 signal: AbortSignal.timeout(10 * 60_000),
                 headers: { "content-type": "application/json", "xi-api-key": key },
-                body: JSON.stringify({ prompt: text, music_length_ms: Math.round(seconds * 1000), model_id: "music_v1", force_instrumental: !vocals }),
+                body: JSON.stringify({
+                    prompt: text, music_length_ms: Math.round(seconds * 1000), model_id: model,
+                    ...(words ? { lyrics_text: words } : { force_instrumental: !vocals }),
+                }),
             });
             let response = await ask(prompt);
             if (response.status === 400) {
@@ -81,16 +87,22 @@ export function elevenLabsComposer(key, fetcher = fetch) {
 }
 /**
  * A model of the owner's own (MusicGen, ACE-Step...): NIXAMP_AI_MUSIC_COMMAND
- * is run with {prompt}, {seconds}, {vocals} and {out} replaced, each as one
- * argument, and must leave an MP3 at {out}.
+ * is run with {prompt}, {seconds}, {vocals}, {lyrics} (a file of the words to
+ * sing, "" when there are none) and {out} replaced, each as one argument, and
+ * must leave an MP3 at {out}.
  */
 export function commandComposer(template) {
     const words = template.trim().split(/\s+/);
     return {
         name: `command/${words[0]?.split("/").pop() ?? "music"}`,
-        compose: ({ prompt, seconds, vocals, out }) => new Promise((resolve, reject) => {
-            const argv = words.map((one) => one.replace("{prompt}", prompt).replace("{seconds}", String(seconds)).replace("{vocals}", vocals ? "1" : "0").replace("{out}", out));
+        compose: ({ prompt, seconds, vocals, out, lyrics }) => new Promise((resolve, reject) => {
+            const lyricsFile = lyrics?.trim() ? `${out}.lyrics.txt` : "";
+            if (lyricsFile)
+                writeFileSync(lyricsFile, `${lyrics.trim()}\n`);
+            const argv = words.map((one) => one.replace("{prompt}", prompt).replace("{seconds}", String(seconds)).replace("{vocals}", vocals ? "1" : "0").replace("{lyrics}", lyricsFile).replace("{out}", out));
             execFile(argv[0], argv.slice(1), { timeout: 30 * 60_000, maxBuffer: 4 * 1024 * 1024 }, (error) => {
+                if (lyricsFile)
+                    rmSync(lyricsFile, { force: true });
                 if (error)
                     return reject(new Error(`the music command failed: ${error.message}`));
                 try {
@@ -111,7 +123,8 @@ export function composerFromEnv(env = process.env) {
     if (command)
         return commandComposer(command);
     const key = aiKey("ELEVENLABS_API_KEY", env);
-    return key ? elevenLabsComposer(key) : null;
+    const model = aiKey("NIXAMP_MUSIC_MODEL", env);
+    return key ? elevenLabsComposer(key, fetch, MUSIC_MODELS.includes(model) ? model : "music_v2_5") : null;
 }
 const MOODS = ["dreamy", "driving", "melancholy", "bright", "hazy", "tense", "playful", "warm", "nocturnal", "triumphant"];
 const WORDS = ["Neon", "Harbor", "Velvet", "Static", "Paper", "Lantern", "Satellite", "Ember", "Glass", "Tide", "Orchard", "Signal"];
@@ -417,13 +430,16 @@ export class AiRadio {
             const month = monthOf(this.now());
             this.usage[month] = (this.usage[month] ?? 0) + station.trackSeconds;
             const file = join(folder, `${String(station.tracks.length + 1).padStart(4, "0")} ${slug(brief.title)}.mp3`);
+            const year = new Date(this.now()).getUTCFullYear().toString();
+            const holder = this.deps.holder?.() ?? "";
             await (this.deps.tag ?? ((from, to, tags) => tag(this.deps.ffmpeg, from, to, tags)))(raw, file, {
                 title: brief.title,
                 artist: `${station.name} (AI)`,
                 album: station.name,
                 genre: "AI",
                 comment: `Composed by ${composer.name} from a brief by ${brief.model}`,
-                date: new Date(this.now()).getUTCFullYear().toString(),
+                date: year,
+                ...(holder ? { publisher: holder, copyright: `℗ ${year} ${holder}` } : {}),
             });
             const track = { file, title: brief.title, prompt: brief.prompt, seconds: station.trackSeconds, made: `${brief.model} + ${composer.name}`, createdAt: this.now() };
             station.tracks.push(track);

package/dist/ai-text.d.ts

@@ -5,6 +5,8 @@ export interface AskOptions {
     prompt: string;
     /** Milliseconds before giving up (default 30 s). */
     timeoutMs?: number;
+    /** The longest answer, in tokens (default 1024): a song's words need more than a title does. */
+    maxTokens?: number;
     fetcher?: typeof fetch;
     env?: Record<string, string | undefined>;
 }

package/dist/ai-text.js

@@ -58,7 +58,7 @@ export async function askJson(options) {
                 body: JSON.stringify({
                     systemInstruction: { parts: [{ text: options.system }] },
                     contents: [{ role: "user", parts: [{ text: options.prompt }] }],
-                    generationConfig: { responseMimeType: "application/json", temperature: 0.9 },
+                    generationConfig: { responseMimeType: "application/json", temperature: 0.9, maxOutputTokens: options.maxTokens ?? 1024 },
                 }),
             });
             if (!response.ok) {
@@ -82,6 +82,8 @@ export async function askJson(options) {
                 headers: { "content-type": "application/json", authorization: `Bearer ${openai}` },
                 body: JSON.stringify({
                     model,
+                    // Workers AI stops at 256 tokens unless it is told more.
+                    max_tokens: options.maxTokens ?? 1024,
                     // Not every compatible server knows json_object; the answer is read for its JSON either way.
                     ...(official ? { response_format: { type: "json_object" } } : {}),
                     messages: [{ role: "system", content: options.system }, { role: "user", content: options.prompt }],
@@ -101,7 +103,7 @@ export async function askJson(options) {
                 headers: { "content-type": "application/json", "x-api-key": anthropic, "anthropic-version": "2023-06-01" },
                 body: JSON.stringify({
                     model,
-                    max_tokens: 1024,
+                    max_tokens: options.maxTokens ?? 1024,
                     system: `${options.system}\nAnswer with one JSON object and nothing else.`,
                     messages: [{ role: "user", content: options.prompt }],
                 }),

package/dist/label-routes.d.ts

@@ -0,0 +1,15 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type AiLabel } from "./ai-label.ts";
+/** Whether this path is the label's public face. */
+export declare function isPublicLabelPath(path: string): boolean;
+export interface LabelRoutesContext {
+    label: AiLabel;
+    canControl: boolean;
+    json: (response: ServerResponse, status: number, body: unknown) => void;
+    readBody: (request: IncomingMessage) => Promise<string>;
+}
+/** Answers the paths above and the owner's; false when the path is neither. */
+export declare function handleLabelRoutes(request: IncomingMessage, response: ServerResponse, path: string, ctx: LabelRoutesContext): Promise<boolean>;
+export declare const LABEL_CSP: string;
+/** The label's catalogue as a page: no script, plays in any browser. */
+export declare function renderLabel(view: ReturnType<AiLabel["publicView"]>): string;

package/dist/label-routes.js

@@ -0,0 +1,255 @@
+/**
+ * The AI label over HTTP (ai-label.ts).
+ *
+ * Public, no key: `/label` (the catalogue as a page: every artist, album and
+ * song, playable, with its words), `/api/v1/label` (the same as JSON) and
+ * `/api/v1/label/<artist>/<album>/<n>.mp3|<n>.txt|cover.jpg` (the released
+ * files themselves). The owner's are under /api/v1/stations/label.
+ */
+import { createHash } from "node:crypto";
+import { createReadStream, statSync } from "node:fs";
+import { ROSTER } from "./ai-label.js";
+import { StationError } from "./stations.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.
+const FILE = /^\/api\/v1\/label\/([a-f0-9]{10})\/([a-f0-9]{8})\/(\d{1,3}\.txt|cover\.jpg)$/;
+/** Whether this path is the label's public face. */
+export function isPublicLabelPath(path) {
+    return path === "/label" || path === "/api/v1/label" || FILE.test(path);
+}
+async function jsonBody(ctx, request) {
+    const raw = await ctx.readBody(request);
+    if (raw.trim() === "")
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new StationError("bad_json", "the body is not JSON");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        throw new StationError("bad_json", "the body is not a JSON object");
+    return parsed;
+}
+/** A file, whole or the byte range asked for, so a player can seek. */
+function sendFile(request, response, path, type, download) {
+    let size = 0;
+    try {
+        size = statSync(path).size;
+    }
+    catch {
+        response.writeHead(404, { "content-type": "text/plain" }).end("gone");
+        return;
+    }
+    const headers = {
+        "content-type": type,
+        "accept-ranges": "bytes",
+        "cache-control": "public, max-age=3600",
+        "access-control-allow-origin": "*",
+        ...(download ? { "content-disposition": `inline; filename*=UTF-8''${encodeURIComponent(download)}` } : {}),
+    };
+    const range = /^bytes=(\d*)-(\d*)$/.exec(String(request.headers.range ?? ""));
+    if (range && size > 0) {
+        const start = range[1] ? Number(range[1]) : Math.max(0, size - Number(range[2] || 0));
+        const end = range[1] && range[2] ? Math.min(Number(range[2]), size - 1) : size - 1;
+        if (start > end || start >= size) {
+            response.writeHead(416, { "content-range": `bytes */${size}` }).end();
+            return;
+        }
+        response.writeHead(206, { ...headers, "content-range": `bytes ${start}-${end}/${size}`, "content-length": String(end - start + 1) });
+        if (request.method === "HEAD")
+            return void response.end();
+        createReadStream(path, { start, end }).pipe(response);
+        return;
+    }
+    response.writeHead(200, { ...headers, "content-length": String(size) });
+    if (request.method === "HEAD")
+        return void response.end();
+    createReadStream(path).pipe(response);
+}
+/** Answers the paths above and the owner's; false when the path is neither. */
+export async function handleLabelRoutes(request, response, path, ctx) {
+    const method = request.method ?? "GET";
+    const label = ctx.label;
+    try {
+        if (isPublicLabelPath(path)) {
+            if (method !== "GET" && method !== "HEAD") {
+                ctx.json(response, 405, { error: "not like that", code: "method_not_allowed" });
+                return true;
+            }
+            if (path === "/label") {
+                const page = renderLabel(label.publicView());
+                response.writeHead(200, { "content-type": "text/html; charset=utf-8", "content-security-policy": LABEL_CSP, "cache-control": "public, max-age=300" });
+                response.end(method === "HEAD" ? undefined : page);
+                return true;
+            }
+            if (path === "/api/v1/label") {
+                ctx.json(response, 200, label.publicView());
+                return true;
+            }
+            const [, artist, album, what] = FILE.exec(path);
+            const found = label.publicFile(artist, album, what);
+            if (!found) {
+                ctx.json(response, 404, { error: "no such file on the label", code: "not_found" });
+                return true;
+            }
+            sendFile(request, response, found.path, found.type, what === "cover.jpg" ? "" : found.path.split("/").pop() ?? "");
+            return true;
+        }
+        if (path !== "/api/v1/stations/label" && !path.startsWith("/api/v1/stations/label/"))
+            return false;
+        if (!ctx.canControl) {
+            ctx.json(response, 403, { error: "only this server's owner runs the label", code: "forbidden" });
+            return true;
+        }
+        if (path === "/api/v1/stations/label") {
+            if (method === "GET") {
+                ctx.json(response, 200, label.status());
+                return true;
+            }
+            if (method === "POST") {
+                ctx.json(response, 200, { settings: label.configure(await jsonBody(ctx, request)) });
+                return true;
+            }
+        }
+        if (path === "/api/v1/stations/label/run" && method === "POST") {
+            void label.tick();
+            ctx.json(response, 202, label.status());
+            return true;
+        }
+        if (path === "/api/v1/stations/label/artists" && method === "POST") {
+            const input = await jsonBody(ctx, request);
+            if (input["roster"] === true) {
+                // The whole first roster at once, skipping whoever is already signed.
+                const signed = Object.keys(ROSTER).flatMap((preset) => {
+                    try {
+                        return [label.sign({ preset })];
+                    }
+                    catch (error) {
+                        if (error instanceof StationError && error.code === "already_signed")
+                            return [];
+                        throw error;
+                    }
+                });
+                ctx.json(response, 201, { artists: signed });
+                return true;
+            }
+            ctx.json(response, 201, { artist: label.sign(input) });
+            return true;
+        }
+        const match = /^\/api\/v1\/stations\/label\/artists\/([a-f0-9]{10})(?:\/(album))?$/.exec(path);
+        if (match) {
+            const [, key, action] = match;
+            if (!action && method === "GET") {
+                const artist = label.get(key);
+                if (!artist)
+                    throw new StationError("not_found", "no such artist on the label", 404);
+                ctx.json(response, 200, { artist });
+                return true;
+            }
+            if (!action && method === "PATCH") {
+                ctx.json(response, 200, { artist: label.update(key, await jsonBody(ctx, request)) });
+                return true;
+            }
+            if (!action && method === "DELETE") {
+                await label.drop(key, new URL(request.url ?? "/", "http://x").searchParams.get("files") === "1");
+                ctx.json(response, 200, { deleted: key });
+                return true;
+            }
+            if (action === "album" && method === "POST") {
+                const album = await label.plan(key);
+                void label.tick();
+                ctx.json(response, 201, { album });
+                return true;
+            }
+        }
+        ctx.json(response, 404, { error: "no such label route", code: "not_found" });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof StationError)
+            ctx.json(response, error.status, { error: error.message, code: error.code });
+        else
+            ctx.json(response, 500, { error: error instanceof Error ? error.message : String(error), code: "internal" });
+        return true;
+    }
+}
+function escape(text) {
+    return text.replace(/[&<>"']/g, (one) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[one]);
+}
+function minutes(seconds) {
+    return `${Math.floor(seconds / 60)}:${String(Math.round(seconds % 60)).padStart(2, "0")}`;
+}
+const STYLE = `
+:root{color-scheme:light dark;--bg:#f6f7f9;--fg:#15171a;--muted:#5d6570;--card:#fff;--line:#dfe3e8;--accent:#0f7b4f}
+@media (prefers-color-scheme:dark){:root{--bg:#0d0f12;--fg:#e8eaee;--muted:#9aa3ad;--card:#161a1f;--line:#262c33;--accent:#3ddc84}}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--fg);font:16px/1.5 system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+main{max-width:960px;margin:0 auto;padding:32px 16px 48px}h1{margin:0 0 4px;font-size:1.8rem}
+.lead{color:var(--muted);margin:0 0 24px}a{color:var(--accent)}
+nav.genres{display:flex;flex-wrap:wrap;gap:8px;margin:0 0 8px}nav.genres a{border:1px solid var(--line);border-radius:999px;padding:4px 12px;text-decoration:none;color:var(--fg);background:var(--card)}
+section.genre{margin-top:36px}section.genre>h2{display:flex;flex-wrap:wrap;align-items:baseline;gap:12px;margin:0 0 12px;font-size:1.4rem}
+section.genre>h2 a{font-size:.9rem;font-weight:600}
+.artist{background:var(--card);border:1px solid var(--line);border-radius:14px;padding:16px;margin:12px 0}
+.artist h3{margin:0;font-size:1.2rem}.bio{color:var(--muted);margin:4px 0 0}
+.album{display:grid;grid-template-columns:160px 1fr;gap:16px;margin-top:18px}
+@media (max-width:560px){.album{grid-template-columns:1fr}}
+.cover{width:160px;height:160px;border-radius:10px;object-fit:cover;background:var(--line);display:block}
+.blank{width:160px;height:160px;border-radius:10px;background:linear-gradient(135deg,var(--accent),var(--line))}
+.album h4{margin:0;font-size:1.05rem}.concept{color:var(--muted);font-size:.9rem;margin:2px 0 8px}
+ol.songs{list-style:none;margin:0;padding:0}ol.songs li{border-top:1px solid var(--line);padding:8px 0}
+.song{display:flex;flex-wrap:wrap;gap:8px 12px;align-items:center}.song .t{flex:1 1 200px;font-weight:600;overflow-wrap:anywhere}
+.song .n,.song .d{color:var(--muted);font-variant-numeric:tabular-nums}
+audio{width:100%;max-width:360px;height:36px}
+details{margin-top:4px}summary{cursor:pointer;color:var(--muted);font-size:.9rem}
+pre.lyrics{white-space:pre-wrap;font:inherit;font-size:.95rem;margin:8px 0 0;padding:12px;border-radius:8px;background:var(--bg)}
+.dl{font-size:.85rem}.soon{color:var(--muted);font-size:.85rem}
+footer{margin-top:48px;color:var(--muted);font-size:.85rem}footer a{color:inherit}
+`;
+function hash(text) {
+    return `'sha256-${createHash("sha256").update(text).digest("base64")}'`;
+}
+export const LABEL_CSP = [
+    "default-src 'none'", `style-src ${hash(STYLE)}`, "img-src 'self'",
+    "base-uri 'none'", "form-action 'none'", "frame-ancestors 'none'",
+].join("; ");
+function renderAlbum(artist, album) {
+    const base = `/api/v1/label/${artist.key}/${album.key}`;
+    const cover = album.cover ? `<img class="cover" src="${base}/cover.jpg" alt="Cover of ${escape(album.title)}" width="160" height="160" loading="lazy">` : `<div class="blank" aria-hidden="true"></div>`;
+    const songs = album.songs.map((song) => `<li><div class="song"><span class="n">${song.n}.</span><span class="t">${escape(song.title)}</span><span class="d">${minutes(song.seconds)}</span></div>`
+        + `<details><summary>Lyrics</summary><pre class="lyrics">${escape(song.lyrics)}</pre></details>`
+        + `<div class="dl"><a href="${base}/${song.n}.txt">lyrics.txt</a></div></li>`).join("");
+    return `<div class="album">${cover}<div><h4>${escape(album.title)} <span class="d">(${album.year})</span></h4>`
+        + `${album.concept ? `<p class="concept">${escape(album.concept)}</p>` : ""}`
+        + `${album.complete ? "" : `<p class="soon">Still being recorded: new songs land here as they are finished.</p>`}`
+        + `<ol class="songs">${songs}</ol></div></div>`;
+}
+/** The label's catalogue as a page: no script, plays in any browser. */
+export function renderLabel(view) {
+    const label = view.holder.replace(/,?\s+(inc|llc|ltd|gmbh|co)\.?$/i, "");
+    const nav = view.genres.length > 1 ? `<nav class="genres" aria-label="Genres">${view.genres.map((one) => `<a href="#${escape(one.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(one.genre)}</a>`).join("")}</nav>` : "";
+    const sections = view.genres.map((genre) => `<section class="genre" id="${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}" aria-labelledby="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">`
+        + `<h2 id="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(genre.genre)}${genre.station ? ` <a href="/watch/${escape(genre.station)}">Listen live, free →</a>` : ""}</h2>`
+        + genre.artists.map((artist) => `<article class="artist"><h3>${escape(artist.name)}</h3>${artist.bio ? `<p class="bio">${escape(artist.bio)}</p>` : ""}${artist.albums.map((album) => renderAlbum(artist, album)).join("")}</article>`).join("")
+        + `</section>`).join("");
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escape(label)} AI Label</title>
+<meta name="description" content="Original music by ${escape(label)}'s AI artists: every album, every song, with the words. New albums every month.">
+<link rel="icon" href="data:,">
+<style>${STYLE}</style>
+</head>
+<body>
+<main>
+<h1>${escape(label)} AI Label</h1>
+<p class="lead">Original artists, written and sung by AI, released by ${escape(view.holder)}. Every album, every song, with the words. New albums land every month. Listening on the live stations is always free.</p>
+${nav}
+${sections || `<p class="soon">The first albums are being recorded. Check back soon.</p>`}
+<footer>℗ ${new Date().getUTCFullYear()} ${escape(view.holder)}. Music and words made with AI. Played by <a href="https://nixamp.com">nixamp</a>.</footer>
+</main>
+</body>
+</html>`;
+}

package/dist/server.d.ts

@@ -24,6 +24,7 @@ import { HlsPackagers } from "./hls.ts";
 import { LibraryIndex, type Probed } from "./library-index.ts";
 import { ListenerStore } from "./library-user.ts";
 import { Importer } from "./handoff.ts";
+import { AiLabel } from "./ai-label.ts";
 import { AiRadio } from "./ai-radio.ts";
 import { ListenerShares } from "./listener-shares.ts";
 import { Support, SupportSubscriptions } from "./support.ts";
@@ -599,6 +600,8 @@ export interface HandlerOptions {
         publicBase?: () => string;
         /** Stations whose music is composed by AI. */
         ai?: AiRadio;
+        /** AI artists and their albums, a genre station each, and the catalogue at /label. */
+        label?: AiLabel;
         /** Tracks anybody may share, sorted onto the air by AI. */
         shares?: ListenerShares;
         /** What a listener may know about the track on the air. */

package/dist/server.js

@@ -61,6 +61,8 @@ import { ListenerStore } from "./library-user.js";
 import { Importer } from "./handoff.js";
 import { handleHandoffs } from "./handoff-routes.js";
 import { handleAiRoutes, isPublicSharePath } from "./ai-routes.js";
+import { AiLabel } from "./ai-label.js";
+import { handleLabelRoutes, isPublicLabelPath } from "./label-routes.js";
 import { AiRadio } from "./ai-radio.js";
 import { ListenerShares } from "./listener-shares.js";
 import { HolderStore, TagReader, factsFor } from "./track-facts.js";
@@ -2177,6 +2179,8 @@ export function createHandler(engine, options) {
             !isStationListenPath(path) &&
             // Sharing a track and reporting one are for anybody the guide reaches.
             !isPublicSharePath(path) &&
+            // The AI label's catalogue, its songs and their words.
+            !(isPublicLabelPath(path) && Boolean(options.stations?.label)) &&
             // What is on, as MCP, for anybody.
             path !== "/mcp/public" &&
             // Supporting a copyright holder is for anybody listening.
@@ -2368,7 +2372,8 @@ export function createHandler(engine, options) {
                 ? await roomEntries(options.stations.rooms.store, options.stations.rooms.probe, watchBase(options.stations.publicBase?.() || `${encrypted ? "https" : "http"}://${request.headers.host ?? "localhost"}`))
                 : [];
             const ads = guideAds();
-            const page = renderGuide([...rooms, ...entries, ...others], options.stations.publicBase?.() ?? "", ads);
+            const label = options.stations.label;
+            const page = renderGuide([...rooms, ...entries, ...others], options.stations.publicBase?.() ?? "", ads, label && label.publicView().genres.length > 0 ? "/label" : "");
             response.writeHead(200, {
                 "content-type": "text/html; charset=utf-8",
                 "cache-control": "no-cache",
@@ -2523,6 +2528,11 @@ export function createHandler(engine, options) {
             });
             return;
         }
+        if (options.stations?.label && (isPublicLabelPath(path) || path === "/api/v1/stations/label" || path.startsWith("/api/v1/stations/label/"))) {
+            const control = isPublicLabelPath(path) ? { allowed: false } : await controlOf();
+            if (await handleLabelRoutes(request, response, path, { label: options.stations.label, canControl: control.allowed, json, readBody }))
+                return;
+        }
         if (options.stations && (isPublicSharePath(path) || path.startsWith("/api/v1/stations/ai") || path.startsWith("/api/v1/stations/shares") || path.startsWith("/api/v1/stations/holders"))) {
             const control = await controlOf();
             // Behind a proxy we trust (dev2 for live.streaming), the sharer is the
@@ -6771,10 +6781,27 @@ export async function serve(argv, version = "0.1.0") {
         ffmpeg: tools.ffmpeg,
         root: join(stateDir(), "ai-music"),
         owner: options.owner || "",
+        holder: () => aiLabel.holder(),
+        mayStart: mayStartStation,
+        log: (line) => console.log(line),
+    });
+    // The AI label: artists who put out albums on their own, filed under the
+    // library as ai/<genre>/<artist>/<year>-<album>/ (NIXAMP_LABEL_ROOT moves it).
+    const labelHome = libraryIndex.sources().find((one) => one.enabled && !one.managed);
+    const aiLabel = new AiLabel(AiLabel.fileFor(stateDir(), options.port), {
+        index: libraryIndex,
+        store: stationStore,
+        runner: stationRunner,
+        probe: probeFile,
+        ffmpeg: tools.ffmpeg,
+        root: process.env["NIXAMP_LABEL_ROOT"] || (labelHome ? join(labelHome.root, "ai") : join(stateDir(), "ai-label")),
+        owner: options.owner || "",
         mayStart: mayStartStation,
         log: (line) => console.log(line),
     });
     aiRadio.startSchedule();
+    aiLabel.startSchedule();
+    stations.label = aiLabel;
     // Tracks anybody shares from the guide, checked by AI before they air.
     const listenerShares = new ListenerShares(ListenerShares.fileFor(stateDir(), options.port), {
         index: libraryIndex,