nixamp 0.57.1 → 0.58.1

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/guide-rooms.d.ts

@@ -32,6 +32,18 @@ export declare function roomAddress(input: string): {
 /** Where the guide links a room's page: config `watchBase`, NIXAMP_WATCH_BASE, else this server. */
 export declare function watchBase(fallback: string, env?: Record<string, string | undefined>): string;
 export declare const watchPage: (base: string, play: string) => string;
+/** A room's page under its name, on this server. */
+export declare const roomPage: (base: string, slug: string) => string;
+export declare const ROOM_PAGE: RegExp;
+export declare const ROOM_SUB: RegExp;
+export declare function isRoomPath(path: string): boolean;
+/**
+ * The rooms by name: "Dropkick Murphys" is /room/dropkick-murphys. Oldest
+ * first, so a name stays with the room that had it; a second one is -2.
+ */
+export declare function roomSlugs(rooms: GuideRoom[]): Map<string, GuideRoom>;
+/** A room's name here, or "". */
+export declare function roomSlugOf(slugs: Map<string, GuideRoom>, id: string): string;
 export declare class RoomStore {
     private readonly file;
     private rooms;
@@ -53,6 +65,9 @@ export interface RoomState {
         title: string;
         artist: string;
     } | null;
+    /** A folder or a playlist (more than one file): HLS plays it better than the endless MP4. */
+    folder?: boolean;
+    album?: string;
 }
 /** Asks a room's own server what is on it: its channel list for a channel, the stream's headers for the live stream. */
 export declare class RoomProbe {
@@ -89,3 +104,30 @@ export interface RoomContext {
 }
 /** Answers /api/v1/guide/rooms; false when the path is not one. */
 export declare function handleRooms(request: IncomingMessage, response: ServerResponse, path: string, ctx: RoomContext): Promise<boolean>;
+export interface RoomProxyContext {
+    store: RoomStore;
+    probe: RoomProbe;
+    /** Why an address may not be fetched from this machine, or "" (as the probe's). */
+    refuse: (link: string) => Promise<string>;
+    json: (response: ServerResponse, status: number, body: unknown) => void;
+    fetcher?: typeof fetch;
+}
+/** What /room/<name>/state answers: the room as its page shows it, no address or key. */
+export interface RoomView {
+    name: string;
+    kind: "audio" | "video";
+    live: boolean;
+    folder: boolean;
+    hls: boolean;
+    title: string;
+    artist: string;
+    album: string;
+}
+/** The room's origin and key, gone from a text answer (a playlist, an error). */
+export declare function roomRewriter(play: string, slug: string): (text: string) => string;
+/**
+ * Answers /room/<name>/state, /stream and /hls/<file>, asked of the room's
+ * server with its key; false when the path is not one. The page itself is
+ * the caller's (it is the built watch page).
+ */
+export declare function handleRoomProxy(request: IncomingMessage, response: ServerResponse, path: string, ctx: RoomProxyContext): Promise<boolean>;

package/dist/guide-rooms.js

@@ -5,16 +5,20 @@
  * a Share or a "?play=" link carries, `https://host:port/api/channels/<id>?k=KEY`
  * or `https://host:port/api/live?k=KEY`. A nixamp.com member publishes one with
  * a rights basis, as a station is published; the guide lists it beside the
- * stations, and its card opens /watch?play=<that address>, which plays it as
- * a film or as radio, whichever it carries.
+ * stations; its card opens /room/<name>, which plays it as a film or as
+ * radio, whichever it carries.
  *
- * Nothing here plays anything: the room's own server does, and this only asks
- * it, now and then, whether the room is on the air and what is on it.
+ * /room/<name> is the room under a readable name on this server, which asks
+ * the room's own server for it with the key held here: the page, its state,
+ * the stream and HLS all come from this origin, so no page names the machine
+ * the room is on or carries its key. The old /watch?play=<address> links
+ * still play, straight from the room's server.
  */
 import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { readConfig } from "./library.js";
+import { slugify } from "./radio-slug.js";
 /** Why a room may be broadcast, the same five reasons a station gives. */
 export const ROOM_BASES = ["owned", "permission", "licensed", "creative-commons", "public-domain"];
 /** Rooms one member may have on the guide at once, and rooms on it in all. */
@@ -62,6 +66,36 @@ export function watchBase(fallback, env = process.env) {
     return /^https?:\/\/[^\s"<>]+$/.test(chosen) ? chosen : fallback;
 }
 export const watchPage = (base, play) => `${base}/watch?play=${encodeURIComponent(play)}`;
+/** A room's page under its name, on this server. */
+export const roomPage = (base, slug) => `${base}/room/${slug}`;
+export const ROOM_PAGE = /^\/room\/([A-Za-z0-9_-]{1,60})\/?$/;
+export const ROOM_SUB = /^\/room\/([a-z0-9-]{1,60})\/(state|stream|hls\/[A-Za-z0-9._-]{1,64})$/;
+export function isRoomPath(path) {
+    return ROOM_PAGE.test(path) || ROOM_SUB.test(path);
+}
+/**
+ * The rooms by name: "Dropkick Murphys" is /room/dropkick-murphys. Oldest
+ * first, so a name stays with the room that had it; a second one is -2.
+ */
+export function roomSlugs(rooms) {
+    const out = new Map();
+    const sorted = [...rooms].sort((a, b) => (a.publishedAt - b.publishedAt) || a.id.localeCompare(b.id));
+    for (const room of sorted) {
+        const base = slugify(room.name) || "room";
+        let slug = base;
+        for (let n = 2; out.has(slug); n += 1)
+            slug = `${base}-${n}`;
+        out.set(slug, room);
+    }
+    return out;
+}
+/** A room's name here, or "". */
+export function roomSlugOf(slugs, id) {
+    for (const [slug, one] of slugs)
+        if (one.id === id)
+            return slug;
+    return "";
+}
 export class RoomStore {
     file;
     rooms = [];
@@ -149,6 +183,8 @@ export class RoomProbe {
                 name: String(row.name ?? address.channel).replace(/\/+$/, "").slice(0, 120),
                 kind: row.kind === "video" ? "video" : "audio",
                 nowPlaying: tags && (tags.title || tags.artist) ? { title: String(tags.title ?? ""), artist: String(tags.artist ?? "") } : null,
+                folder: address.channel.startsWith("folder-") || (Array.isArray(row.playlist) && row.playlist.length > 1),
+                album: String(tags?.album ?? "").slice(0, 200),
             };
         }
         // The live stream: on the air when it answers with media.
@@ -160,7 +196,7 @@ export class RoomProbe {
             controller.abort();
             if (!answer.ok)
                 return null;
-            return { live: true, name: "Live", kind: type.startsWith("video/") ? "video" : "audio", nowPlaying: null };
+            return { live: true, name: "Live", kind: type.startsWith("video/") ? "video" : "audio", nowPlaying: null, folder: false, album: "" };
         }
         finally {
             clearTimeout(timer);
@@ -169,6 +205,7 @@ export class RoomProbe {
 }
 /** The rooms as guide cards: the page to open, on the air or not, and what is on. */
 export async function roomEntries(store, probe, base) {
+    const slugs = roomSlugs(store.list());
     return Promise.all(store.list().map(async (room) => {
         const state = await probe.state(room.play);
         return {
@@ -177,7 +214,7 @@ export async function roomEntries(store, probe, base) {
             kind: state?.kind ?? room.kind,
             group: "rooms",
             state: state?.live ? "live" : "offline",
-            page: watchPage(base, room.play),
+            page: roomPage(base, roomSlugOf(slugs, room.id) || room.id),
             nowPlaying: state?.nowPlaying ?? null,
         };
     }));
@@ -245,7 +282,7 @@ export async function handleRooms(request, response, path, ctx) {
         const title = typeof body?.title === "string" ? body.title.trim().slice(0, 120) : "";
         const note = typeof body?.note === "string" ? body.note.trim().slice(0, 300) : "";
         const room = ctx.store.put({ play: address.play, name: title || state.name, kind: state.kind, basis, note, by: taken?.by ?? by });
-        ctx.json(response, 200, { room: { id: room.id, name: room.name, kind: room.kind, basis: room.basis }, page: watchPage(ctx.base, room.play) });
+        ctx.json(response, 200, { room: { id: room.id, name: room.name, kind: room.kind, basis: room.basis }, page: roomPage(ctx.base, roomSlugOf(roomSlugs(ctx.store.list()), room.id) || room.id) });
         return true;
     }
     const one = /^\/api\/v1\/guide\/rooms\/([A-Za-z0-9_-]{1,32})$/.exec(path);
@@ -262,3 +299,116 @@ export async function handleRooms(request, response, path, ctx) {
     ctx.json(response, 405, { error: "method not allowed", code: "method_not_allowed" });
     return true;
 }
+/** The room's origin and key, gone from a text answer (a playlist, an error). */
+export function roomRewriter(play, slug) {
+    const address = roomAddress(play);
+    if (!address)
+        return (text) => text;
+    const channelPath = address.channel !== null ? `/api/channels/${address.channel}` : "/api/live";
+    return (text) => text
+        .split(`${address.origin}${channelPath}/hls/`).join(`/room/${slug}/hls/`)
+        .split(`${address.origin}${channelPath}`).join(`/room/${slug}/stream`)
+        .split(address.origin).join("")
+        .split(`?k=${address.key}&`).join("?").split(`&k=${address.key}`).join("").split(`?k=${address.key}`).join("")
+        .split(address.key).join("");
+}
+/**
+ * Answers /room/<name>/state, /stream and /hls/<file>, asked of the room's
+ * server with its key; false when the path is not one. The page itself is
+ * the caller's (it is the built watch page).
+ */
+export async function handleRoomProxy(request, response, path, ctx) {
+    const sub = ROOM_SUB.exec(path);
+    if (!sub)
+        return false;
+    const method = request.method ?? "GET";
+    if (method !== "GET" && method !== "HEAD") {
+        ctx.json(response, 405, { error: "a room's page can watch, not drive", code: "method_not_allowed" });
+        return true;
+    }
+    const slug = sub[1];
+    const room = roomSlugs(ctx.store.list()).get(slug);
+    const address = room ? roomAddress(room.play) : null;
+    if (!room || !address) {
+        ctx.json(response, 404, { error: "no room by that name", code: "not_found" });
+        return true;
+    }
+    const what = sub[2];
+    if (what === "state") {
+        const state = await ctx.probe.state(room.play);
+        if (!state) {
+            ctx.json(response, 404, { error: "that room is not on the air", code: "unavailable" });
+            return true;
+        }
+        const view = {
+            name: room.name || state.name,
+            kind: state.kind,
+            live: state.live,
+            folder: state.folder === true,
+            hls: address.channel !== null,
+            title: state.nowPlaying?.title ?? "",
+            artist: state.nowPlaying?.artist ?? "",
+            album: state.album ?? "",
+        };
+        response.setHeader("cache-control", "no-store");
+        ctx.json(response, 200, view);
+        return true;
+    }
+    let upstream;
+    if (what === "stream")
+        upstream = address.play;
+    else {
+        if (address.channel === null) {
+            ctx.json(response, 404, { error: "the live stream has no HLS", code: "not_found" });
+            return true;
+        }
+        upstream = `${address.origin}/api/channels/${address.channel}/${what}?k=${address.key}`;
+    }
+    if ((await ctx.refuse(upstream).catch(() => "refused")) !== "") {
+        ctx.json(response, 502, { error: "that room's server cannot be reached from here", code: "upstream" });
+        return true;
+    }
+    const stop = new AbortController();
+    response.on("close", () => stop.abort());
+    const answer = await (ctx.fetcher ?? fetch)(upstream, {
+        method, signal: stop.signal, redirect: "error",
+        headers: { ...(request.headers.range ? { range: String(request.headers.range) } : {}), accept: String(request.headers.accept ?? "*/*") },
+    }).catch(() => null);
+    if (!answer) {
+        ctx.json(response, 502, { error: "that room's server did not answer", code: "upstream" });
+        return true;
+    }
+    const type = answer.headers.get("content-type") ?? "";
+    const text = /json|mpegurl|^text\//i.test(type);
+    const headers = { "cache-control": "no-store", "x-content-type-options": "nosniff" };
+    for (const name of ["content-type", "content-length", "content-range", "accept-ranges", "x-accel-buffering", "retry-after"]) {
+        const value = answer.headers.get(name);
+        if (value && !(text && name === "content-length"))
+            headers[name] = value;
+    }
+    if (text) {
+        // A playlist (or an error) is small: read whole, the room's address and key taken out.
+        const body = roomRewriter(room.play, slug)(await answer.text().catch(() => ""));
+        response.writeHead(answer.status, { ...headers, "content-length": String(Buffer.byteLength(body)) });
+        response.end(method === "HEAD" ? undefined : body);
+        return true;
+    }
+    response.writeHead(answer.status, headers);
+    if (!answer.body || method === "HEAD") {
+        response.end();
+        return true;
+    }
+    try {
+        for await (const chunk of answer.body) {
+            if (response.destroyed)
+                break;
+            if (!response.write(chunk))
+                await new Promise((done) => { response.once("drain", done); response.once("close", done); });
+        }
+    }
+    catch {
+        // The viewer left, or the room's server did.
+    }
+    response.end();
+    return true;
+}

package/dist/radio-pages.d.ts

@@ -188,9 +188,9 @@ export interface StationFace {
     description?: string;
     video?: boolean;
 }
-export declare function stationHead(station: StationFace, slug: string, base: string): string;
+export declare function stationHead(station: StationFace, slug: string, base: string, path?: string): string;
 /** The built station page (or the inline one) as /radio/<name> serves it: its head, the header, indexable. */
-export declare function asRadioPage(html: string, station: StationFace, slug: string, base: string, nav: string): string;
+export declare function asRadioPage(html: string, station: StationFace, slug: string, base: string, nav: string, path?: string): string;
 /** A station another server lists on this guide (a guide peer), as /radio reaches it. */
 export interface PeerRadio {
     origin: string;

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)?\/?$/;
@@ -388,8 +388,8 @@ export function renderAlbum(catalogue, album, ctx) {
 export function renderMissing(what, base, nav) {
     return document({ title: `Not here · live.streaming`, description: "Nothing by that name is on the air here.", url: `${base}/radio` }, nav, `<h1>No ${escape(what)} by that name</h1><p class="lead">Nothing by that name is on the air here now. <a href="/radio">See every station</a>.</p>`);
 }
-export function stationHead(station, slug, base) {
-    const url = `${base}/radio/${slug}`;
+export function stationHead(station, slug, base, path = `/radio/${slug}`) {
+    const url = `${base}${path}`;
     const description = station.description || `${station.name}, live now. Free to listen; tap the artist or album on the air to see more.`;
     return `<title>${escape(station.name)} · live.streaming</title>
     <meta name="description" content="${escape(description)}" />
@@ -403,9 +403,9 @@ export function stationHead(station, slug, base) {
     <style>${NAV_STYLE}</style>`;
 }
 /** The built station page (or the inline one) as /radio/<name> serves it: its head, the header, indexable. */
-export function asRadioPage(html, station, slug, base, nav) {
+export function asRadioPage(html, station, slug, base, nav, path) {
     return html
-        .replace(/<title>[^<]*<\/title>/, stationHead(station, slug, base))
+        .replace(/<title>[^<]*<\/title>/, stationHead(station, slug, base, path))
         .replace(/\s*<meta name="robots" content="noindex"\s*\/?>/, "")
         .replace(/<body>/, `<body>\n${nav}`);
 }

package/dist/server.js

@@ -73,7 +73,7 @@ import { LyricsFinder } from "./lyrics.js";
 import { LyricsPublisher } from "./lyrics-publish.js";
 import { aiKey } from "./ai-keys.js";
 import { STATION_APP_CSP, STATION_PAGE, STATION_PAGE_CSP, STATION_PAGE_HTML, WATCH_APP_CSP } from "./station-page.js";
-import { handleRooms, RoomProbe, roomEntries, RoomStore, watchBase } from "./guide-rooms.js";
+import { handleRoomProxy, handleRooms, isRoomPath, ROOM_PAGE, roomAddress, RoomProbe, roomEntries, roomSlugOf, roomSlugs, RoomStore, watchBase } from "./guide-rooms.js";
 import { handleVods, VodProbe, vodEntries, VodStore, vodView } from "./guide-vods.js";
 import { withPitFooter } from "./pit-footer.js";
 import { handleFollowPage } from "./follow-page.js";
@@ -2317,6 +2317,8 @@ export function createHandler(engine, options) {
             !/^\/watch\/[a-z0-9]{10}$/.test(path) &&
             // A live room's page: the room's own key travels in ?play=, checked by its server.
             !(path === "/watch" && Boolean(options.stations?.rooms)) &&
+            // A live room under its name here, asked of its server with the key held here (guide-rooms.ts).
+            !(isRoomPath(path) && Boolean(options.stations?.rooms)) &&
             // Live rooms on the guide: listed for anybody, published by a member (guide-rooms.ts).
             !((path === "/api/v1/guide/rooms" || path.startsWith("/api/v1/guide/rooms/")) && Boolean(options.stations?.rooms)) &&
             // On demand: a file's page and the guide's list of them (guide-vods.ts); the file's own key travels in its play address.
@@ -2546,7 +2548,56 @@ export function createHandler(engine, options) {
         // A live room's page: /watch?play=<a nixamp server's channel or live
         // stream address>. The built page plays it in @profullstack/player, as a
         // film or as radio; nothing about the room passes through here.
+        if (options.stations?.rooms && isRoomPath(path)) {
+            const rooms = options.stations.rooms;
+            if (await handleRoomProxy(request, response, path, { store: rooms.store, probe: rooms.probe, refuse: (link) => refusedDestination(link), json }))
+                return;
+            const asked = ROOM_PAGE.exec(path)[1];
+            const slugs = roomSlugs(rooms.store.list());
+            const room = slugs.get(asked);
+            if (!room) {
+                // A room's id finds its name: /room/<id> goes to /room/<name>.
+                const named = roomSlugOf(slugs, asked);
+                if (named) {
+                    response.writeHead(301, { location: `/room/${named}`, "cache-control": "public, max-age=300" });
+                    response.end();
+                    return;
+                }
+            }
+            if (request.method !== "GET" && request.method !== "HEAD") {
+                json(response, 405, { error: "method not allowed", code: "method_not_allowed" });
+                return;
+            }
+            const built = web !== null && isFile(join(web, "watch.html")) ? readFileSync(join(web, "watch.html"), "utf8") : null;
+            if (!built) {
+                json(response, 404, { error: "this server was started without its web pages" });
+                return;
+            }
+            const base = radioBaseFor(request, options.stations.publicBase?.() ?? "");
+            const nav = radioNav(guideHosts().has(requestHost) ? "/" : "/guide", "live");
+            const face = room ? { name: room.name, description: room.note || `${room.name}, live now on live.streaming.`, video: room.kind === "video" } : { name: "No such room" };
+            response.writeHead(room ? 200 : 404, {
+                "content-type": "text/html; charset=utf-8",
+                "cache-control": "no-cache",
+                "content-security-policy": adCsp(WATCH_APP_CSP, guideAds()),
+                "referrer-policy": "strict-origin-when-cross-origin",
+                "x-content-type-options": "nosniff",
+            });
+            response.end(request.method === "HEAD" ? undefined : withPageAd(asRadioPage(built, face, asked, base, nav, `/room/${asked}`), guideAds()));
+            return;
+        }
         if (options.stations?.rooms && path === "/watch" && (request.method === "GET" || request.method === "HEAD")) {
+            // A room published here plays under its name: the old link keeps working and lands there.
+            const play = roomAddress(url.searchParams.get("play") ?? "");
+            if (play) {
+                const slugs = roomSlugs(options.stations.rooms.store.list());
+                const published = [...slugs].find(([, one]) => one.play === play.play)?.[0];
+                if (published) {
+                    response.writeHead(302, { location: `/room/${published}`, "cache-control": "no-store", "referrer-policy": "no-referrer" });
+                    response.end();
+                    return;
+                }
+            }
             const built = web !== null && isFile(join(web, "watch.html")) ? withPageAd(readFileSync(join(web, "watch.html"), "utf8"), guideAds()) : null;
             if (!built) {
                 json(response, 404, { error: "this server was started without its web pages" });

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);