nixamp 0.55.2 → 0.57.0

package/dist/ai-label.d.ts

@@ -1,6 +1,7 @@
 import { type Composer } from "./ai-radio.ts";
 import { askJson } from "./ai-text.ts";
 import { type SyncedLine } from "./lyrics.ts";
+import { type Member } from "./label-profiles.ts";
 import type { LibraryIndex, Probed } from "./library-index.ts";
 import type { StationRunner } from "./station-runner.ts";
 import { type StationStore } from "./stations.ts";
@@ -58,6 +59,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;
@@ -109,7 +112,9 @@ export declare function genreSlug(genre: string): string;
 export declare function songBase(song: Pick<LabelSong, "n" | "title">): string;
 /** Words as a singer gets them: section lines kept, the model's own notes and fences dropped. */
 export declare function cleanLyrics(text: string): string;
-export declare function planAlbum(artist: Pick<LabelArtist, "name" | "genre" | "sound" | "voice" | "bio" | "themes" | "albums">, songs: number, ask?: typeof askJson): Promise<{
+export declare function planAlbum(artist: Pick<LabelArtist, "name" | "genre" | "sound" | "voice" | "bio" | "themes" | "albums"> & {
+    cast?: string;
+}, songs: number, ask?: typeof askJson): Promise<{
     title: string;
     concept: string;
     songs: Array<{
@@ -120,7 +125,9 @@ export declare function planAlbum(artist: Pick<LabelArtist, "name" | "genre" | "
 }>;
 /** A new artist for this genre, unlike the ones already signed. */
 export declare function inventArtist(genre: string, taken: string[], ask?: typeof askJson): Promise<ArtistPreset>;
-export declare function writeLyrics(artist: Pick<LabelArtist, "name" | "genre" | "voice" | "themes">, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "seconds">, ask?: typeof askJson): Promise<{
+export declare function writeLyrics(artist: Pick<LabelArtist, "name" | "genre" | "voice" | "themes"> & {
+    cast?: string;
+}, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "seconds">, ask?: typeof askJson): Promise<{
     lyrics: string;
     model: string;
 }>;
@@ -146,7 +153,9 @@ export declare function sungLines(lyrics: string): string[];
  */
 export declare function syncLines(lyrics: string, timed: TimedWord[]): SyncedLine[];
 /** Image prompts for a song's video, one a scene, from its words and mood. */
-export declare function writeStoryboard(artist: Pick<LabelArtist, "name" | "genre" | "sound">, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "lyrics">, scenes: number, ask?: typeof askJson): Promise<string[]>;
+export declare function writeStoryboard(artist: Pick<LabelArtist, "name" | "genre" | "sound"> & {
+    cast?: string;
+}, album: Pick<LabelAlbum, "title" | "concept">, song: Pick<LabelSong, "title" | "style" | "lyrics">, scenes: number, ask?: typeof askJson): Promise<string[]>;
 /**
  * A song's music video from its storyboard: each scene's picture moves (a
  * slow zoom in, a pan, a zoom out, a pan back, in turn), scenes cross-fade,
@@ -212,6 +221,7 @@ export declare class AiLabel {
     private settings;
     private usage;
     private running;
+    private profiling;
     /** Songs being made now, by `<album>:<n>`. */
     private claims;
     /** Artists whose next album is being planned now. */
@@ -332,6 +342,24 @@ export declare class AiLabel {
         artistName: string;
         albumTitle: string;
     } | null;
+    /** The artist's folder: <root>/<genre>/<artist>/, where its albums and profile pages live. */
+    folderOf(artist: Pick<LabelArtist, "genre" | "name">): string;
+    /** The artist's people as their pages say now (hand edits win). */
+    cast(artist: LabelArtist): Member[];
+    /** The people in one line, for a prompt; "" before they are cast. */
+    castOf(artist: LabelArtist): string;
+    /**
+     * The artist's profile: its members invented once (and their portraits
+     * drawn), and artist.md written again with what it has released.
+     */
+    ensureProfile(artist: LabelArtist): Promise<void>;
+    /** Every artist's profile, made or brought up to date; one at a time. */
+    profiles(): Promise<void>;
+    /** 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;
     /** 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;
     /** A released song's MP3, when this grant's scope covers it. */
@@ -361,6 +389,13 @@ 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;

package/dist/ai-label.js

@@ -34,6 +34,7 @@ import { aiKey } from "./ai-keys.js";
 import { composerFromEnv, OutOfCredit } from "./ai-radio.js";
 import { askJson, hasModel } from "./ai-text.js";
 import { formatLrc } from "./lyrics.js";
+import { bandMarkdown, castLine, inventMembers, readMembers, writeMembers } from "./label-profiles.js";
 import { StationError } from "./stations.js";
 /**
  * The label's first roster: invented names, one genre each, sung in English.
@@ -327,6 +328,7 @@ export async function planAlbum(artist, songs, ask = askJson) {
             `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"),
@@ -373,6 +375,7 @@ export async function writeLyrics(artist, album, song, ask = askJson) {
         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.`,
@@ -468,6 +471,7 @@ export async function writeStoryboard(artist, album, song, scenes, ask = askJson
         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.`,
@@ -595,6 +599,7 @@ export class AiLabel {
     settings = { ...DEFAULTS, pausedReason: "" };
     usage = {};
     running = false;
+    profiling = false;
     /** Songs being made now, by `<album>:<n>`. */
     claims = new Map();
     /** Artists whose next album is being planned now. */
@@ -838,7 +843,8 @@ export class AiLabel {
         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()))
@@ -868,7 +874,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());
     }
     /**
      * Music videos for every released song without one, one at a time (a
@@ -1006,7 +1013,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) => workersAiCover(prompt));
                 // A few at a time: the image model is quick, the machine is shared.
@@ -1226,7 +1233,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;
@@ -1266,6 +1273,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);
@@ -1292,7 +1300,8 @@ export class AiLabel {
         return drawing;
     }
     async drawCover(artist, album) {
-        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) {
@@ -1378,6 +1387,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) => ({
@@ -1414,6 +1424,68 @@ export class AiLabel {
         }
         return null;
     }
+    /** The artist's folder: <root>/<genre>/<artist>/, where its albums and profile pages live. */
+    folderOf(artist) {
+        return join(this.root, genreSlug(artist.genre), fileName(artist.name));
+    }
+    /** The artist's people as their pages say now (hand edits win). */
+    cast(artist) {
+        return readMembers(this.folderOf(artist), artist.members ?? []);
+    }
+    /** The people in one line, for a prompt; "" before they are cast. */
+    castOf(artist) {
+        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) {
+        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) => 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() {
+        if (this.profiling)
+            return;
+        this.profiling = true;
+        try {
+            for (const artist of this.list())
+                await this.ensureProfile(artist).catch((error) => this.log(`no profile for ${artist.name}: ${error.message}`));
+        }
+        finally {
+            this.profiling = false;
+        }
+    }
+    /** A profile file anybody may read: artist.md, members/<slug>.md or members/<slug>.jpg. */
+    profileFile(artistKey, what) {
+        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) {
         if (!file.endsWith(".mp4"))
@@ -1466,6 +1538,25 @@ export class AiLabel {
         }
         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) => { 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 };
     }

package/dist/channels.d.ts

@@ -247,6 +247,16 @@ export declare class Channel {
      * failure, so it does not count as a redial.
      */
     skip(): boolean;
+    /** How far listeners have got into this dial of a list, by the encoder's progress. */
+    private heard;
+    /** Where a list would pick up after what listeners hear now (PlaylistInputStream.resumePoint). */
+    resumePoint(): {
+        file: string;
+        upcoming: string[];
+        sinceBreak: number;
+    } | null;
+    /** Whether listeners would get sound (and, for a picture, its opening) if they joined now. */
+    get flowing(): boolean;
     /** An entry's tags, as read when it was put on. */
     tagsOf(file: string): {
         title: string;
@@ -539,6 +549,16 @@ export declare class Channels {
         artist: string;
         album: string;
     } | undefined;
+    /** 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;
+    /** Whether a channel is up and has started sending. */
+    flowing(id: string): boolean;
+    /** Who is attached to one channel: listeners, relays, packagers. */
+    listenersOf(id: string): number;
     /** The next entry, now, on a channel playing a list of files. */
     skip(id: string): boolean;
     stop(id: string): boolean;

package/dist/channels.js

@@ -169,6 +169,16 @@ export class Channel {
             this.info.redials = redials;
         return done;
     }
+    /** How far listeners have got into this dial of a list, by the encoder's progress. */
+    heard = 0;
+    /** Where a list would pick up after what listeners hear now (PlaylistInputStream.resumePoint). */
+    resumePoint() {
+        return this.playlistInput?.resumePoint(this.heard) ?? null;
+    }
+    /** Whether listeners would get sound (and, for a picture, its opening) if they joined now. */
+    get flowing() {
+        return this.info.bytes > 0 && (!this.fragments || this.fragments.ready);
+    }
     /** An entry's tags, as read when it was put on. */
     tagsOf(file) {
         return this.playlistInput?.tags.get(file);
@@ -334,6 +344,7 @@ export class Channel {
                 ...resume.rotation,
             }) : null;
             this.playlistInput = playlistInput;
+            this.heard = 0;
             const through = this.outroOn ? null : playlistInput
                 ? { format: "mpegts", open: async (signal) => playlistInput.open(signal) }
                 : this.options.through?.(this.info, from, input, audio) ?? null;
@@ -413,6 +424,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)
@@ -1283,6 +1295,18 @@ export class Channels {
     tagsOf(id, file) {
         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) {
+        return this.open.get(id)?.resumePoint() ?? null;
+    }
+    /** Whether a channel is up and has started sending. */
+    flowing(id) {
+        return this.open.get(id)?.flowing ?? false;
+    }
+    /** Who is attached to one channel: listeners, relays, packagers. */
+    listenersOf(id) {
+        return this.open.get(id)?.listeners.size ?? 0;
+    }
     /** The next entry, now, on a channel playing a list of files. */
     skip(id) {
         return this.open.get(id)?.skip() ?? false;

package/dist/label-profiles.d.ts

@@ -0,0 +1,60 @@
+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 declare function memberSlug(name: string): string;
+/** A member's OpenProfile page. */
+export declare function memberMarkdown(member: Member, band: {
+    name: string;
+    holder: string;
+}): string;
+/** A member's page read back, so hand edits win; null when it is not one of ours. */
+export declare function readMember(text: string, slug: string): Member | null;
+/** The band's OpenProfile page. */
+export declare 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;
+/** The band's people, invented once: one for a solo act, three to five for a band. */
+export declare function inventMembers(band: {
+    name: string;
+    genre: string;
+    sound: string;
+    voice: string;
+    bio: string;
+}, ask: typeof askJson): Promise<Member[]>;
+/** How the band looks on stage, for a cover or a scene: every member by name, role and look. */
+export declare function castLine(members: Member[]): string;
+/** The portrait prompt for a member: the same person every time it is used as a reference. */
+export declare function portraitPrompt(member: Member, band: {
+    name: string;
+    genre: string;
+}): string;
+/** Writes the member pages and portraits that are missing; returns the members as the pages now say. */
+export declare function writeMembers(folder: string, members: Member[], band: {
+    name: string;
+    genre: string;
+    holder: string;
+}, draw: ((prompt: string) => Promise<Buffer | null>) | null): Promise<Member[]>;
+/** The members as their pages say now (hand edits included), in the order given. */
+export declare function readMembers(folder: string, slugs: string[]): Member[];

package/dist/label-profiles.js

@@ -0,0 +1,190 @@
+/**
+ * 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";
+export function memberSlug(name) {
+    return name.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "member";
+}
+function line(text) {
+    return text.replace(/[\r\n]+/g, " ").trim();
+}
+/** A member's OpenProfile page. */
+export function memberMarkdown(member, band) {
+    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, slug) {
+    const name = /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? "";
+    if (!name)
+        return null;
+    const field = (label) => new RegExp(`^- \\*\\*${label}\\*\\*:\\s*(.+)$`, "m").exec(text)?.[1]?.trim() ?? "";
+    const section = (heading) => {
+        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) {
+    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, ask) {
+    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"] : [];
+    const seen = new Set();
+    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) {
+    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, band) {
+    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, members, band, draw) {
+    const dir = join(folder, "members");
+    mkdirSync(dir, { recursive: true });
+    const out = [];
+    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, slugs) {
+    return slugs.flatMap((slug) => {
+        try {
+            const member = readMember(readFileSync(join(folder, "members", `${slug}.md`), "utf8"), slug);
+            return member ? [member] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}