nixamp 0.58.0 → 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/channels.d.ts

@@ -215,6 +215,8 @@ export interface ChannelOptions {
     /** Whether a pulled source is read here and piped to ffmpeg. See `Channels.setThrough`. */
     through?: ThroughProvider;
 }
+/** The byte count a chunk began at, for one a list channel put out; undefined for any other. */
+export declare function chunkStart(chunk: Buffer): number | undefined;
 /**
  * One live source, and its audience.
  *
@@ -257,6 +259,20 @@ export declare class Channel {
     } | null;
     /** Whether listeners would get sound (and, for a picture, its opening) if they joined now. */
     get flowing(): boolean;
+    /**
+     * What was going out at this point of the byte count: the list's file (""
+     * in a break) and how far into it, with its tags. Null for a byte this
+     * channel no longer knows, or for a channel that is not a radio list.
+     */
+    placeAt(bytes: number): {
+        file: string;
+        position: number;
+        tags?: {
+            title: string;
+            artist: string;
+            album: string;
+        };
+    } | null;
     /** An entry's tags, as read when it was put on. */
     tagsOf(file: string): {
         title: string;
@@ -290,6 +306,8 @@ export declare class Channel {
     private breakOn;
     /** The last couple of minutes of a radio list without its breaks, for listenWithoutBreaks. */
     private music;
+    /** The last few dials of a radio list, newest last, for placeAt(). */
+    private dials;
     private musicBytes;
     private fragmentClock;
     private fragmentTimes;
@@ -543,6 +561,8 @@ export declare class Channels {
     setThrough(provider: ThroughProvider | null): void;
     /** The kind of a channel, for a relay to say what it is carrying. */
     kindOf(id: string): "audio" | "video" | undefined;
+    /** What a radio list channel was putting out at a point of its byte count (Channel.placeAt). */
+    placeAt(id: string, bytes: number): ReturnType<Channel["placeAt"]>;
     /** An entry's tags on a channel playing a list of files. */
     tagsOf(id: string, file: string): {
         title: string;

package/dist/channels.js

@@ -122,6 +122,16 @@ export function cleanId(value, fallback = "main") {
     const id = value.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
     return id.slice(0, 40) || fallback;
 }
+/**
+ * Where each chunk a channel put out begins in its byte count (ChannelInfo.bytes),
+ * so a listener's own bytes can be laid onto the channel's: a backlog, a
+ * skipped break and a redial all keep the chunk objects they were sent as.
+ */
+const chunkStarts = new WeakMap();
+/** The byte count a chunk began at, for one a list channel put out; undefined for any other. */
+export function chunkStart(chunk) {
+    return chunkStarts.get(chunk);
+}
 /**
  * One live source, and its audience.
  *
@@ -179,6 +189,20 @@ export class Channel {
     get flowing() {
         return this.info.bytes > 0 && (!this.fragments || this.fragments.ready);
     }
+    /**
+     * What was going out at this point of the byte count: the list's file (""
+     * in a break) and how far into it, with its tags. Null for a byte this
+     * channel no longer knows, or for a channel that is not a radio list.
+     */
+    placeAt(bytes) {
+        const dial = this.dials.findLast((one) => one.base <= bytes);
+        if (!dial)
+            return null;
+        const place = dial.input.place(((bytes - dial.base) * 8) / (dial.kbps * 1000));
+        const file = place.at >= 0 ? place.list[place.at] ?? "" : "";
+        const tags = file ? dial.input.tags.get(file) : undefined;
+        return { file, position: place.position, ...(tags ? { tags } : {}) };
+    }
     /** An entry's tags, as read when it was put on. */
     tagsOf(file) {
         return this.playlistInput?.tags.get(file);
@@ -210,6 +234,8 @@ export class Channel {
     breakOn = false;
     /** The last couple of minutes of a radio list without its breaks, for listenWithoutBreaks. */
     music = [];
+    /** The last few dials of a radio list, newest last, for placeAt(). */
+    dials = [];
     musicBytes = 0;
     fragmentClock = new FragmentClock();
     fragmentTimes = new WeakMap();
@@ -452,9 +478,17 @@ export class Channel {
                 if (!sent)
                     this.info.error = undefined;
                 sent = true;
+                const at = this.info.bytes;
                 this.info.bytes += chunk.byteLength;
                 this.rearm(child);
                 if (kbps > 0 && playlistInput) {
+                    // Constant-bitrate MP3: a byte of this dial is exactly a time on its list's clock.
+                    if (written === 0) {
+                        this.dials.push({ base: at, input: playlistInput, kbps });
+                        if (this.dials.length > 8)
+                            this.dials.shift();
+                    }
+                    chunkStarts.set(chunk, at);
                     this.breakOn = playlistInput.place((written * 8) / (kbps * 1000)).at === -1;
                     written += chunk.byteLength;
                 }
@@ -1291,6 +1325,10 @@ export class Channels {
     kindOf(id) {
         return this.open.get(id)?.info.kind;
     }
+    /** What a radio list channel was putting out at a point of its byte count (Channel.placeAt). */
+    placeAt(id, bytes) {
+        return this.open.get(id)?.placeAt(bytes) ?? null;
+    }
     /** An entry's tags on a channel playing a list of files. */
     tagsOf(id, file) {
         return this.open.get(id)?.tagsOf(file);

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/radio-pages.js

@@ -21,7 +21,7 @@
 import { createHash } from "node:crypto";
 import { albumSlug, artistSlug, stationSlug } from "./radio-slug.js";
 /** A station's own paths, as the station link opens them. */
-export const RADIO_SUB = /^\/radio\/([a-z0-9-]{1,60})\/(stream|state|listen\.m3u|events|now|art|lyrics)$/;
+export const RADIO_SUB = /^\/radio\/([a-z0-9-]{1,60})\/(stream|state|listen\.m3u|events|now|art|lyrics|clock)$/;
 export const RADIO_STATION = /^\/radio\/([a-z0-9-]{1,60})\/?$/;
 export const RADIO_ARTIST = /^\/radio\/artist\/([a-z0-9-]{1,90})\/?$/;
 export const RADIO_ALBUM = /^\/radio\/album\/([a-z0-9-]{1,100})(\/cover\.jpg)?\/?$/;

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;