nixamp 0.58.1 → 0.59.0

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());
@@ -2844,6 +2857,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 +7177,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 +7440,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 +7635,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 +8045,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 } : {}),

package/dist/store-routes.js

@@ -11,6 +11,7 @@
  */
 import { createHash } from "node:crypto";
 import { PRICES } from "./music-store.js";
+import { serverId } from "./music-hub.js";
 import { SupportError } from "./support.js";
 const PURCHASE = /^\/purchases\/([0-9a-f-]{36})$/;
 const ONE = /^\/api\/v1\/store\/purchases\/([0-9a-f-]{36})$/;
@@ -100,7 +101,7 @@ export async function handleStoreRoutes(request, response, path, url, ctx) {
             }
             const me = await ctx.account().catch(() => null);
             const what = item.kind === "song" ? "One song" : item.kind === "album" ? `The album, ${item.songs} songs` : `Everything by ${escape(item.artistName)}, ${item.songs} songs so far`;
-            const cover = item.kind === "artist" ? "" : `<img src="${escape(`${item.server}/api/v1/label/${item.artist}/${item.album}/cover.jpg`)}" alt="" width="160" height="160" style="border-radius:10px;float:right;margin:0 0 8px 12px;max-width:40%;height:auto">`;
+            const cover = item.kind === "artist" ? "" : `<img src="${escape(`/api/v1/music/file/${serverId(item.server)}/${item.artist}/${item.album}/cover.jpg`)}" alt="" width="160" height="160" style="border-radius:10px;float:right;margin:0 0 8px 12px;max-width:40%;height:auto">`;
             html(response, 200, page(`Download ${item.title}`, `<div class="card">${cover}
 <h1>${escape(item.title)}</h1><p class="by">${escape(item.artistName)}</p>
 <div class="price">${price(item.amountCents)}</div>
@@ -113,8 +114,8 @@ export async function handleStoreRoutes(request, response, path, url, ctx) {
 <button id="pay" type="submit">Pay ${price(item.amountCents)} with crypto</button>
 </form>
 <p id="status" role="status" aria-live="polite"></p>
-<small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com. For small amounts pick a coin with low fees (USDC on Polygon or Solana, SOL, LTC). Listening on the live stations is always free.${me ? "" : ` <a href="/radio#music">Sign in</a> with the same email to keep everything under My music.`}</small>
-</div>`, JSON.stringify({ server: item.server, kind: item.kind, artist: item.artist, album: item.album, n: item.n })), method);
+<small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com. For small amounts pick a coin with low fees (USDC on Polygon or Solana, SOL, LTC). Listening on the live stations is always free.${me ? "" : ` <a href="/?redirect=${encodeURIComponent("/music/me")}#account-panel">Sign in</a> with the same email to keep everything under My music.`}</small>
+</div>`, JSON.stringify({ server: serverId(item.server), kind: item.kind, artist: item.artist, album: item.album, n: item.n })), method);
             return true;
         }
         const receipt = PURCHASE.exec(path);
@@ -127,7 +128,7 @@ export async function handleStoreRoutes(request, response, path, url, ctx) {
             const body = purchase.status === "paid"
                 ? `<div class="card"><h1>${escape(purchase.title)}</h1><p class="by">${escape(purchase.artistName)} · paid ${price(purchase.amountCents)}</p>
 <a class="go" href="${escape(store.zipUrl(purchase))}" download>Download the zip</a>
-<small>MP3s with the cover art and lyrics, plus each song's .lyrics.txt, cover.jpg and album.json. Keep this page's address (it is in your email too) to download again. Signed in to nixamp.com as ${escape(purchase.email)}, everything you bought is under <a href="/radio#music">My music</a>, to play or download.</small></div>`
+<small>MP3s with the cover art and lyrics, plus each song's .lyrics.txt, cover.jpg and album.json. Keep this page's address (it is in your email too) to download again. Signed in to nixamp.com as ${escape(purchase.email)}, everything you bought is under <a href="/music/me">My music</a>, to play or download.</small></div>`
                 : `<div class="card"><h1>${escape(purchase.title)}</h1><p class="by">${escape(purchase.artistName)} · ${price(purchase.amountCents)} in ${escape(purchase.coin)}</p>
 <p>Waiting for your payment. Once CoinPay confirms it, your download is here and in your email (${escape(purchase.email)}). This page checks again when you reload it.</p>
 <a class="go" href="https://coinpayportal.com/pay/${escape(purchase.paymentId)}">Open the payment</a></div>`;

package/package.json

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

package/src/ai-label.ts

@@ -738,6 +738,8 @@ export interface AiLabelDeps {
   storyVideo?: (input: { audio: string; images: string[]; seconds: number; artist: string; title: string; out: string }) => Promise<void>;
   /** A scene's picture for this prompt, or null when nothing can draw one; Workers AI by default. */
   image?: (prompt: string) => Promise<Buffer | null>;
+  /** 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;
@@ -1383,6 +1385,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();