nixamp 0.58.0 → 0.59.0

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/station-routes.d.ts

@@ -13,7 +13,7 @@
  * reading English.
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { Channels } from "./channels.ts";
+import { type Channels } from "./channels.ts";
 import type { StationRunner } from "./station-runner.ts";
 import { type Limits, type StationUsage } from "./station-metering.ts";
 import { type TrackFacts } from "./track-facts.ts";
@@ -98,6 +98,14 @@ declare function links(ctx: StationContext, station: Station, base?: string): {
     m3u: string;
     state: string;
 };
+/** Records a connection's bytes onto its channel's, through the listener it writes to. */
+export declare function clockedListener<T extends {
+    write(chunk: Buffer): boolean;
+}>(key: string, out: T): T & {
+    forget(): void;
+};
+/** Which byte of its channel a connection's player is on, `seconds` into what it was sent; null when unknown. */
+export declare function heardByte(key: string, seconds: number, kbps: number): number | null;
 export declare function publicView(ctx: StationContext, station: Station): PublicStation;
 /** Where the guide puts a station: composed by AI, shared by listeners, or the owner's radio or TV. */
 export type GuideGroup = "ai" | "shared" | "radio" | "tv";

package/dist/station-routes.js

@@ -1,3 +1,4 @@
+import { chunkStart } from "./channels.js";
 import { alertsFor } from "./station-metering.js";
 import { aiFromTags } from "./track-facts.js";
 import { quietDuringBreaks } from "./break-silence.js";
@@ -6,7 +7,7 @@ import { watchBase } from "./guide-rooms.js";
 import { radioPeers, radioStations } from "./radio-pages.js";
 import { StationError, channelOf, tokensMatch, } from "./stations.js";
 /** The three things a station's link opens. */
-const LISTEN = /^\/api\/v1\/stations\/([a-z0-9]{10})\/(stream|state|listen\.m3u|events|now|art|lyrics)$/;
+const LISTEN = /^\/api\/v1\/stations\/([a-z0-9]{10})\/(stream|state|listen\.m3u|events|now|art|lyrics|clock)$/;
 /** Whether this path is one a station's own link may open, without the server's key. */
 export function isStationListenPath(path) {
     return LISTEN.test(path) || path === "/api/v1/stations/guide";
@@ -28,6 +29,41 @@ function links(ctx, station, base = ctx.base) {
         state: `${at}/state?${query}`,
     };
 }
+const clocks = new Map();
+const MAX_CLOCKS = 5000;
+const MAX_RUNS = 500;
+/** Records a connection's bytes onto its channel's, through the listener it writes to. */
+export function clockedListener(key, out) {
+    const clock = { runs: [], local: 0, next: -1 };
+    if (clocks.size >= MAX_CLOCKS)
+        clocks.delete(clocks.keys().next().value);
+    clocks.set(key, clock);
+    return Object.assign(Object.create(out), {
+        write: (chunk) => {
+            const at = chunkStart(chunk);
+            // Silence written in a break's place carries no start: it stands for the break's bytes.
+            if (at !== undefined && at !== clock.next) {
+                clock.runs.push({ local: clock.local, global: at });
+                if (clock.runs.length > MAX_RUNS)
+                    clock.runs.shift();
+            }
+            clock.local += chunk.length;
+            clock.next = (at ?? clock.next) + chunk.length;
+            return out.write(chunk);
+        },
+        forget: () => { if (clocks.get(key) === clock)
+            clocks.delete(key); },
+    });
+}
+/** Which byte of its channel a connection's player is on, `seconds` into what it was sent; null when unknown. */
+export function heardByte(key, seconds, kbps) {
+    const clock = clocks.get(key);
+    if (!clock || !(seconds >= 0) || kbps <= 0)
+        return null;
+    const local = Math.min(clock.local, (seconds * kbps * 1000) / 8);
+    const run = clock.runs.findLast((one) => one.local <= local);
+    return run ? run.global + (local - run.local) : null;
+}
 /** The file on the air now, as the channel's own encoder last reported it. */
 function nowPlayingFile(ctx, station) {
     const info = ctx.channels.info(channelOf(station.id));
@@ -247,6 +283,26 @@ export async function handleStations(request, response, path, url, ctx) {
             ctx.json(response, 200, { lyrics: { title: lyrics.title, artist: lyrics.artist, text: lyrics.text, source: lyrics.source, language: lyrics.language, ...(lyrics.synced ? { synced: lyrics.synced } : {}) } });
             return true;
         }
+        if (what === "clock") {
+            // ?n= the stream's nonce, ?ct= the player's currentTime: the song and second being heard.
+            const key = `${station.id}:${url.searchParams.get("n") ?? ""}`;
+            const byte = heardByte(key, Number(url.searchParams.get("ct")), station.bitrate);
+            const place = byte === null ? null : ctx.channels.placeAt(channelOf(station.id), byte);
+            if (!place) {
+                ctx.json(response, 404, { error: "no clock for that stream", code: "not_found" });
+                return true;
+            }
+            const track = place.file ? (place.tags ?? ctx.trackFor(place.file)) : null;
+            const duration = place.file && ctx.durationOf ? ctx.durationOf(place.file) : 0;
+            ctx.json(response, 200, {
+                station: station.id,
+                break: place.file === "",
+                position: Math.round(place.position * 1000) / 1000,
+                duration: Math.round(duration * 10) / 10,
+                nowPlaying: track && (track.title || track.artist) ? { title: track.title, artist: track.artist, album: track.album } : null,
+            });
+            return true;
+        }
         if (what === "now") {
             const file = ctx.runner.observed(station.id) === "live" || ctx.runner.observed(station.id) === "recovering" ? nowPlayingFile(ctx, station) : "";
             ctx.json(response, 200, { station: station.id, facts: file && ctx.facts ? await ctx.facts(station, file).catch(() => null) : null });
@@ -315,9 +371,12 @@ export async function handleStations(request, response, path, url, ctx) {
                 pending: () => response.writableLength,
             }
             : response;
+        const nonce = /^[A-Za-z0-9_-]{1,40}$/.test(url.searchParams.get("n") ?? "") ? url.searchParams.get("n") : "";
+        const clocked = nonce && !station.video ? clockedListener(`${station.id}:${nonce}`, metered) : null;
+        const out = clocked ?? metered;
         const detach = spared
-            ? ctx.channels.listenWithoutBreaks(channelId, metered, station.bitrate, (out) => quietDuringBreaks(out, station.bitrate, () => true))
-            : ctx.channels.listen(channelId, metered);
+            ? ctx.channels.listenWithoutBreaks(channelId, out, station.bitrate, (quiet) => quietDuringBreaks(quiet, station.bitrate, () => true))
+            : ctx.channels.listen(channelId, out);
         if (detach === null) {
             response.end();
             return true;
@@ -332,6 +391,7 @@ export async function handleStations(request, response, path, url, ctx) {
             detach();
             untrack();
             left?.();
+            clocked?.forget();
         };
         request.on("close", leave);
         response.on("close", leave);

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.0",
+  "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();

package/src/channels.ts

@@ -282,6 +282,21 @@ export interface ChannelOptions {
   through?: ThroughProvider;
 }
 
+/**
+ * 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<Buffer, number>();
+
+/** The byte count a chunk began at, for one a list channel put out; undefined for any other. */
+export function chunkStart(chunk: Buffer): number | undefined {
+  return chunkStarts.get(chunk);
+}
+
+/** A list's dial: where in the byte count it began, and its list's clock. */
+interface Dial { base: number; input: PlaylistInputStream; kbps: number }
+
 /**
  * One live source, and its audience.
  *
@@ -338,6 +353,20 @@ export class Channel {
     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: number): { file: string; position: number; tags?: { title: string; artist: string; album: string } } | null {
+    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: string): { title: string; artist: string; album: string } | undefined {
     return this.playlistInput?.tags.get(file);
@@ -369,6 +398,8 @@ export class Channel {
   private breakOn = false;
   /** The last couple of minutes of a radio list without its breaks, for listenWithoutBreaks. */
   private music: Buffer[] = [];
+  /** The last few dials of a radio list, newest last, for placeAt(). */
+  private dials: Dial[] = [];
   private musicBytes = 0;
   private fragmentClock = new FragmentClock();
   private fragmentTimes = new WeakMap<Buffer, number>();
@@ -622,9 +653,16 @@ export class Channel {
         if (this.child !== child) return;
         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;
         } else this.breakOn = this.info.playlistAt === -1;
@@ -1460,6 +1498,11 @@ export class Channels {
     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: string, bytes: number): ReturnType<Channel["placeAt"]> {
+    return this.open.get(id)?.placeAt(bytes) ?? null;
+  }
+
   /** An entry's tags on a channel playing a list of files. */
   tagsOf(id: string, file: string): { title: string; artist: string; album: string } | undefined {
     return this.open.get(id)?.tagsOf(file);

package/src/follow-page.ts

@@ -112,7 +112,7 @@ export async function handleFollowPage(request: IncomingMessage, response: Serve
   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/src/label-routes.ts

@@ -11,6 +11,7 @@ import { createReadStream, statSync } from "node:fs";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { ROSTER, type AiLabel, type PublicArtist } from "./ai-label.ts";
 import { covers, PRICES, type GrantVerifier } from "./music-store.ts";
+import { serverId } from "./music-hub.ts";
 import { writeZip, zipSize } from "./zip-stream.ts";
 import { StationError } from "./stations.ts";
 import { adCsp, withPageAd, type GuideAds } from "./station-guide.ts";
@@ -30,7 +31,8 @@ export function isPublicLabelPath(path: string): boolean {
 
 /** nixamp.com's page that sells this: a song, an album or everything by the artist. */
 export function buyLink(site: string, server: string, kind: "song" | "album" | "artist", artist: string, album = "", n = 0): string {
-  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()}`;
 }