nixamp 0.55.2 → 0.57.0

package/dist/station-runner.js

@@ -1,4 +1,6 @@
 import { EXCLUDE_AFTER, OFFLINE_RETRY_MS, RECOVERY_DELAYS_MS, StationError, channelOf, insideRoots, spreadByArtist, stationOfChannel, } from "./stations.js";
+/** How long a listener waking a station is held for its first bytes. */
+export const WAKE_WAIT_MS = 10_000;
 /**
  * Who a file is by when the tags do not say: "Artist - Album/track" names
  * them in the folder, and "Artist/Album/track" one folder up.
@@ -26,6 +28,14 @@ export class StationRunner {
     down = new Map();
     /** The server is going down: its channels end because it is, not because a station failed. */
     closing = false;
+    /** Wanted on, with nobody listening: no channel until somebody does. */
+    asleep = new Set();
+    /** For a station asleep: the rest of the pass it was playing, in order. */
+    parked = new Map();
+    /** Since when a station's channel has had nobody on it. */
+    quietSince = new Map();
+    waking = new Map();
+    idleTimer = null;
     constructor(deps) {
         this.deps = deps;
     }
@@ -35,7 +45,21 @@ export class StationRunner {
      * busy day every station said "something keeps stopping it".
      */
     close() {
+        if (!this.closing) {
+            // Where each station on the air was, so after an update it wakes on
+            // the next track with its break clock, as it would from a sleep.
+            for (const station of this.deps.store.list()) {
+                if (station.desired !== "running" || this.asleep.has(station.id))
+                    continue;
+                const point = this.deps.channels.resumePoint(channelOf(station.id));
+                if (point)
+                    this.deps.store.setResume(station.id, { after: point.file || station.resume?.after || "", sinceBreak: point.sinceBreak });
+            }
+        }
         this.closing = true;
+        if (this.idleTimer)
+            clearInterval(this.idleTimer);
+        this.idleTimer = null;
         for (const timer of this.timers.values())
             clearTimeout(timer);
         this.timers.clear();
@@ -60,6 +84,7 @@ export class StationRunner {
             throw new StationError("nothing_playable", "none of this station's files can be found in the library", 409);
         }
         this.deps.store.setDesired(id, "running", this.now());
+        this.asleep.delete(id);
         this.cancelRecovery(id);
         this.attempts.delete(id);
         await this.launch(id);
@@ -68,6 +93,9 @@ export class StationRunner {
     /** Wanted off, and taken off. Stays off across restarts. */
     stop(id) {
         const station = this.deps.store.setDesired(id, "stopped", this.now());
+        this.asleep.delete(id);
+        this.parked.delete(id);
+        this.quietSince.delete(id);
         this.down.delete(id);
         this.cancelRecovery(id);
         this.attempts.delete(id);
@@ -83,6 +111,11 @@ export class StationRunner {
     skip(id) {
         if (!this.deps.store.get(id))
             throw new StationError("not_found", "no such station", 404);
+        // Asleep, the next track is the one after the one it will wake on.
+        if (this.asleep.has(id)) {
+            this.parked.get(id)?.shift();
+            return;
+        }
         if (!this.deps.channels.skip(channelOf(id)))
             throw new StationError("not_live", "the station is not playing", 409);
     }
@@ -96,13 +129,162 @@ export class StationRunner {
     }
     /** Put back every station that was running when this server last stopped. */
     restore() {
+        // Asleep until somebody listens, when stations sleep at all: putting
+        // every one on at once, to have each go back to sleep a minute later,
+        // is a storm of ffmpeg for nobody.
+        const sleepy = (this.deps.idleSeconds?.() ?? 0) > 0;
         for (const station of this.deps.store.list()) {
             if (station.desired !== "running")
                 continue;
+            if (sleepy) {
+                this.asleep.add(station.id);
+                continue;
+            }
             this.log(`  Putting station "${station.name}" back on the air.`);
             void this.launch(station.id);
         }
     }
+    /** Whether a station is asleep: wanted on, on the air to the guide, with no channel until somebody listens. */
+    isSleeping(id) {
+        return this.asleep.has(id);
+    }
+    /** The file a sleeping station would wake on, "" when it cannot say. */
+    nextUp(id) {
+        if (!this.asleep.has(id))
+            return "";
+        const parked = this.parked.get(id)?.[0];
+        if (parked)
+            return parked;
+        const station = this.deps.store.get(id);
+        if (!station || station.shuffle || !station.resume?.after)
+            return "";
+        const files = station.items;
+        const at = files.indexOf(station.resume.after);
+        return at >= 0 ? files[at + 1] ?? "" : "";
+    }
+    /** Look every so often for stations nobody is listening to. */
+    watchIdle(everyMs = 5_000) {
+        if (this.idleTimer)
+            return;
+        this.idleTimer = setInterval(() => this.sweep(), everyMs);
+        this.idleTimer.unref?.();
+    }
+    /**
+     * Put to sleep every station whose channel has had nobody on it for the
+     * idle time. Anybody attached counts: a listener on the link or /radio, a
+     * class or room relaying it, an HLS packager, a peer pulling it. The
+     * now-playing events alone do not.
+     */
+    sweep() {
+        const idle = this.deps.idleSeconds?.() ?? 0;
+        if (idle <= 0 || this.closing)
+            return;
+        const now = this.now();
+        for (const station of this.deps.store.list()) {
+            const id = station.id;
+            const channelId = channelOf(id);
+            if (station.desired !== "running" || this.asleep.has(id) || this.starting.has(id) || !this.deps.channels.has(channelId)) {
+                this.quietSince.delete(id);
+                continue;
+            }
+            if (this.deps.channels.listenersOf(channelId) > 0) {
+                this.quietSince.delete(id);
+                continue;
+            }
+            const since = this.quietSince.get(id);
+            if (since === undefined)
+                this.quietSince.set(id, now);
+            else if (now - since >= idle * 1000)
+                this.sleep(id);
+        }
+    }
+    /** Off the air for now, still wanted on: remembers where it was, and is not a failure. */
+    sleep(id) {
+        const station = this.deps.store.get(id);
+        const channelId = channelOf(id);
+        if (!station || station.desired !== "running" || this.asleep.has(id))
+            return;
+        const point = this.deps.channels.resumePoint(channelId);
+        this.deps.store.setResume(id, {
+            after: point?.file || station.resume?.after || "",
+            sinceBreak: point ? point.sinceBreak : station.resume?.sinceBreak ?? 0,
+        });
+        this.parked.set(id, point?.upcoming ?? []);
+        this.asleep.add(id);
+        this.quietSince.delete(id);
+        this.cancelRecovery(id);
+        this.attempts.delete(id);
+        this.errors.delete(id);
+        this.down.delete(id);
+        if (this.deps.channels.has(channelId)) {
+            this.stopping.add(channelId);
+            this.deps.channels.stop(channelId);
+        }
+        this.log(`  Station "${station.name}" is asleep until somebody listens.`);
+    }
+    /** On again for a listener, if it was asleep. True when its channel is up (or coming up). */
+    wake(id) {
+        const pending = this.waking.get(id);
+        if (pending)
+            return pending;
+        if (!this.asleep.has(id))
+            return Promise.resolve(this.deps.channels.has(channelOf(id)) || this.starting.has(id));
+        this.asleep.delete(id);
+        this.quietSince.delete(id);
+        const station = this.deps.store.get(id);
+        if (station)
+            this.log(`  Station "${station.name}" woke for a listener.`);
+        const woken = this.launch(id).finally(() => this.waking.delete(id));
+        this.waking.set(id, woken);
+        return woken;
+    }
+    /**
+     * Wake it if it is asleep, and wait (up to `timeoutMs`) for its first
+     * bytes, so a listener hears it start rather than a stream that ends.
+     * True when the channel is up.
+     */
+    async awake(id, timeoutMs = WAKE_WAIT_MS, gone = () => false) {
+        const channelId = channelOf(id);
+        const deadline = Date.now() + timeoutMs;
+        const woke = this.asleep.has(id) || this.waking.has(id);
+        if (!woke)
+            return this.deps.channels.has(channelId);
+        let timer;
+        const up = await Promise.race([
+            this.wake(id),
+            new Promise((done) => { timer = setTimeout(() => done(false), timeoutMs); }),
+        ]);
+        clearTimeout(timer);
+        if (!up && !this.deps.channels.has(channelId))
+            return false;
+        while (!this.deps.channels.flowing(channelId) && Date.now() < deadline && !gone()) {
+            if (!this.deps.channels.has(channelId) && !this.starting.has(id))
+                return false;
+            await new Promise((done) => setTimeout(done, 50));
+        }
+        return this.deps.channels.has(channelId);
+    }
+    /**
+     * Where a launch picks up: the rest of the pass it slept in, or (after the
+     * server restarted) the files after the one it was on; and the break
+     * clock. Taken once, by the next launch.
+     */
+    takeResume(id, station, files) {
+        const parked = this.parked.get(id);
+        this.parked.delete(id);
+        let upcoming = parked && parked.length > 0 ? parked : null;
+        const after = station.resume?.after ?? "";
+        if (!parked && after && !station.shuffle) {
+            const at = files.indexOf(after);
+            if (at >= 0 && at + 1 < files.length)
+                upcoming = files.slice(at + 1);
+        }
+        const sinceBreak = station.resume?.sinceBreak ?? 0;
+        // Used once: a recovery later is a start like any other.
+        if (station.resume)
+            this.deps.store.setResume(id, null);
+        return { upcoming, sinceBreak };
+    }
     async launch(id) {
         const station = this.deps.store.get(id);
         if (!station || station.desired !== "running")
@@ -118,6 +300,10 @@ export class StationRunner {
         }
         this.starting.add(id);
         const store = this.deps.store;
+        const resume = this.takeResume(id, station, files);
+        // The first pass after a sleep is the rest of the one it slept in.
+        let carryOn = resume.upcoming;
+        let clock = resume.sinceBreak;
         try {
             const ok = await this.deps.pull(channelId, station.name, files, {
                 audioBitrate: station.bitrate,
@@ -125,9 +311,19 @@ export class StationRunner {
                     repeat: station.repeat,
                     passOver: true,
                     // Read at every pass, so turning shuffle on or off lands then.
-                    order: (length, files) => (store.get(id)?.shuffle
-                        ? spreadByArtist(files, (file) => this.deps.artistOf?.(file) || artistFromPath(file))
-                        : [...Array(length).keys()]),
+                    order: (length, files) => {
+                        if (carryOn) {
+                            const wanted = carryOn;
+                            carryOn = null;
+                            const index = new Map(files.map((file, at) => [file, at]));
+                            const picked = wanted.map((file) => index.get(file)).filter((at) => at !== undefined && !store.isExcluded(id, files[at]));
+                            if (picked.length > 0)
+                                return picked;
+                        }
+                        return store.get(id)?.shuffle
+                            ? spreadByArtist(files, (file) => this.deps.artistOf?.(file) || artistFromPath(file))
+                            : [...Array(length).keys()];
+                    },
                     // Read at every track, so an edit lands on the next one.
                     current: () => {
                         const now = store.get(id);
@@ -137,7 +333,12 @@ export class StationRunner {
                     // Read at every boundary, so setting breaks on a running station
                     // lands without a restart; 0 is none.
                     ...(this.deps.breaks
-                        ? { breaks: { everySeconds: () => store.get(id)?.breaksEvery ?? 0, next: () => this.deps.breaks(station.video) } }
+                        ? { breaks: {
+                                everySeconds: () => store.get(id)?.breaksEvery ?? 0,
+                                next: () => this.deps.breaks(station.video),
+                                // Once: a redial later in the day starts its own clock, as it always has.
+                                sinceBreak: () => { const was = clock; clock = 0; return was; },
+                            } }
                         : {}),
                     onFailure: ({ file, reason }) => {
                         this.errors.set(id, reason);
@@ -218,6 +419,9 @@ export class StationRunner {
             return "stopped";
         if (station.desired === "stopped")
             return "stopped";
+        // On the air to anyone asking: the first listener wakes it.
+        if (this.asleep.has(id))
+            return "live";
         if (this.starting.has(id))
             return "starting";
         const info = this.deps.channels.info(channelOf(id));

package/dist/stations.d.ts

@@ -41,6 +41,15 @@ export interface Station {
     idempotencyKey: string;
     createdAt: number;
     updatedAt: number;
+    /**
+     * Where it was when it last went to sleep with nobody listening: the file
+     * that was on, so it carries on after it, and the seconds of airtime since
+     * its last break, so breaks keep their spacing across sleeps.
+     */
+    resume?: {
+        after: string;
+        sinceBreak: number;
+    };
 }
 /** Times an item may fail in a row before rotation leaves it out. */
 export declare const EXCLUDE_AFTER = 3;
@@ -97,6 +106,11 @@ export declare class StationStore {
     /** Name, words, files and rotation. Who may listen is changed by publish/unpublish. */
     update(id: string, input: StationInput, items: string[] | null, now?: number): Station;
     remove(id: string): boolean;
+    /** Where it was when it went to sleep (Station.resume); null forgets it. */
+    setResume(id: string, resume: {
+        after: string;
+        sinceBreak: number;
+    } | null): void;
     setDesired(id: string, desired: Desired, now?: number): Station;
     /**
      * Who may hear it, and whether the directory lists it. Public needs a

package/dist/stations.js

@@ -262,6 +262,17 @@ export class StationStore {
             this.save();
         return had;
     }
+    /** Where it was when it went to sleep (Station.resume); null forgets it. */
+    setResume(id, resume) {
+        const station = this.stations.get(id);
+        if (!station)
+            return;
+        if (resume)
+            station.resume = { after: resume.after, sinceBreak: Math.max(0, Math.round(resume.sinceBreak)) };
+        else
+            delete station.resume;
+        this.save();
+    }
     setDesired(id, desired, now = Date.now()) {
         const station = this.require(id);
         station.desired = desired;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.55.2",
+  "version": "0.57.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

@@ -34,6 +34,7 @@ import { aiKey } from "./ai-keys.ts";
 import { composerFromEnv, OutOfCredit, type Composer } from "./ai-radio.ts";
 import { askJson, hasModel } from "./ai-text.ts";
 import { formatLrc, type SyncedLine } from "./lyrics.ts";
+import { bandMarkdown, castLine, inventMembers, readMembers, writeMembers, type Member } from "./label-profiles.ts";
 import type { LibraryIndex, Probed } from "./library-index.ts";
 import type { StationRunner } from "./station-runner.ts";
 import { StationError, type StationStore } from "./stations.ts";
@@ -94,6 +95,8 @@ export interface LabelArtist {
   themes: string;
   enabled: boolean;
   albums: LabelAlbum[];
+  /** Its people, by slug: each has members/<slug>.md and .jpg in the artist's folder (label-profiles.ts). */
+  members?: string[];
   createdAt: number;
   lastAttemptAt: number;
   lastError: string;
@@ -426,7 +429,7 @@ const LYRICS_SYSTEM = [
 ].join(" ");
 
 export async function planAlbum(
-  artist: Pick<LabelArtist, "name" | "genre" | "sound" | "voice" | "bio" | "themes" | "albums">,
+  artist: Pick<LabelArtist, "name" | "genre" | "sound" | "voice" | "bio" | "themes" | "albums"> & { cast?: string },
   songs: number,
   ask: typeof askJson = askJson,
 ): Promise<{ title: string; concept: string; songs: Array<{ title: string; style: string }>; model: string }> {
@@ -440,6 +443,7 @@ export async function planAlbum(
       `Voice: ${artist.voice}`,
       artist.bio ? `Who they are: ${artist.bio}` : "",
       artist.themes ? `What they sing about: ${artist.themes}` : "",
+      artist.cast ? `The band, as they are (write for these people): ${artist.cast}` : "",
       before.length ? `Albums already out (do not reuse their titles or song titles; take the story somewhere new): ${before.join(" | ")}` : "This is the artist's debut album.",
       `The album has exactly ${songs} songs.`,
     ].filter(Boolean).join("\n"),
@@ -481,7 +485,7 @@ export async function inventArtist(genre: string, taken: string[], ask: typeof a
 }
 
 export async function writeLyrics(
-  artist: Pick<LabelArtist, "name" | "genre" | "voice" | "themes">,
+  artist: Pick<LabelArtist, "name" | "genre" | "voice" | "themes"> & { cast?: string },
   album: Pick<LabelAlbum, "title" | "concept">,
   song: Pick<LabelSong, "title" | "style" | "seconds">,
   ask: typeof askJson = askJson,
@@ -491,6 +495,7 @@ export async function writeLyrics(
     prompt: [
       `Artist: ${artist.name} (${artist.genre}); voice: ${artist.voice}`,
       artist.themes ? `What they sing about: ${artist.themes}` : "",
+      artist.cast ? `Who sings and plays it (their voice and personality shape the words): ${artist.cast}` : "",
       `Album: "${album.title}"${album.concept ? `: ${album.concept}` : ""}`,
       `Song: "${song.title}": ${song.style}`,
       `The song lasts about ${song.seconds} seconds: keep the words under ${Math.max(600, Math.round(song.seconds * 10))} characters.`,
@@ -583,7 +588,7 @@ const STORYBOARD_SYSTEM = [
 
 /** Image prompts for a song's video, one a scene, from its words and mood. */
 export async function writeStoryboard(
-  artist: Pick<LabelArtist, "name" | "genre" | "sound">,
+  artist: Pick<LabelArtist, "name" | "genre" | "sound"> & { cast?: string },
   album: Pick<LabelAlbum, "title" | "concept">,
   song: Pick<LabelSong, "title" | "style" | "lyrics">,
   scenes: number,
@@ -593,6 +598,7 @@ export async function writeStoryboard(
     system: STORYBOARD_SYSTEM,
     prompt: [
       `Song: "${song.title}" by ${artist.name} (${artist.genre}; ${artist.sound}), from "${album.title}"${album.concept ? `: ${album.concept}` : ""}`,
+      artist.cast ? `The band (these are the only performers; whenever one appears, name them and repeat their full look in that prompt, the image model remembers nothing): ${artist.cast}` : "",
       `Mood and arrangement: ${song.style}`,
       song.lyrics ? `Lyrics:\n${song.lyrics.slice(0, 1800)}` : "",
       `Exactly ${scenes} scenes.`,
@@ -746,6 +752,7 @@ export class AiLabel {
   private settings: LabelSettings = { ...DEFAULTS, pausedReason: "" };
   private usage: Record<string, number> = {};
   private running = false;
+  private profiling = false;
   /** Songs being made now, by `<album>:<n>`. */
   private claims = new Map<string, { label: string; seconds: number }>();
   /** Artists whose next album is being planned now. */
@@ -976,7 +983,8 @@ export class AiLabel {
     if (!this.canAsk()) throw new StationError("no_writer", "no language model to write the album: set GEMINI_API_KEY, OPENAI_API_KEY (or NIXAMP_OPENAI_URL) or ANTHROPIC_API_KEY", 409);
     const pending = artist.albums.find((one) => !one.doneAt);
     if (pending) throw new StationError("album_in_progress", `"${pending.title}" is still being made`, 409);
-    const plan = await planAlbum(artist, this.settings.songsPerAlbum, this.deps.ask ?? askJson);
+    await this.ensureProfile(artist).catch(() => undefined);
+    const plan = await planAlbum({ ...artist, cast: this.castOf(artist) }, this.settings.songsPerAlbum, this.deps.ask ?? askJson);
     const year = new Date(this.now()).getUTCFullYear();
     let title = plan.title;
     if (artist.albums.some((one) => one.title.toLowerCase() === title.toLowerCase())) title = `${title} II`;
@@ -1005,7 +1013,8 @@ export class AiLabel {
     this.timer = setInterval(() => { void this.tick(); void this.videos(); }, everyMs);
     this.timer.unref?.();
     void this.tick();
-    void this.videos();
+    // Profiles first (quick), so videos made after cast the right people.
+    void this.profiles().finally(() => void this.videos());
   }
 
   /**
@@ -1132,7 +1141,7 @@ export class AiLabel {
     if (this.canAsk()) {
       try {
         const count = Math.max(4, Math.min(16, Math.round(seconds / 9)));
-        const prompts = await writeStoryboard(artist, album, song, count, this.deps.ask ?? askJson);
+        const prompts = await writeStoryboard({ ...artist, cast: this.castOf(artist) }, album, song, count, this.deps.ask ?? askJson);
         mkdirSync(scenes, { recursive: true });
         const draw = this.deps.image ?? ((prompt: string) => workersAiCover(prompt));
         // A few at a time: the image model is quick, the machine is shared.
@@ -1334,7 +1343,7 @@ export class AiLabel {
     try {
       let writer = song.made || album.writer;
       if (!song.lyrics) {
-        const written = await writeLyrics(artist, album, song, this.deps.ask ?? askJson);
+        const written = await writeLyrics({ ...artist, cast: this.castOf(artist) }, album, song, this.deps.ask ?? askJson);
         song.lyrics = written.lyrics;
         writer = written.model;
         song.made = writer;
@@ -1374,6 +1383,7 @@ export class AiLabel {
       if (album.songs.every((one) => one.file)) {
         album.doneAt = this.now();
         this.log(`${artist.name} released "${album.title}"`);
+        void this.ensureProfile(artist).catch(() => undefined);
       }
       this.save();
       this.writeAlbumJson(artist, album);
@@ -1399,7 +1409,8 @@ export class AiLabel {
   }
 
   private async drawCover(artist: LabelArtist, album: LabelAlbum): Promise<void> {
-    const prompt = `Album cover art for "${album.title}", a ${artist.genre} album by ${artist.name}. ${album.concept} Style: ${artist.sound}. Striking, original, square composition. No text, no letters, no logos, no watermark.`;
+    const cast = this.castOf(artist);
+    const prompt = `Album cover art for "${album.title}", a ${artist.genre} album by ${artist.name}. ${album.concept} Style: ${artist.sound}.${cast ? ` If the band appears, they look exactly like this: ${cast}.` : ""} Striking, original, square composition. No text, no letters, no logos, no watermark.`;
     try {
       const picture = await (this.deps.cover ?? ((text) => workersAiCover(text)))(prompt);
       if (picture) {
@@ -1485,6 +1496,7 @@ export class AiLabel {
         .filter((one) => one.genre === genre)
         .map((one) => ({
           key: one.key, name: one.name, genre: one.genre, bio: one.bio,
+          members: this.cast(one).map((member) => ({ slug: member.slug, name: member.name, role: member.role, bio: member.bio })),
           albums: one.albums
             .filter((album) => album.songs.some((song) => song.file))
             .map((album) => ({
@@ -1520,6 +1532,67 @@ export class AiLabel {
     return null;
   }
 
+  /** The artist's folder: <root>/<genre>/<artist>/, where its albums and profile pages live. */
+  folderOf(artist: Pick<LabelArtist, "genre" | "name">): string {
+    return join(this.root, genreSlug(artist.genre), fileName(artist.name));
+  }
+
+  /** The artist's people as their pages say now (hand edits win). */
+  cast(artist: LabelArtist): Member[] {
+    return readMembers(this.folderOf(artist), artist.members ?? []);
+  }
+
+  /** The people in one line, for a prompt; "" before they are cast. */
+  castOf(artist: LabelArtist): string {
+    return castLine(this.cast(artist));
+  }
+
+  /**
+   * The artist's profile: its members invented once (and their portraits
+   * drawn), and artist.md written again with what it has released.
+   */
+  async ensureProfile(artist: LabelArtist): Promise<void> {
+    const folder = this.folderOf(artist);
+    mkdirSync(folder, { recursive: true });
+    const band = { name: artist.name, genre: artist.genre, holder: this.settings.holder };
+    const draw = this.deps.image === undefined ? (prompt: string) => workersAiCover(prompt) : this.deps.image;
+    if (!artist.members?.length && this.canAsk()) {
+      const invented = await inventMembers(artist, this.deps.ask ?? askJson);
+      const written = await writeMembers(folder, invented, band, draw);
+      artist.members = written.map((one) => one.slug);
+      this.save();
+      this.log(`${artist.name}: ${written.map((one) => `${one.name} (${one.role})`).join(", ")}`);
+    } else if (artist.members?.length) {
+      // Portraits that are missing (a page added by hand, a failed drawing) are drawn now.
+      await writeMembers(folder, this.cast(artist), band, draw);
+    }
+    writeFileSync(join(folder, "artist.md"), bandMarkdown({
+      ...artist, holder: this.settings.holder, members: this.cast(artist),
+      albums: artist.albums.filter((one) => one.doneAt || one.songs.some((song) => song.file)).map((one) => ({ year: one.year, title: one.title })),
+    }));
+  }
+
+  /** Every artist's profile, made or brought up to date; one at a time. */
+  async profiles(): Promise<void> {
+    if (this.profiling) return;
+    this.profiling = true;
+    try {
+      for (const artist of this.list()) await this.ensureProfile(artist).catch((error: unknown) => this.log(`no profile for ${artist.name}: ${(error as Error).message}`));
+    } finally {
+      this.profiling = false;
+    }
+  }
+
+  /** A profile file anybody may read: artist.md, members/<slug>.md or members/<slug>.jpg. */
+  profileFile(artistKey: string, what: string): { path: string; type: string } | null {
+    const artist = this.artists.get(artistKey);
+    if (!artist) return null;
+    if (what === "artist.md") return { path: join(this.folderOf(artist), "artist.md"), type: "text/markdown; charset=utf-8" };
+    const match = /^members\/([a-z0-9-]{1,40})\.(md|jpg)$/.exec(what);
+    if (!match || !(artist.members ?? []).includes(match[1]!)) return null;
+    return { path: join(this.folderOf(artist), "members", `${match[1]}.${match[2]}`), type: match[2] === "md" ? "text/markdown; charset=utf-8" : "image/jpeg" };
+  }
+
   /** The song's MP3 when `file` is one of the label's music videos (it holds the tags, cover and words); else `file`. */
   audioFor(file: string): string {
     if (!file.endsWith(".mp4")) return file;
@@ -1566,6 +1639,18 @@ export class AiLabel {
       }, null, 2)}\n`) });
     }
     if (entries.length === 0) return null;
+    // Everything by an artist comes with who they are: the band's page, each member's page and portrait.
+    if (scope.kind === "artist") {
+      const folder = this.folderOf(artist);
+      const exists = (path: string): boolean => { try { return statSync(path).isFile(); } catch { return false; } };
+      if (exists(join(folder, "artist.md"))) entries.push({ name: `${top}/artist.md`, path: join(folder, "artist.md") });
+      for (const slug of artist.members ?? []) {
+        for (const ext of ["md", "jpg"]) {
+          const path = join(folder, "members", `${slug}.${ext}`);
+          if (exists(path)) entries.push({ name: `${top}/members/${slug}.${ext}`, path });
+        }
+      }
+    }
     const what = scope.kind === "artist" ? "Discography" : scope.kind === "album" ? albums[0]!.title : this.songFile(scope.artist, scope.album, scope.n) ? albums[0]!.songs.find((one) => one.n === scope.n)!.title : "Song";
     return { name: `${fileName(artist.name)} - ${fileName(what)}.zip`, entries };
   }
@@ -1582,5 +1667,7 @@ export interface PublicArtist {
   name: string;
   genre: string;
   bio: string;
+  /** The people (profile pages at /api/v1/label/<artist>/members/<slug>.md, portraits .jpg). */
+  members: Array<{ slug: string; name: string; role: string; bio: string }>;
   albums: Array<{ key: string; title: string; year: number; concept: string; cover: boolean; complete: boolean; songs: Array<{ n: number; title: string; seconds: number; lyrics: string }> }>;
 }

package/src/channels.ts

@@ -325,6 +325,19 @@ export class Channel {
     return done;
   }
 
+  /** How far listeners have got into this dial of a list, by the encoder's progress. */
+  private heard = 0;
+
+  /** Where a list would pick up after what listeners hear now (PlaylistInputStream.resumePoint). */
+  resumePoint(): { file: string; upcoming: string[]; sinceBreak: number } | null {
+    return this.playlistInput?.resumePoint(this.heard) ?? null;
+  }
+
+  /** Whether listeners would get sound (and, for a picture, its opening) if they joined now. */
+  get flowing(): boolean {
+    return this.info.bytes > 0 && (!this.fragments || this.fragments.ready);
+  }
+
   /** 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);
@@ -503,6 +516,7 @@ export class Channel {
         ...resume.rotation,
       }) : null;
       this.playlistInput = playlistInput;
+      this.heard = 0;
       const through = this.outroOn ? null : playlistInput
         ? { format: "mpegts", open: async (signal: AbortSignal) => playlistInput.open(signal) }
         : this.options.through?.(this.info, from, input, audio) ?? null;
@@ -585,6 +599,7 @@ export class Channel {
           if (match) {
             const seconds = Number(match[1]) / 1e6;
             if (playlistInput) {
+              this.heard = seconds;
               const place = playlistInput.place(seconds);
               // A break (-1) belongs to no list; a track's index belongs to its own.
               if (place.at >= 0 && this.info.playlist !== place.list) this.info.playlist = place.list as string[];
@@ -1450,6 +1465,21 @@ export class Channels {
     return this.open.get(id)?.tagsOf(file);
   }
 
+  /** Where a channel playing a list would pick up after what is on now; null when it is not one. */
+  resumePoint(id: string): { file: string; upcoming: string[]; sinceBreak: number } | null {
+    return this.open.get(id)?.resumePoint() ?? null;
+  }
+
+  /** Whether a channel is up and has started sending. */
+  flowing(id: string): boolean {
+    return this.open.get(id)?.flowing ?? false;
+  }
+
+  /** Who is attached to one channel: listeners, relays, packagers. */
+  listenersOf(id: string): number {
+    return this.open.get(id)?.listeners.size ?? 0;
+  }
+
   /** The next entry, now, on a channel playing a list of files. */
   skip(id: string): boolean {
     return this.open.get(id)?.skip() ?? false;