nixamp 0.57.1 → 0.58.0

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

@@ -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/package.json

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

package/src/guide-rooms.ts

@@ -5,11 +5,14 @@
  * 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";
@@ -17,6 +20,7 @@ import { randomBytes } from "node:crypto";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { readConfig } from "./library.ts";
 import type { GuideEntry } from "./station-guide.ts";
+import { slugify } from "./radio-slug.ts";
 
 /** Why a room may be broadcast, the same five reasons a station gives. */
 export const ROOM_BASES = ["owned", "permission", "licensed", "creative-commons", "public-domain"] as const;
@@ -74,6 +78,38 @@ export function watchBase(fallback: string, env: Record<string, string | undefin
 
 export const watchPage = (base: string, play: string): string => `${base}/watch?play=${encodeURIComponent(play)}`;
 
+/** A room's page under its name, on this server. */
+export const roomPage = (base: string, slug: string): string => `${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: string): boolean {
+  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: GuideRoom[]): Map<string, GuideRoom> {
+  const out = new Map<string, GuideRoom>();
+  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: Map<string, GuideRoom>, id: string): string {
+  for (const [slug, one] of slugs) if (one.id === id) return slug;
+  return "";
+}
+
 export class RoomStore {
   private rooms: GuideRoom[] = [];
   constructor(private readonly file: string) {
@@ -128,6 +164,9 @@ export interface RoomState {
   name: string;
   kind: "audio" | "video";
   nowPlaying: { 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;
 }
 
 interface ChannelRow {
@@ -135,7 +174,8 @@ interface ChannelRow {
   name?: string;
   kind?: string;
   live?: boolean;
-  codecs?: { tags?: { title?: string; artist?: string } };
+  playlist?: unknown[];
+  codecs?: { tags?: { title?: string; artist?: string; 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. */
@@ -175,6 +215,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.
@@ -185,7 +227,7 @@ export class RoomProbe {
       const type = answer.headers.get("content-type") ?? "";
       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);
     }
@@ -194,6 +236,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: RoomStore, probe: RoomProbe, base: string): Promise<GuideEntry[]> {
+  const slugs = roomSlugs(store.list());
   return Promise.all(store.list().map(async (room) => {
     const state = await probe.state(room.play);
     return {
@@ -202,7 +245,7 @@ export async function roomEntries(store: RoomStore, probe: RoomProbe, base: stri
       kind: state?.kind ?? room.kind,
       group: "rooms" as const,
       state: state?.live ? "live" : "offline",
-      page: watchPage(base, room.play),
+      page: roomPage(base, roomSlugOf(slugs, room.id) || room.id),
       nowPlaying: state?.nowPlaying ?? null,
     };
   }));
@@ -281,7 +324,7 @@ export async function handleRooms(request: IncomingMessage, response: ServerResp
     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);
@@ -298,3 +341,134 @@ export async function handleRooms(request: IncomingMessage, response: ServerResp
   ctx.json(response, 405, { error: "method not allowed", code: "method_not_allowed" });
   return true;
 }
+
+// --- /room/<name>: the room through this server ----------------------------------
+
+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 function roomRewriter(play: string, slug: string): (text: string) => string {
+  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: IncomingMessage, response: ServerResponse, path: string, ctx: RoomProxyContext): Promise<boolean> {
+  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: RoomView = {
+      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: string;
+  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: Record<string, string> = { "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 as unknown as AsyncIterable<Uint8Array>) {
+      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;
+}