nixamp 0.58.1 → 0.59.1

package/dist/ai-label.d.ts

@@ -209,6 +209,12 @@ export interface AiLabelDeps {
     }) => 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>;
+    /** Tells the world an album landed (nixamp.com tells the artist's followers); never awaited. */
+    announce?: (release: {
+        artist: string;
+        title: string;
+        kind: "album" | "song";
+    }) => void;
     /** The day's pick (artist, genre, new or not); Math.random by default. */
     random?: () => number;
     now?: () => number;

package/dist/ai-label.js

@@ -1273,6 +1273,7 @@ export class AiLabel {
             if (album.songs.every((one) => one.file)) {
                 album.doneAt = this.now();
                 this.log(`${artist.name} released "${album.title}"`);
+                this.deps.announce?.({ artist: artist.key, title: album.title, kind: "album" });
                 void this.ensureProfile(artist).catch(() => undefined);
             }
             this.save();

package/dist/follow-page.js

@@ -96,7 +96,7 @@ export async function handleFollowPage(request, response, path, url, ctx) {
     if (!me) {
         send(response, 200, page(`Follow ${target.name}`, `<h1>Follow ${escape(target.name)}</h1>
 <p class="by">Sign in to nixamp.com to follow the artists you hear on the radio.</p>
-<a class="go" href="/radio#music">Sign in to nixamp.com</a>
+<a class="go" href="/music/me">Sign in to nixamp.com</a>
 <small>Signed in, open this page again (or press Follow on the artist's page) to follow.</small>${back}`), method);
         return true;
     }

package/dist/label-routes.js

@@ -10,6 +10,7 @@ import { createHash } from "node:crypto";
 import { createReadStream, statSync } from "node:fs";
 import { ROSTER } from "./ai-label.js";
 import { covers, PRICES } from "./music-store.js";
+import { serverId } from "./music-hub.js";
 import { writeZip, zipSize } from "./zip-stream.js";
 import { StationError } from "./stations.js";
 import { adCsp, withPageAd } from "./station-guide.js";
@@ -25,7 +26,8 @@ export function isPublicLabelPath(path) {
 }
 /** nixamp.com's page that sells this: a song, an album or everything by the artist. */
 export function buyLink(site, server, kind, artist, album = "", n = 0) {
-    const query = new URLSearchParams({ server, kind, artist, ...(kind !== "artist" ? { album } : {}), ...(kind === "song" ? { n: String(n) } : {}) });
+    // The server goes by its opaque id (music-hub.ts): no link names the machine the music is on.
+    const query = new URLSearchParams({ server: /^https:\/\//.test(server) ? serverId(server) : server, kind, artist, ...(kind !== "artist" ? { album } : {}), ...(kind === "song" ? { n: String(n) } : {}) });
     return `${site}/buy?${query.toString()}`;
 }
 async function jsonBody(ctx, request) {

package/dist/music-hub.d.ts

@@ -0,0 +1,97 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** A server's opaque id: the first 10 hex of the SHA-256 of its https origin. Both sides can work it out. */
+export declare function serverId(base: string): string;
+/** The followable id of an artist, as /follow and live.streaming's /radio use it. */
+export declare function artistFollowId(name: string): string;
+interface LabelArtist {
+    key: string;
+    name: string;
+    genre: string;
+    bio: string;
+    members?: Array<{
+        slug: string;
+        name: string;
+        role: string;
+        bio: string;
+    }>;
+    albums: Array<{
+        key: string;
+        title: string;
+        year: number;
+        concept: string;
+        cover: boolean;
+        complete: boolean;
+        songs: Array<{
+            n: number;
+            title: string;
+            seconds: number;
+            lyrics?: string;
+        }>;
+    }>;
+}
+export interface HubStation {
+    server: string;
+    id: string;
+    name: string;
+    state: string;
+    listen: string;
+    token: string;
+    nowPlaying: {
+        title: string;
+        artist: string;
+    } | null;
+}
+export interface HubArtist extends LabelArtist {
+    server: string;
+    follow: string;
+}
+export interface HubCatalogue {
+    holders: string[];
+    genres: Array<{
+        genre: string;
+        stations: HubStation[];
+        artists: HubArtist[];
+    }>;
+    /** Every AI station on the servers, by genre or not (lo-fi, the bands...). */
+    stations: HubStation[];
+}
+export interface MusicHubOptions {
+    /** The servers whose labels are gathered: the directory and the guide's peers. */
+    peers: () => string[];
+    fetcher?: typeof fetch;
+    now?: () => number;
+}
+export declare class MusicHub {
+    private readonly options;
+    private cache;
+    private bases;
+    constructor(options: MusicHubOptions);
+    private now;
+    /** The https origin behind an opaque id, among the servers known now. */
+    resolve(id: string): string;
+    /** The catalogue, gathered at most once a minute (a slow or gone server is left out, not waited on). */
+    catalogue(): Promise<HubCatalogue>;
+    private read;
+    private gather;
+}
+/**
+ * live.streaming's /radio/artist/<slug> and /radio/album/<slug> addresses, on
+ * nixamp.com: the /music page they name (radio-slug.ts's slugs), or "" when
+ * the catalogue has no such artist or album.
+ */
+export declare function musicPageFor(hub: MusicHub, path: string): Promise<string>;
+export declare function isMusicPath(path: string): boolean;
+export interface MusicRoutesContext {
+    hub: MusicHub;
+    json: (response: ServerResponse, status: number, body: unknown) => void;
+    readBody: (request: IncomingMessage) => Promise<string>;
+    /** The page shell (web/music.html), or null when the web build is absent. */
+    page: () => string | null;
+    /** A server says something of its label landed; null when nobody may say so. */
+    released?: (request: IncomingMessage, body: Record<string, unknown>) => Promise<{
+        status: number;
+        body: unknown;
+    }>;
+}
+export declare function handleMusicRoutes(request: IncomingMessage, response: ServerResponse, path: string, ctx: MusicRoutesContext): Promise<boolean>;
+export {};

package/dist/music-hub.js

@@ -0,0 +1,215 @@
+/**
+ * nixamp.com/music: every AI label's catalogue in one place.
+ *
+ * The music lives on the servers that make it (server1 and any other nixamp
+ * with a label); nixamp.com is where people listen, browse, follow and buy.
+ * This gathers each server's /api/v1/label and its public stations, gives
+ * every server a short opaque id (so no page or link names the machine), and
+ * hands covers, portraits and words through itself.
+ *
+ *   GET /api/v1/music                         the merged catalogue
+ *   GET /api/v1/music/file/<server>/<path>    a cover, portrait, profile or words, through nixamp.com
+ *   POST /api/v1/music/released               a server says an album or song landed: its followers hear
+ */
+import { createHash } from "node:crypto";
+/** A server's opaque id: the first 10 hex of the SHA-256 of its https origin. Both sides can work it out. */
+export function serverId(base) {
+    return createHash("sha256").update(base.replace(/\/+$/, "")).digest("hex").slice(0, 10);
+}
+/** The followable id of an artist, as /follow and live.streaming's /radio use it. */
+export function artistFollowId(name) {
+    const slug = name.split(/\s*;\s*/)[0].normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60) || "artist";
+    return `artist:${slug}`;
+}
+export class MusicHub {
+    options;
+    cache = null;
+    bases = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    /** The https origin behind an opaque id, among the servers known now. */
+    resolve(id) {
+        if (!/^[a-f0-9]{10}$/.test(id))
+            return "";
+        if (!this.bases.has(id))
+            for (const base of this.options.peers())
+                this.bases.set(serverId(base), base);
+        return this.bases.get(id) ?? "";
+    }
+    /** The catalogue, gathered at most once a minute (a slow or gone server is left out, not waited on). */
+    catalogue() {
+        if (this.cache && this.now() - this.cache.at < 60_000)
+            return this.cache.value;
+        const value = this.gather().catch((error) => { this.cache = null; throw error; });
+        this.cache = { at: this.now(), value };
+        return value;
+    }
+    async read(url) {
+        try {
+            const response = await (this.options.fetcher ?? fetch)(url, { signal: AbortSignal.timeout(6_000), headers: { accept: "application/json" } });
+            return response.ok ? await response.json() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async gather() {
+        const peers = [...new Set(this.options.peers())];
+        const holders = new Set();
+        const genres = new Map();
+        const stations = [];
+        await Promise.all(peers.map(async (base) => {
+            const id = serverId(base);
+            this.bases.set(id, base);
+            const [label, guide] = await Promise.all([
+                this.read(`${base}/api/v1/label`),
+                this.read(`${base}/api/v1/stations/guide?local=1`),
+            ]);
+            // A station is heard through its own server; the page's token is its listen key.
+            const byId = new Map();
+            for (const one of guide?.stations ?? []) {
+                if (one.group && one.group !== "ai")
+                    continue;
+                let page;
+                try {
+                    page = new URL(one.page);
+                }
+                catch {
+                    continue;
+                }
+                if (page.origin !== base)
+                    continue;
+                const station = { server: id, id: one.id, name: one.name, state: one.state, listen: `${base}/api/v1/stations/${one.id}`, token: page.searchParams.get("t") ?? "", nowPlaying: one.nowPlaying };
+                byId.set(one.id, station);
+                stations.push(station);
+            }
+            if (!label)
+                return;
+            holders.add(label.holder);
+            for (const genre of label.genres) {
+                const slot = genres.get(genre.genre) ?? { genre: genre.genre, stations: [], artists: [] };
+                const station = byId.get(genre.station);
+                if (station)
+                    slot.stations.push(station);
+                for (const artist of genre.artists)
+                    slot.artists.push({ ...artist, server: id, follow: artistFollowId(artist.name) });
+                genres.set(genre.genre, slot);
+            }
+        }));
+        return {
+            holders: [...holders],
+            genres: [...genres.values()].sort((a, b) => a.genre.localeCompare(b.genre)),
+            stations: stations.sort((a, b) => a.name.localeCompare(b.name)),
+        };
+    }
+}
+const FILE = /^\/api\/v1\/music\/file\/([a-f0-9]{10})\/([a-f0-9]{10}\/(?:[a-f0-9]{8}\/(?:\d{1,3}\.txt|cover\.jpg)|artist\.md|members\/[a-z0-9-]{1,40}\.(?:md|jpg)))$/;
+const slugOf = (text, max) => text.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, max);
+/**
+ * live.streaming's /radio/artist/<slug> and /radio/album/<slug> addresses, on
+ * nixamp.com: the /music page they name (radio-slug.ts's slugs), or "" when
+ * the catalogue has no such artist or album.
+ */
+export async function musicPageFor(hub, path) {
+    const match = /^\/radio\/(artist|album)\/([a-z0-9-]{1,100})\/?$/.exec(path);
+    if (!match)
+        return "";
+    const catalogue = await hub.catalogue();
+    const artists = catalogue.genres.flatMap((one) => one.artists);
+    if (match[1] === "artist") {
+        const artist = artists.find((one) => one.follow === `artist:${match[2]}`);
+        return artist ? `/music/artist/${artist.server}/${artist.key}` : "";
+    }
+    for (const artist of artists) {
+        const album = artist.albums.find((one) => slugOf(`${artist.follow.slice(7)} ${one.title}`, 90) === match[2]);
+        if (album)
+            return `/music/album/${artist.server}/${artist.key}/${album.key}`;
+    }
+    return "";
+}
+export function isMusicPath(path) {
+    return path === "/music" || path.startsWith("/music/") || path === "/api/v1/music" || FILE.test(path) || path === "/api/v1/music/released";
+}
+export async function handleMusicRoutes(request, response, path, ctx) {
+    if (!isMusicPath(path))
+        return false;
+    const method = request.method ?? "GET";
+    if (path === "/api/v1/music/released") {
+        if (method !== "POST" || !ctx.released) {
+            ctx.json(response, 405, { error: "not like that" });
+            return true;
+        }
+        let body = {};
+        try {
+            body = JSON.parse(await ctx.readBody(request));
+        }
+        catch {
+            ctx.json(response, 400, { error: "the body is not JSON" });
+            return true;
+        }
+        const answer = await ctx.released(request, body);
+        ctx.json(response, answer.status, answer.body);
+        return true;
+    }
+    if (method !== "GET" && method !== "HEAD") {
+        ctx.json(response, 405, { error: "not like that" });
+        return true;
+    }
+    if (path === "/api/v1/music") {
+        ctx.json(response, 200, await ctx.hub.catalogue());
+        return true;
+    }
+    const file = FILE.exec(path);
+    if (file) {
+        const base = ctx.hub.resolve(file[1]);
+        if (!base) {
+            ctx.json(response, 404, { error: "no such server" });
+            return true;
+        }
+        try {
+            const upstream = await fetch(`${base}/api/v1/label/${file[2]}`, { signal: AbortSignal.timeout(15_000) });
+            if (!upstream.ok || !upstream.body) {
+                ctx.json(response, upstream.status === 404 ? 404 : 502, { error: "not there" });
+                return true;
+            }
+            response.writeHead(200, {
+                "content-type": upstream.headers.get("content-type") ?? "application/octet-stream",
+                "cache-control": "public, max-age=3600",
+                ...(upstream.headers.get("content-length") ? { "content-length": upstream.headers.get("content-length") } : {}),
+            });
+            if (method === "HEAD") {
+                response.end();
+                return true;
+            }
+            const reader = upstream.body.getReader();
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (!response.write(value))
+                    await new Promise((resolve) => response.once("drain", resolve));
+            }
+            response.end();
+        }
+        catch {
+            if (!response.headersSent)
+                ctx.json(response, 502, { error: "the server holding it did not answer" });
+            else
+                response.destroy();
+        }
+        return true;
+    }
+    // /music and everything under it is the app; it reads /api/v1/music.
+    const page = ctx.page();
+    if (!page) {
+        ctx.json(response, 404, { error: "the music app is not built here" });
+        return true;
+    }
+    response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-cache" });
+    response.end(method === "HEAD" ? undefined : page);
+    return true;
+}

package/dist/music-store.d.ts

@@ -63,6 +63,8 @@ export interface MusicStoreOptions {
     secret: string;
     /** The servers whose catalogues may be sold here (the directory and the guide's peers). */
     servers: () => string[];
+    /** The https origin behind an opaque server id, when nixamp.com keeps a hub. */
+    resolveServer?: (id: string) => string;
     fetcher?: typeof fetch;
     now?: () => number;
     log?: (line: string) => void;

package/dist/music-store.js

@@ -151,7 +151,9 @@ export class MusicStore {
     }
     /** What is for sale at this address, with its name and price; refused when there is no such thing. */
     async describe(input) {
-        const server = serverBase(input["server"]);
+        // An opaque server id (music-hub.ts), or an https origin.
+        const asked = String(input["server"] ?? "");
+        const server = /^[a-f0-9]{10}$/.test(asked) ? (this.options.resolveServer?.(asked) ?? "") : serverBase(asked);
         // A server in the directory or the guide's peers, or one named under nixamp.com (whose names
         // and certificates nixamp.com issues): the directory empties on every restart of nixamp.com.
         const named = server ? new URL(server).hostname.endsWith(".nixamp.com") : false;
@@ -240,7 +242,7 @@ export class MusicStore {
         await this.mail(purchase.email, `Your music: ${purchase.title}`, [
             `Thank you. "${purchase.title}" by ${purchase.artistName} is yours: MP3s with the cover art and the lyrics, in one zip.`,
             `Download it, now or any time: ${this.link(purchase.id, purchase.token)}`,
-            `Sign in to nixamp.com with ${purchase.email} and everything you have bought is under My music on ${this.options.site}/radio#music, to play or download again.`,
+            `Sign in to nixamp.com with ${purchase.email} and everything you have bought is under My music on ${this.options.site}/music/me, to play or download again.`,
         ]);
         return purchase;
     }

package/dist/server.d.ts

@@ -26,6 +26,7 @@ import { ListenerStore } from "./library-user.ts";
 import { Importer } from "./handoff.ts";
 import { AiLabel } from "./ai-label.ts";
 import { MusicStore } from "./music-store.ts";
+import { MusicHub } from "./music-hub.ts";
 import { AiRadio } from "./ai-radio.ts";
 import { ListenerShares } from "./listener-shares.ts";
 import { Support, SupportSubscriptions } from "./support.ts";
@@ -833,6 +834,14 @@ export interface HandlerOptions {
     coinpayWebhookSecret?: string;
     /** The AI label's songs for sale, nixamp.com only (music-store.ts). */
     musicStore?: MusicStore;
+    /** nixamp.com/music: every server's label in one app (music-hub.ts). */
+    music?: {
+        hub: MusicHub;
+        released: (request: IncomingMessage, body: Record<string, unknown>) => Promise<{
+            status: number;
+            body: unknown;
+        }>;
+    };
     sharedTranslations?: SharedTranslations;
     /** Translation: texts in another language, by a model here. The same optional library. */
     translator?: Translator;

package/dist/server.js

@@ -64,6 +64,7 @@ import { handleAiRoutes, isPublicSharePath } from "./ai-routes.js";
 import { AiLabel } from "./ai-label.js";
 import { buyLink, handleLabelRoutes, isPublicLabelPath } from "./label-routes.js";
 import { GrantVerifier, MusicStore, PRICES } from "./music-store.js";
+import { handleMusicRoutes, isMusicPath, MusicHub, musicPageFor, serverId } from "./music-hub.js";
 import { handleStoreRoutes, isStorePath } from "./store-routes.js";
 import { AiRadio } from "./ai-radio.js";
 import { ListenerShares } from "./listener-shares.js";
@@ -1591,7 +1592,7 @@ export function createHandler(engine, options) {
                 query.set("t", station.listenToken);
                 request.url = `/api/v1/stations/${station.id}/${sub[2]}?${query.toString()}`;
                 const here = options.stations.publicBase?.() ?? "";
-                rewriteResponse(response, radioRewriter(station, sub[1], /^https:\/\//.test(here) ? `${storeSite}/buy?server=${encodeURIComponent(here)}&` : ""));
+                rewriteResponse(response, radioRewriter(station, sub[1], /^https:\/\//.test(here) ? `${storeSite}/buy?server=${serverId(here)}&` : ""));
                 return handle(request, response);
             }
         }
@@ -2309,6 +2310,9 @@ export function createHandler(engine, options) {
             !(isPublicLabelPath(path) && Boolean(options.stations?.label)) &&
             // The music store: its pages, checkout, receipts and grants (nixamp.com).
             !(isStorePath(path) && Boolean(options.musicStore)) &&
+            // nixamp.com/music: the app and its catalogue, for anybody.
+            !(isMusicPath(path) && Boolean(options.music)) &&
+            !(/^\/radio\/(artist|album)\//.test(path) && Boolean(options.music)) &&
             // What is on, as MCP, for anybody.
             path !== "/mcp/public" &&
             // Supporting a copyright holder is for anybody listening.
@@ -2643,6 +2647,15 @@ export function createHandler(engine, options) {
         // /radio: public, listed stations under readable names, and the artists and
         // albums they play (radio-pages.ts). A station's own paths under its name
         // were answered at the top of this handler.
+        // On nixamp.com, live.streaming's artist and album addresses open the same page of the music app.
+        if (options.music && /^\/radio\/(artist|album)\//.test(path) && (request.method === "GET" || request.method === "HEAD")) {
+            const target = await musicPageFor(options.music.hub, path).catch(() => "");
+            if (target) {
+                response.writeHead(302, { location: target });
+                response.end();
+                return;
+            }
+        }
         if (options.stations && isRadioPath(path) && (request.method === "GET" || request.method === "HEAD")) {
             const stations = options.stations;
             const named = radioStations(stations.store.list());
@@ -2691,12 +2704,27 @@ export function createHandler(engine, options) {
                 ], base, nav));
                 return;
             }
+            // Our label's artists and albums live on nixamp.com/music, where Follow,
+            // Buy and the player are; live.streaming is the public mirror and sends
+            // them there. Anybody else's keep their page here.
+            const onSite = (() => { try {
+                return new URL(storeSite).host === requestHost;
+            }
+            catch {
+                return true;
+            } })();
+            const toMusic = (kind, slug) => {
+                response.writeHead(302, { location: `${storeSite}/radio/${kind}/${encodeURIComponent(slug)}`, "cache-control": "public, max-age=300" });
+                response.end();
+            };
             const artistPath = RADIO_ARTIST.exec(path);
             if (artistPath) {
                 const catalogue = radioCatalogue();
                 const artist = catalogue.artists.get(artistPath[1]);
                 if (!artist)
                     return send(404, renderMissing("artist", base, nav));
+                if (artist.label && !onSite)
+                    return toMusic("artist", artistPath[1]);
                 return send(200, renderArtist(catalogue, artist, { base, nav, shop, site: storeSite, stationNames }));
             }
             const albumPath = RADIO_ALBUM.exec(path);
@@ -2715,6 +2743,8 @@ export function createHandler(engine, options) {
                 }
                 if (!album)
                     return send(404, renderMissing("album", base, nav));
+                if (album.label && !onSite)
+                    return toMusic("album", albumPath[1]);
                 return send(200, renderAlbum(catalogue, album, { base, nav, shop, site: storeSite, stationNames }));
             }
             const stationPath = RADIO_STATION.exec(path);
@@ -2844,6 +2874,23 @@ export function createHandler(engine, options) {
             });
             return;
         }
+        if (options.music && isMusicPath(path)) {
+            const music = options.music;
+            const shell = web ? join(web, "music.html") : "";
+            if (await handleMusicRoutes(request, response, path, {
+                hub: music.hub,
+                json,
+                readBody,
+                page: () => { try {
+                    return shell ? readFileSync(shell, "utf8") : null;
+                }
+                catch {
+                    return null;
+                } },
+                released: music.released,
+            }))
+                return;
+        }
         if (options.musicStore && options.support && isStorePath(path)) {
             const support = options.support;
             const accounts = options.accounts;
@@ -7147,6 +7194,19 @@ export async function serve(argv, version = "0.1.0") {
         root: process.env["NIXAMP_LABEL_ROOT"] || (labelHome ? join(labelHome.root, "ai") : join(stateDir(), "ai-label")),
         owner: options.owner || "",
         mayStart: mayStartStation,
+        // A release is told to nixamp.com as this server's owner; nixamp.com tells the artist's followers.
+        announce: (release) => {
+            const session = readSession();
+            const here = stations.publicBase?.() ?? "";
+            if (!session?.token || !/^https:\/\//.test(here))
+                return;
+            void fetch(`${session.site.replace(/\/+$/, "")}/api/v1/music/released`, {
+                method: "POST",
+                headers: { "content-type": "application/json", authorization: `Bearer ${session.token}` },
+                body: JSON.stringify({ ...release, server: here }),
+                signal: AbortSignal.timeout(15_000),
+            }).then((answer) => console.log(`  ai label: nixamp.com was told of "${release.title}" (${answer.status})`)).catch(() => undefined);
+        },
         log: (line) => console.log(line),
     });
     aiRadio.startSchedule();
@@ -7397,18 +7457,54 @@ export async function serve(argv, version = "0.1.0") {
     supportMonthly?.startSchedule();
     // The AI label's songs for sale: purchases kept here, the music zipped by the server that holds it.
     const jwtSecret = process.env["NIXAMP_JWT_SECRET"] ?? "";
+    // The servers whose music nixamp.com sells and plays: the directory and the guide's peers.
+    const musicServers = () => {
+        const listed = directory ? directory.list().map((one) => peerBase(one.url)).filter(Boolean) : [];
+        return [...new Set([...guidePeers(), ...listed])];
+    };
+    // nixamp.com/music: every server's label in one catalogue (music-hub.ts).
+    const musicHub = options.directory ? new MusicHub({ peers: musicServers }) : undefined;
     const musicStore = supportPayments && supportPayments.enabled && pool && jwtSecret ? new MusicStore({
         db: pool,
         support: supportPayments,
         mail: process.env["RESEND_API_KEY"] ? { apiKey: process.env["RESEND_API_KEY"], from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>" } : null,
         site: nixampSite,
         secret: sha("sha256").update(`music-grant:${jwtSecret}`).digest("hex"),
-        servers: () => {
-            const listed = directory ? directory.list().map((one) => peerBase(one.url)).filter(Boolean) : [];
-            return [...new Set([...guidePeers(), ...listed])];
-        },
+        servers: musicServers,
+        ...(musicHub ? { resolveServer: (id) => musicHub.resolve(id) } : {}),
         log: (line) => console.log(line),
     }) : undefined;
+    /**
+     * A server says an album (or song) of its label landed: its artist's
+     * followers are told. Only the account that owns a listed server may say
+     * so, only for an artist that server's catalogue has, once per release.
+     */
+    const announced = new Set();
+    const musicReleased = async (request, body) => {
+        const me = accounts ? await accounts.whoIs(tokenFrom(request.headers)).catch(() => null) : null;
+        if (!me)
+            return { status: 401, body: { error: "sign in as the server's owner" } };
+        const base = peerBase(String(body["server"] ?? ""));
+        const owns = directory?.list().some((one) => one.ownerId === me.id && peerBase(one.url) === base) ?? false;
+        if (!base || !owns || !musicHub)
+            return { status: 403, body: { error: "that server is not yours, or not listed" } };
+        const catalogue = await musicHub.catalogue();
+        const id = serverId(base);
+        const artist = catalogue.genres.flatMap((one) => one.artists).find((one) => one.server === id && one.key === body["artist"]);
+        const what = String(body["title"] ?? "").replace(/[\r\n]/g, " ").slice(0, 120);
+        if (!artist || !what)
+            return { status: 404, body: { error: "no such artist on that server" } };
+        const key = `${id}:${artist.key}:${what}`;
+        if (announced.has(key))
+            return { status: 200, body: { told: false, why: "already" } };
+        announced.add(key);
+        tellAudienceOf(artist.follow, {
+            title: `New from ${artist.name}`,
+            body: body["kind"] === "song" ? `"${what}" is out. Listen free on nixamp.` : `The album "${what}" is out. Listen free on nixamp.`,
+            url: `${nixampSite}/music/artist/${id}/${artist.key}`,
+        });
+        return { status: 202, body: { told: true, follow: artist.follow } };
+    };
     if (translationPasses)
         void translationPasses.access().catch(() => console.error("nixamp: translation checkout could not warm; it will retry on demand"));
     const liveVoice = accounts && process.env["NIXAMP_DUBBING"] !== "off" ? new LiveVoice({
@@ -7556,8 +7652,14 @@ export async function serve(argv, version = "0.1.0") {
             body: `${what} Listen at ${DEFAULT_DIRECTORY}/directory, or call ${CALL_IN_NUMBER} and key ${listing.code}.`.trim(),
             url: listing.url,
         };
+        tellAudienceOf(listing.ownerId, note);
+    };
+    /** Everyone following `followed` (an account, or `artist:<slug>`), by every way they asked to be told. */
+    const tellAudienceOf = (followed, note) => {
+        if (follows === undefined)
+            return;
         void follows
-            .audience(listing.ownerId)
+            .audience(followed)
             .then((audience) => notifyAll(audience, note, {
             ...(process.env["RESEND_API_KEY"]
                 ? {
@@ -7960,6 +8062,7 @@ export async function serve(argv, version = "0.1.0") {
         ...(supportPayments ? { support: supportPayments } : {}),
         ...(supportMonthly ? { supportSubscriptions: supportMonthly } : {}),
         ...(musicStore ? { musicStore } : {}),
+        ...(musicHub ? { music: { hub: musicHub, released: musicReleased } } : {}),
         ...(process.env["COINPAY_WEBHOOK_SECRET"] ? { coinpayWebhookSecret: process.env["COINPAY_WEBHOOK_SECRET"] } : {}),
         ...(sharedTranslations ? { sharedTranslations } : {}),
         ...(translator ? { translator } : {}),