nixamp 0.55.1 → 0.56.0

package/dist/radio-pages.js

@@ -26,9 +26,33 @@ 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)?\/?$/;
 export function isRadioPath(path) {
-    return path === "/radio" || path === "/radio/" || RADIO_SUB.test(path) || RADIO_STATION.test(path) || RADIO_ARTIST.test(path) || RADIO_ALBUM.test(path);
+    return path === "/radio" || path === "/radio/" || path === RADIO_BUY || RADIO_SUB.test(path) || RADIO_STATION.test(path) || RADIO_ARTIST.test(path) || RADIO_ALBUM.test(path);
+}
+const RESERVED = new Set(["artist", "album", "artists", "albums", "buy"]);
+/**
+ * Buy, through this server: a 302 to nixamp.com's store page for it, so the
+ * link on a /radio page does not carry the machine the music is on.
+ */
+export const RADIO_BUY = "/radio/buy";
+/** /radio/buy?kind=&artist=&album=&n=, checked: the label's keys and nothing else. */
+export function radioBuyQuery(query) {
+    const kind = query.get("kind");
+    const artist = query.get("artist") ?? "";
+    const album = query.get("album") ?? "";
+    const n = Number(query.get("n") ?? 0);
+    if (kind !== "song" && kind !== "album" && kind !== "artist")
+        return null;
+    if (!/^[a-f0-9]{10}$/.test(artist))
+        return null;
+    if (kind !== "artist" && !/^[a-f0-9]{8}$/.test(album))
+        return null;
+    if (kind === "song" && !(Number.isInteger(n) && n >= 1 && n <= 999))
+        return null;
+    return { kind, artist, album: kind === "artist" ? "" : album, n: kind === "song" ? n : 0 };
+}
+export function radioBuyLink(kind, artist, album = "", n = 0) {
+    return `${RADIO_BUY}?${new URLSearchParams({ kind, artist, ...(kind !== "artist" ? { album } : {}), ...(kind === "song" ? { n: String(n) } : {}) }).toString()}`;
 }
-const RESERVED = new Set(["artist", "album", "artists", "albums"]);
 /**
  * Public, listed stations by name. Oldest first, so a name stays with the
  * station that had it; a second "Jazz" is jazz-2.
@@ -180,11 +204,14 @@ export function rewriteResponse(response, rewrite) {
     response.end = (chunk, ...rest) => end(swap(chunk), ...rest);
 }
 /** The station's addresses and token, as /radio/<name> says them instead. */
-export function radioRewriter(station, slug) {
+export function radioRewriter(station, slug, buyFrom = "") {
     const token = station.listenToken;
     const encoded = encodeURIComponent(token);
     return (text) => {
         let out = text.split(`/api/v1/stations/${station.id}/`).join(`/radio/${slug}/`);
+        // The store's links name this server; /radio/buy sends there without saying so.
+        if (buyFrom)
+            out = out.split(buyFrom).join(`${RADIO_BUY}?`);
         for (const one of new Set([encoded, token])) {
             out = out.split(`?t=${one}&`).join("?").split(`&t=${one}`).join("").split(`?t=${one}`).join("").split(one).join("");
         }

package/dist/server.js

@@ -77,7 +77,7 @@ import { handleRooms, RoomProbe, roomEntries, RoomStore, watchBase } from "./gui
 import { handleVods, VodProbe, vodEntries, VodStore, vodView } from "./guide-vods.js";
 import { withPitFooter } from "./pit-footer.js";
 import { handleFollowPage } from "./follow-page.js";
-import { asRadioPage, buildCatalogue, isRadioPath, NAV_STYLE, RADIO_ALBUM, RADIO_ARTIST, RADIO_CSP, RADIO_STATION, RADIO_SUB, radioNav, radioPeers, radioRewriter, radioStations, renderAlbum, renderArtist, renderDirectory, renderMissing, rewriteResponse, } from "./radio-pages.js";
+import { asRadioPage, buildCatalogue, isRadioPath, NAV_STYLE, RADIO_ALBUM, RADIO_ARTIST, RADIO_CSP, RADIO_STATION, RADIO_SUB, RADIO_BUY, radioBuyLink, radioBuyQuery, radioNav, radioPeers, radioRewriter, radioStations, renderAlbum, renderArtist, renderDirectory, renderMissing, rewriteResponse, } from "./radio-pages.js";
 import { adCsp, guideAds, guideCsp, withPageAd, guideHosts, guidePeers, peerBase, PeerGuides, renderGuide } from "./station-guide.js";
 import { StationRunner } from "./station-runner.js";
 import { StationError, StationStore, channelOf, stationOfChannel } from "./stations.js";
@@ -1590,7 +1590,8 @@ export function createHandler(engine, options) {
                 query.delete("t");
                 query.set("t", station.listenToken);
                 request.url = `/api/v1/stations/${station.id}/${sub[2]}?${query.toString()}`;
-                rewriteResponse(response, radioRewriter(station, sub[1]));
+                const here = options.stations.publicBase?.() ?? "";
+                rewriteResponse(response, radioRewriter(station, sub[1], /^https:\/\//.test(here) ? `${storeSite}/buy?server=${encodeURIComponent(here)}&` : ""));
                 return handle(request, response);
             }
         }
@@ -2610,10 +2611,18 @@ export function createHandler(engine, options) {
                 response.end(request.method === "HEAD" ? undefined : page);
             };
             const shop = stations.label && /^https:\/\//.test(publicBase)
-                ? { site: storeSite, buy: (kind, artist, album = "", n = 0) => buyLink(storeSite, publicBase, kind, artist, album, n), prices: PRICES }
+                ? { site: storeSite, buy: radioBuyLink, prices: PRICES }
                 : null;
             const peers = stations.peers ? radioPeers(named.keys(), await stations.peers.entries()) : new Map();
             const stationNames = new Map([...named].map(([slug, one]) => [slug, one.name]));
+            if (path === RADIO_BUY) {
+                const item = radioBuyQuery(url.searchParams);
+                if (!item || !shop)
+                    return send(404, renderMissing("thing for sale", base, nav));
+                response.writeHead(302, { location: buyLink(storeSite, publicBase, item.kind, item.artist, item.album, item.n), "cache-control": "no-store", "referrer-policy": "no-referrer" });
+                response.end();
+                return;
+            }
             if (path === "/radio" || path === "/radio/") {
                 const encrypted = request.socket.encrypted === true;
                 const entries = guideEntries({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.55.1",
+  "version": "0.56.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/label-profiles.ts

@@ -0,0 +1,212 @@
+/**
+ * Who is in each AI label band: an OpenProfile page per member and one for
+ * the band, so the same people sing, appear on covers and in videos every
+ * time instead of whoever an image model draws next.
+ *
+ *     <artist folder>/artist.md                 the band: genre, sound, members, discography
+ *     <artist folder>/members/<slug>.md         a member: role, look, voice, personality...
+ *     <artist folder>/members/<slug>.jpg        their reference portrait
+ *
+ * The pages are the source of truth once written: a person may edit a
+ * member's look or voice by hand, and what is generated next reads the page
+ * back (readMember). Members are invented once, by a language model, as
+ * fictional people; the portrait is drawn from the look and kept.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { askJson } from "./ai-text.ts";
+
+export interface Member {
+  slug: string;
+  name: string;
+  /** What they do in the band: "lead vocals", "lead guitar", "drums"... */
+  role: string;
+  /** How they look, in enough detail to draw the same person again: age, face, hair, build, signature clothes. */
+  look: string;
+  /** How they sound, for a singer; how they play, for the rest. */
+  voice: string;
+  personality: string;
+  influences: string;
+  bio: string;
+}
+
+export function memberSlug(name: string): string {
+  return name.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "member";
+}
+
+function line(text: string): string {
+  return text.replace(/[\r\n]+/g, " ").trim();
+}
+
+/** A member's OpenProfile page. */
+export function memberMarkdown(member: Member, band: { name: string; holder: string }): string {
+  return [
+    `# ${member.name}`,
+    "",
+    "- **Kind**: fictional musician, made with AI",
+    `- **Band**: [${band.name}](../artist.md)`,
+    `- **Role**: ${line(member.role)}`,
+    `- **Avatar**: [portrait](${member.slug}.jpg)`,
+    `- **Parent**: ${band.holder}`,
+    "",
+    line(member.bio),
+    "",
+    "## Look",
+    "",
+    line(member.look),
+    "",
+    "## Voice",
+    "",
+    line(member.voice),
+    "",
+    "## Personality",
+    "",
+    line(member.personality),
+    "",
+    "## Influences",
+    "",
+    line(member.influences),
+    "",
+  ].join("\n");
+}
+
+/** A member's page read back, so hand edits win; null when it is not one of ours. */
+export function readMember(text: string, slug: string): Member | null {
+  const name = /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? "";
+  if (!name) return null;
+  const field = (label: string): string => new RegExp(`^- \\*\\*${label}\\*\\*:\\s*(.+)$`, "m").exec(text)?.[1]?.trim() ?? "";
+  const section = (heading: string): string => {
+    const match = new RegExp(`^##\\s+${heading}\\s*$([\\s\\S]*?)(?=^##\\s|$(?![\\s\\S]))`, "m").exec(text);
+    return (match?.[1] ?? "").trim().replace(/\s+/g, " ");
+  };
+  // The bio is the prose between the fields and the first section.
+  const bio = (/^- \*\*Parent\*\*:.*$\n+([\s\S]*?)(?=^##\s)/m.exec(text)?.[1] ?? "").trim().replace(/\s+/g, " ");
+  return { slug, name, role: field("Role"), look: section("Look"), voice: section("Voice"), personality: section("Personality"), influences: section("Influences"), bio };
+}
+
+/** The band's OpenProfile page. */
+export function bandMarkdown(band: {
+  name: string; genre: string; sound: string; voice: string; bio: string; themes: string; holder: string;
+  members: Member[]; albums: Array<{ year: number; title: string }>;
+}): string {
+  return [
+    `# ${band.name}`,
+    "",
+    "- **Kind**: band, fictional, made with AI",
+    `- **Genre**: ${band.genre}`,
+    `- **Label**: ${band.holder}`,
+    `- **Members**: ${band.members.map((one) => `[${one.name}](members/${one.slug}.md) (${one.role})`).join(", ")}`,
+    "",
+    line(band.bio),
+    "",
+    "## Sound",
+    "",
+    line(band.sound),
+    "",
+    "## Lead voice",
+    "",
+    line(band.voice),
+    "",
+    "## Themes",
+    "",
+    line(band.themes),
+    "",
+    "## Discography",
+    "",
+    ...(band.albums.length ? band.albums.map((one) => `- ${one.year} · ${one.title}`) : ["- (first album on its way)"]),
+    "",
+  ].join("\n");
+}
+
+const MEMBERS_SYSTEM = [
+  "You cast the members of a fictional band (or the one person behind a solo act) for an AI record label.",
+  "Everyone is invented: never a real person, never a lookalike of one. Give each a full name, their role, and a look described",
+  "precisely enough that an illustrator could draw the same person every time: age range, face, skin tone, hair, build, signature outfit and accessories.",
+  "Answer as JSON: {\"members\": [{\"name\": \"\", \"role\": \"\", \"look\": \"at most 300 characters\", \"voice\": \"how they sing or play, at most 150 characters\",",
+  "\"personality\": \"at most 150 characters\", \"influences\": \"styles and eras, never named artists, at most 120 characters\", \"bio\": \"one or two sentences\"}]}.",
+].join(" ");
+
+/** The band's people, invented once: one for a solo act, three to five for a band. */
+export async function inventMembers(
+  band: { name: string; genre: string; sound: string; voice: string; bio: string },
+  ask: typeof askJson,
+): Promise<Member[]> {
+  const answer = await ask({
+    system: MEMBERS_SYSTEM,
+    prompt: [
+      `Act: ${band.name} (${band.genre})`,
+      `Sound: ${band.sound}`,
+      `Lead voice: ${band.voice}`,
+      band.bio ? `Who they are: ${band.bio}` : "",
+      "If the name reads as one person's, cast that one person as the solo artist (role: vocals and the instrument that fits); otherwise cast the band, the lead singer first, matching the lead voice.",
+    ].filter(Boolean).join("\n"),
+    maxTokens: 2000,
+    timeoutMs: 90_000,
+  });
+  const list = Array.isArray(answer.value["members"]) ? answer.value["members"] as Array<Record<string, unknown>> : [];
+  const seen = new Set<string>();
+  const members = list
+    .map((one) => {
+      const name = line(String(one?.["name"] ?? "")).slice(0, 60);
+      return {
+        slug: memberSlug(name), name,
+        role: line(String(one?.["role"] ?? "")).slice(0, 80),
+        look: line(String(one?.["look"] ?? "")).slice(0, 500),
+        voice: line(String(one?.["voice"] ?? "")).slice(0, 300),
+        personality: line(String(one?.["personality"] ?? "")).slice(0, 300),
+        influences: line(String(one?.["influences"] ?? "")).slice(0, 200),
+        bio: line(String(one?.["bio"] ?? "")).slice(0, 500),
+      };
+    })
+    .filter((one) => one.name && one.look.length > 20 && !seen.has(one.slug) && seen.add(one.slug))
+    .slice(0, 6);
+  if (members.length === 0) throw new Error("the model cast nobody");
+  return members;
+}
+
+/** How the band looks on stage, for a cover or a scene: every member by name, role and look. */
+export function castLine(members: Member[]): string {
+  return members.map((one) => `${one.name} (${one.role}): ${one.look}`).join("; ");
+}
+
+/** The portrait prompt for a member: the same person every time it is used as a reference. */
+export function portraitPrompt(member: Member, band: { name: string; genre: string }): string {
+  return `Photographic portrait of ${member.look}. ${member.role} in the ${band.genre} band ${band.name}. Head and shoulders, three-quarter view, natural expression, soft studio light, plain dark background, sharp focus, 85mm lens. No text, no logos.`;
+}
+
+/** Writes the member pages and portraits that are missing; returns the members as the pages now say. */
+export async function writeMembers(folder: string, members: Member[], band: { name: string; genre: string; holder: string }, draw: ((prompt: string) => Promise<Buffer | null>) | null): Promise<Member[]> {
+  const dir = join(folder, "members");
+  mkdirSync(dir, { recursive: true });
+  const out: Member[] = [];
+  for (const member of members) {
+    const page = join(dir, `${member.slug}.md`);
+    let current = member;
+    try {
+      current = readMember(readFileSync(page, "utf8"), member.slug) ?? member;
+    } catch {
+      writeFileSync(page, memberMarkdown(member, band));
+    }
+    const portrait = join(dir, `${member.slug}.jpg`);
+    let drawn = true;
+    try { readFileSync(portrait); } catch { drawn = false; }
+    if (!drawn && draw) {
+      const picture = await draw(portraitPrompt(current, band)).catch(() => null);
+      if (picture) writeFileSync(portrait, picture);
+    }
+    out.push(current);
+  }
+  return out;
+}
+
+/** The members as their pages say now (hand edits included), in the order given. */
+export function readMembers(folder: string, slugs: string[]): Member[] {
+  return slugs.flatMap((slug) => {
+    try {
+      const member = readMember(readFileSync(join(folder, "members", `${slug}.md`), "utf8"), slug);
+      return member ? [member] : [];
+    } catch {
+      return [];
+    }
+  });
+}

package/src/label-routes.ts

@@ -20,9 +20,12 @@ import { adCsp, withPageAd, type GuideAds } from "./station-guide.ts";
 // MP3 or a zip needs a grant from nixamp.com's store (music-store.ts).
 const FILE = /^\/api\/v1\/label\/([a-f0-9]{10})\/([a-f0-9]{8})\/(\d{1,3}\.(?:txt|mp3)|cover\.jpg)$/;
 
+/** An artist's OpenProfile pages and portraits: artist.md, members/<slug>.md, members/<slug>.jpg. */
+const PROFILE = /^\/api\/v1\/label\/([a-f0-9]{10})\/(artist\.md|members\/[a-z0-9-]{1,40}\.(?:md|jpg))$/;
+
 /** Whether this path is the label's public face (an MP3 or the zip still asks for its grant). */
 export function isPublicLabelPath(path: string): boolean {
-  return path === "/label" || path === "/api/v1/label" || path === "/api/v1/label/zip" || FILE.test(path);
+  return path === "/label" || path === "/api/v1/label" || path === "/api/v1/label/zip" || FILE.test(path) || PROFILE.test(path);
 }
 
 /** nixamp.com's page that sells this: a song, an album or everything by the artist. */
@@ -146,6 +149,16 @@ export async function handleLabelRoutes(
         response.end();
         return true;
       }
+      const profile = PROFILE.exec(path);
+      if (profile) {
+        const found = label.profileFile(profile[1]!, profile[2]!);
+        if (!found) {
+          ctx.json(response, 404, { error: "no such profile", code: "not_found" });
+          return true;
+        }
+        sendFile(request, response, found.path, found.type, "");
+        return true;
+      }
       const [, artist, album, what] = FILE.exec(path)!;
       if (what!.endsWith(".mp3")) {
         const scope = ctx.grants && grant ? await ctx.grants.check(grant) : null;
@@ -270,6 +283,11 @@ audio{width:100%;max-width:360px;height:36px}
 details{margin-top:4px}summary{cursor:pointer;color:var(--muted);font-size:.9rem}
 pre.lyrics{white-space:pre-wrap;font:inherit;font-size:.95rem;margin:8px 0 0;padding:12px;border-radius:8px;background:var(--bg)}
 .dl{font-size:.85rem}.soon{color:var(--muted);font-size:.85rem}
+ul.members{list-style:none;margin:12px 0 4px;padding:0;display:flex;flex-wrap:wrap;gap:10px}
+ul.members a{display:flex;gap:8px;align-items:center;color:var(--fg);text-decoration:none;border:1px solid var(--line);border-radius:999px;padding:4px 12px 4px 4px}
+ul.members a:hover,ul.members a:focus-visible{border-color:var(--accent)}
+ul.members img{width:40px;height:40px;border-radius:50%;object-fit:cover;background:var(--line)}
+ul.members span{display:grid;line-height:1.2}ul.members .role{color:var(--muted);font-size:.8rem}
 a.buy{display:inline-block;font-weight:700;text-decoration:none;border:1px solid var(--accent);border-radius:999px;padding:2px 10px}
 footer{margin-top:48px;color:var(--muted);font-size:.85rem}footer a{color:inherit}
 `;
@@ -285,6 +303,16 @@ export const LABEL_CSP = [
 
 type Shop = { site: string; server: string } | undefined;
 
+/** The band: each member's portrait, name and role, linking to their OpenProfile page. */
+function renderMembers(artist: PublicArtist): string {
+  if (!artist.members?.length) return "";
+  const base = `/api/v1/label/${artist.key}`;
+  return `<ul class="members">${artist.members.map((member) => `<li><a href="${base}/members/${escape(member.slug)}.md" title="${escape(member.bio)}">`
+    + `<img src="${base}/members/${escape(member.slug)}.jpg" alt="" width="56" height="56" loading="lazy">`
+    + `<span><strong>${escape(member.name)}</strong><span class="role">${escape(member.role)}</span></span></a></li>`).join("")}</ul>`
+    + `<p class="dl"><a href="${base}/artist.md">${escape(artist.name)}'s profile</a></p>`;
+}
+
 function price(cents: number): string {
   return cents < 100 ? `${cents}¢` : `$${(cents / 100).toFixed(cents % 100 ? 2 : 0)}`;
 }
@@ -313,7 +341,7 @@ export function renderLabel(view: ReturnType<AiLabel["publicView"]>, shop?: Shop
   const nav = view.genres.length > 1 ? `<nav class="genres" aria-label="Genres">${view.genres.map((one) => `<a href="#${escape(one.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(one.genre)}</a>`).join("")}</nav>` : "";
   const sections = view.genres.map((genre) => `<section class="genre" id="${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}" aria-labelledby="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">`
     + `<h2 id="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(genre.genre)}${genre.station ? ` <a href="/watch/${escape(genre.station)}">Listen live, free →</a>` : ""}</h2>`
-    + genre.artists.map((artist) => `<article class="artist"><h3>${escape(artist.name)}</h3>${artist.bio ? `<p class="bio">${escape(artist.bio)}</p>` : ""}`
+    + genre.artists.map((artist) => `<article class="artist"><h3>${escape(artist.name)}</h3>${artist.bio ? `<p class="bio">${escape(artist.bio)}</p>` : ""}${renderMembers(artist)}`
       + `${shop ? `<p>${buy(shop, "artist", artist.key, "", 0, "everything by them")}</p>` : ""}`
       + `${artist.albums.map((album) => renderAlbum(artist, album, shop)).join("")}</article>`).join("")
     + `</section>`).join("");