nixamp 0.60.3 → 0.61.0

package/dist/known-servers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The servers nixamp.com has seen listed lately, and who owns each, kept in
+ * Postgres.
+ *
+ * The directory lives in memory and fills again only as servers heartbeat, so
+ * for a minute after every deploy nixamp.com/music had no catalogue and a
+ * label server's Veo or release call was refused as "not listed". This keeps
+ * the last day's servers so both work straight away; a server still listed
+ * always wins over what is remembered.
+ */
+import type { Queryable } from "./veo-studio.ts";
+export interface KnownServer {
+    base: string;
+    ownerId: string;
+    seenAt: number;
+}
+export declare class KnownServers {
+    private readonly db;
+    private readonly now;
+    private known;
+    private ready;
+    constructor(db: Queryable, now?: () => number);
+    private ensure;
+    /** What the last process saw in the last day. */
+    load(): Promise<void>;
+    /** The servers listed now: remembered here and in the database. */
+    sync(listed: Array<{
+        base: string;
+        ownerId: string;
+    }>): Promise<void>;
+    /** Servers seen in the last day. */
+    list(): KnownServer[];
+}

package/dist/known-servers.js

@@ -0,0 +1,40 @@
+const DAY_MS = 24 * 60 * 60 * 1000;
+export class KnownServers {
+    db;
+    now;
+    known = new Map();
+    ready = null;
+    constructor(db, now = Date.now) {
+        this.db = db;
+        this.now = now;
+    }
+    ensure() {
+        return (this.ready ??= this.db.query("CREATE TABLE IF NOT EXISTS music_servers (base TEXT PRIMARY KEY, owner_id TEXT NOT NULL, seen_at TIMESTAMPTZ NOT NULL DEFAULT now())").catch((error) => { this.ready = null; throw error; }));
+    }
+    /** What the last process saw in the last day. */
+    async load() {
+        await this.ensure();
+        const { rows } = await this.db.query("SELECT base, owner_id, seen_at FROM music_servers WHERE seen_at > $1", [new Date(this.now() - DAY_MS)]);
+        for (const row of rows) {
+            const base = String(row["base"]);
+            if (!this.known.has(base))
+                this.known.set(base, { base, ownerId: String(row["owner_id"]), seenAt: new Date(String(row["seen_at"])).getTime() });
+        }
+    }
+    /** The servers listed now: remembered here and in the database. */
+    async sync(listed) {
+        await this.ensure();
+        const at = this.now();
+        for (const one of listed) {
+            if (!one.base || !one.ownerId)
+                continue;
+            this.known.set(one.base, { base: one.base, ownerId: one.ownerId, seenAt: at });
+            await this.db.query("INSERT INTO music_servers (base, owner_id, seen_at) VALUES ($1, $2, now()) ON CONFLICT (base) DO UPDATE SET owner_id = EXCLUDED.owner_id, seen_at = now()", [one.base, one.ownerId]);
+        }
+    }
+    /** Servers seen in the last day. */
+    list() {
+        const since = this.now() - DAY_MS;
+        return [...this.known.values()].filter((one) => one.seenAt > since);
+    }
+}

package/dist/music-hub.js

@@ -12,7 +12,8 @@
  *   POST /api/v1/music/released               a server says an album or song landed: its followers hear
  */
 import { createHash } from "node:crypto";
-import { musicPage, renderMusicPage } from "./music-seo.js";
+import { memberProfile, musicPage, renderMusicPage } from "./music-seo.js";
+import { readMember } from "./label-profiles.js";
 /** A server's opaque id: the first 10 hex of the SHA-256 of its https origin. Both sides can work it out. */
 export function serverId(base) {
     return createHash("sha256").update(base.replace(/\/+$/, "")).digest("hex").slice(0, 10);
@@ -136,8 +137,10 @@ export async function musicPageFor(hub, path) {
     }
     return "";
 }
+/** A band member's OpenProfile as JSON (music-seo.ts memberProfile), read from their page on the server that holds it. */
+const MEMBER_JSON = /^\/api\/v1\/music\/member\/([a-f0-9]{10})\/([a-f0-9]{10})\/([a-z0-9-]{1,40})\.json$/;
 export function isMusicPath(path) {
-    return path === "/music" || path.startsWith("/music/") || path === "/api/v1/music" || FILE.test(path) || path === "/api/v1/music/released" || path === "/api/v1/music/veo";
+    return path === "/music" || path.startsWith("/music/") || path === "/api/v1/music" || FILE.test(path) || MEMBER_JSON.test(path) || path === "/api/v1/music/released" || path === "/api/v1/music/veo";
 }
 export async function handleMusicRoutes(request, response, path, ctx) {
     if (!isMusicPath(path))
@@ -182,6 +185,33 @@ export async function handleMusicRoutes(request, response, path, ctx) {
         ctx.json(response, 200, await ctx.hub.catalogue());
         return true;
     }
+    const person = MEMBER_JSON.exec(path);
+    if (person) {
+        const [, server, artistKey, slug] = person;
+        const base = ctx.hub.resolve(server);
+        if (!base) {
+            ctx.json(response, 404, { error: "no such server" });
+            return true;
+        }
+        try {
+            const upstream = await fetch(`${base}/api/v1/label/${artistKey}/members/${slug}.md`, { signal: AbortSignal.timeout(10_000) });
+            const member = upstream.ok ? readMember(await upstream.text(), slug) : null;
+            if (!member) {
+                ctx.json(response, 404, { error: "no such person" });
+                return true;
+            }
+            const catalogue = await ctx.hub.catalogue().catch(() => null);
+            const band = catalogue?.genres.flatMap((one) => one.artists).find((one) => one.server === server && one.key === artistKey)?.name ?? "";
+            const profile = memberProfile(member, { site: (ctx.site ?? "https://nixamp.com").replace(/\/+$/, ""), server, artist: artistKey, band, holder: catalogue?.holders[0] ?? "Profullstack, Inc." });
+            response.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "public, max-age=300", "access-control-allow-origin": "*" });
+            response.end(method === "HEAD" ? undefined : JSON.stringify(profile, null, 2));
+        }
+        catch {
+            if (!response.headersSent)
+                ctx.json(response, 502, { error: "the server holding it did not answer" });
+        }
+        return true;
+    }
     const file = FILE.exec(path);
     if (file) {
         const base = ctx.hub.resolve(file[1]);
@@ -239,7 +269,7 @@ export async function handleMusicRoutes(request, response, path, ctx) {
     // one without the server a page names is not knowing, not "no such page": the
     // shell as it is, never a 404 a crawler would drop the page for.
     const servers = new Set(catalogue?.genres.flatMap((one) => one.artists.map((artist) => artist.server)) ?? []);
-    const named = /^\/music\/(?:artist|album)\/([a-f0-9]{10})\//.exec(path)?.[1];
+    const named = /^\/music\/(?:artist|album|member)\/([a-f0-9]{10})\//.exec(path)?.[1];
     const known = servers.size > 0 && (!named || servers.has(named));
     const view = catalogue && known ? musicPage(path, catalogue, site) : null;
     const html = view ? renderMusicPage(shell, view, `${site}${path.replace(/\/+$/, "") || "/music"}`) : shell;

package/dist/music-seo.d.ts

@@ -9,9 +9,50 @@
  *   /music/genre/<slug>                     a genre's artists
  *   /music/artist/<server>/<artist>         an artist: bio, members, albums
  *   /music/album/<server>/<artist>/<album>  an album: cover, songs
+ *   /music/member/<server>/<artist>/<slug>  a band member: photo, job, OpenProfile (JSON at /api/v1/music/member/...json)
  *   /music/me                               the listener's own page: never indexed
  */
 import type { HubCatalogue } from "./music-hub.ts";
+/** What someone does, said as a job: "lead vocals in Hollow Sovereign", "bass in Harbor Lights Society". */
+export declare function memberJob(role: string, band: string): string;
+/** A band member's OpenProfile, as JSON: the page's fields, with every address absolute. */
+export interface MemberProfile {
+    openprofile: string;
+    type: "person";
+    kind: string;
+    name: string;
+    role: string;
+    job: string;
+    band: {
+        name: string;
+        url: string;
+    };
+    avatar: string;
+    bio: string;
+    look: string;
+    voice: string;
+    personality: string;
+    influences: string;
+    parent: string;
+    url: string;
+    source: string;
+}
+export declare function memberProfile(member: {
+    slug: string;
+    name: string;
+    role: string;
+    bio: string;
+    look: string;
+    voice: string;
+    personality: string;
+    influences: string;
+}, where: {
+    site: string;
+    server: string;
+    artist: string;
+    band: string;
+    holder: string;
+}): MemberProfile;
 interface Head {
     title: string;
     description: string;

package/dist/music-seo.js

@@ -5,6 +5,32 @@ const clip = (text, max) => {
     return one.length <= max ? one : `${one.slice(0, max - 1).replace(/\s+\S*$/, "")}…`;
 };
 const clock = (seconds) => `${Math.floor(seconds / 60)}:${String(Math.round(seconds % 60)).padStart(2, "0")}`;
+const capital = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+/** What someone does, said as a job: "lead vocals in Hollow Sovereign", "bass in Harbor Lights Society". */
+export function memberJob(role, band) {
+    return `${role || "member"} in ${band}`;
+}
+export function memberProfile(member, where) {
+    const files = `${where.site}/api/v1/music/file/${where.server}/${where.artist}/members/${member.slug}`;
+    return {
+        openprofile: "1",
+        type: "person",
+        kind: "fictional musician, made with AI",
+        name: member.name,
+        role: member.role,
+        job: memberJob(member.role, where.band),
+        band: { name: where.band, url: `${where.site}/music/artist/${where.server}/${where.artist}` },
+        avatar: `${files}.jpg`,
+        bio: member.bio,
+        look: member.look,
+        voice: member.voice,
+        personality: member.personality,
+        influences: member.influences,
+        parent: where.holder,
+        url: `${where.site}/music/member/${where.server}/${where.artist}/${member.slug}`,
+        source: `${files}.md`,
+    };
+}
 /** The head and summary of a /music address, from the catalogue. `site` is https://nixamp.com. */
 export function musicPage(path, catalogue, site) {
     const at = (rest) => `${site}${rest}`;
@@ -32,6 +58,36 @@ export function musicPage(path, catalogue, site) {
             body: "<h1>My music</h1><p>Sign in to see what you bought and who you follow.</p>",
         };
     }
+    if (parts[0] === "member" && parts[1] && parts[2] && parts[3]) {
+        const artist = artists.find((one) => one.server === parts[1] && one.key === parts[2]);
+        const member = artist?.members?.find((one) => one.slug === parts[3]);
+        if (!artist || !member)
+            return missing("person");
+        const job = memberJob(member.role, artist.name);
+        const portrait = file(artist.server, `${artist.key}/members/${member.slug}.jpg`);
+        const json = `/api/v1/music/member/${artist.server}/${artist.key}/${member.slug}.json`;
+        return {
+            status: 200,
+            head: {
+                title: `${member.name} · ${job} · nixamp music`,
+                description: clip(member.bio || `${member.name}, ${job}.`, 200),
+                type: "profile",
+                image: { url: portrait, alt: `${member.name} of ${artist.name}` },
+                extra: [["profile:username", member.slug]],
+                ld: {
+                    "@context": "https://schema.org", "@type": "Person", name: member.name, url: at(`/music/member/${artist.server}/${artist.key}/${member.slug}`),
+                    ...(member.role ? { jobTitle: member.role } : {}),
+                    ...(member.bio ? { description: member.bio } : {}),
+                    image: portrait,
+                    memberOf: { "@type": "MusicGroup", name: artist.name, url: at(artistLink(artist)) },
+                },
+            },
+            body: `<p><a href="/music">Music</a> / <a href="${artistLink(artist)}">${escape(artist.name)}</a></p><h1>${escape(member.name)}</h1>`
+                + `<p>${escape(capital(member.role || "member"))} in <a href="${artistLink(artist)}">${escape(artist.name)}</a></p>`
+                + (member.bio ? `<p>${escape(member.bio)}</p>` : "")
+                + `<p><a href="${json}">OpenProfile as JSON</a></p>`,
+        };
+    }
     if (parts[0] === "genre" && parts[1]) {
         const genre = catalogue.genres.find((one) => slug(one.genre) === parts[1]);
         if (!genre)

package/dist/server.js

@@ -65,7 +65,8 @@ import { AiLabel, VeoUnavailable } from "./ai-label.js";
 import { buyLink, handleLabelRoutes, isPublicLabelPath } from "./label-routes.js";
 import { GrantVerifier, MusicStore, PRICES } from "./music-store.js";
 import { handleMusicRoutes, isMusicPath, MusicHub, musicPageFor, serverId } from "./music-hub.js";
-import { VeoBudgetError, VeoStudio } from "./veo-studio.js";
+import { fileLedger, pgLedger, VeoBudgetError, VeoStudio } from "./veo-studio.js";
+import { KnownServers } from "./known-servers.js";
 import { handleStoreRoutes, isStorePath } from "./store-routes.js";
 import { AiRadio } from "./ai-radio.js";
 import { ListenerShares } from "./listener-shares.js";
@@ -7490,9 +7491,16 @@ export async function serve(argv, version = "0.1.0") {
     // The AI label's songs for sale: purchases kept here, the music zipped by the server that holds it.
     const jwtSecret = process.env["NIXAMP_JWT_SECRET"] ?? "";
     // The servers whose music nixamp.com sells and plays: the directory and the guide's peers.
+    // Remembered in Postgres too, so the catalogue and owners are there the moment a deploy restarts us.
+    const knownServers = options.directory && pool ? new KnownServers(pool) : undefined;
+    const listedServers = () => directory ? directory.list().map((one) => ({ base: peerBase(one.url), ownerId: one.ownerId ?? "" })).filter((one) => one.base) : [];
+    if (knownServers) {
+        void knownServers.load().catch((error) => console.log(`  music servers not remembered: ${error instanceof Error ? error.message : String(error)}`));
+        setInterval(() => void knownServers.sync(listedServers()).catch(() => undefined), 60_000).unref();
+    }
     const musicServers = () => {
-        const listed = directory ? directory.list().map((one) => peerBase(one.url)).filter(Boolean) : [];
-        return [...new Set([...guidePeers(), ...listed])];
+        const listed = listedServers().map((one) => one.base);
+        return [...new Set([...guidePeers(), ...listed, ...(knownServers?.list().map((one) => one.base) ?? [])])];
     };
     // nixamp.com/music: every server's label in one catalogue (music-hub.ts).
     const musicHub = options.directory ? new MusicHub({ peers: musicServers }) : undefined;
@@ -7514,14 +7522,21 @@ export async function serve(argv, version = "0.1.0") {
     // Veo shots for label music videos, under a monthly dollar cap (veo-studio.ts). nixamp.com only.
     const veoStudio = options.directory && process.env["NIXAMP_VEO_API_KEY"] ? new VeoStudio({
         key: process.env["NIXAMP_VEO_API_KEY"],
-        file: VeoStudio.fileFor(stateDir(), options.port),
+        // The month's spend in Postgres: a deploy recreates the container, and a file there would forget it.
+        ledger: pool ? pgLedger(pool) : fileLedger(VeoStudio.fileFor(stateDir(), options.port)),
         monthlyUsd: Number(process.env["NIXAMP_VEO_MONTHLY_USD"] ?? 50),
         usdPerSecond: Number(process.env["NIXAMP_VEO_USD_PER_SECOND"] ?? 0.15),
     }) : undefined;
     /** The signed-in account owns a server listed in the directory at this base. */
     const ownsListed = async (request, base) => {
         const me = accounts ? await accounts.whoIs(tokenFrom(request.headers)).catch(() => null) : null;
-        return Boolean(me && base && directory?.list().some((one) => one.ownerId === me.id && peerBase(one.url) === base));
+        if (!me || !base)
+            return false;
+        const listed = listedServers();
+        // A server listed now answers for itself; one not (yet) back since a restart, by who last owned it.
+        if (listed.some((one) => one.base === base))
+            return listed.some((one) => one.base === base && one.ownerId === me.id);
+        return Boolean(knownServers?.list().some((one) => one.base === base && one.ownerId === me.id));
     };
     const musicVeo = async (request) => {
         if (!veoStudio)
@@ -7530,7 +7545,7 @@ export async function serve(argv, version = "0.1.0") {
         if (!(await ownsListed(request, base)))
             return { status: 403, body: { error: "only the owner of a listed server" } };
         if (request.method === "GET")
-            return { status: 200, body: veoStudio.status() };
+            return { status: 200, body: await veoStudio.status() };
         if (request.method !== "POST")
             return { status: 405, body: { error: "GET or POST" } };
         let input;
@@ -7549,7 +7564,7 @@ export async function serve(argv, version = "0.1.0") {
         }
         catch (error) {
             if (error instanceof VeoBudgetError)
-                return { status: 402, body: { error: error.message, code: "budget", ...veoStudio.status() } };
+                return { status: 402, body: { error: error.message, code: "budget", ...(await veoStudio.status()) } };
             return { status: 422, body: { error: error.message, code: "refused" } };
         }
     };

package/dist/veo-studio.d.ts

@@ -2,9 +2,24 @@ export declare class VeoBudgetError extends Error {
 }
 export declare class VeoRefused extends Error {
 }
+/** Where the month's spend lives. `reserve` adds `usd` only if that keeps the month at or under `cap`. */
+export interface VeoLedger {
+    spent(month: string): Promise<number>;
+    reserve(month: string, usd: number, cap: number): Promise<boolean>;
+    refund(month: string, usd: number): Promise<void>;
+}
+export interface Queryable {
+    query: (text: string, params?: unknown[]) => Promise<{
+        rows: Array<Record<string, unknown>>;
+    }>;
+}
+/** The spend in Postgres, one row a month, reserved atomically. */
+export declare function pgLedger(db: Queryable): VeoLedger;
+/** The spend in a file, for a nixamp with no database (its own state directory must survive restarts). */
+export declare function fileLedger(file: string): VeoLedger;
 export interface VeoStudioOptions {
     key: string;
-    file: string;
+    ledger: VeoLedger;
     monthlyUsd?: number;
     usdPerSecond?: number;
     model?: string;
@@ -14,21 +29,19 @@ export interface VeoStudioOptions {
 }
 export declare class VeoStudio {
     private readonly options;
-    private spent;
     constructor(options: VeoStudioOptions);
     static fileFor(stateDir: string, port: number): string;
     private month;
     private get cap();
     private get rate();
-    private save;
-    status(): {
+    status(): Promise<{
         month: string;
         spentUsd: number;
         capUsd: number;
         leftUsd: number;
         usdPerSecond: number;
         secondsLeft: number;
-    };
+    }>;
     /** One shot: 4, 6 or 8 seconds, 16:9, with up to three reference images (JPEG). */
     clip(input: {
         prompt: string;

package/dist/veo-studio.js

@@ -11,6 +11,10 @@
  *
  * The key is NIXAMP_VEO_API_KEY, its own name, so nothing else on nixamp.com
  * starts spending Gemini credit because a Gemini key appeared.
+ *
+ * The month's spend is kept in Postgres on nixamp.com (a deploy recreates its
+ * container and would lose a file, and with it the cap), reserved in one
+ * statement that refuses to go over; a file only where there is no database.
  */
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -18,18 +22,62 @@ export class VeoBudgetError extends Error {
 }
 export class VeoRefused extends Error {
 }
+/** The spend in Postgres, one row a month, reserved atomically. */
+export function pgLedger(db) {
+    let ready = null;
+    const ensure = () => (ready ??= db.query("CREATE TABLE IF NOT EXISTS veo_spend (month TEXT PRIMARY KEY, usd NUMERIC NOT NULL DEFAULT 0)").catch((error) => { ready = null; throw error; }));
+    return {
+        async spent(month) {
+            await ensure();
+            return Number((await db.query("SELECT usd FROM veo_spend WHERE month = $1", [month])).rows[0]?.["usd"] ?? 0);
+        },
+        async reserve(month, usd, cap) {
+            await ensure();
+            await db.query("INSERT INTO veo_spend (month, usd) VALUES ($1, 0) ON CONFLICT (month) DO NOTHING", [month]);
+            const done = await db.query("UPDATE veo_spend SET usd = usd + $2 WHERE month = $1 AND usd + $2 <= $3 RETURNING usd", [month, usd, cap + 1e-9]);
+            return done.rows.length > 0;
+        },
+        async refund(month, usd) {
+            await ensure();
+            await db.query("UPDATE veo_spend SET usd = GREATEST(0, usd - $2) WHERE month = $1", [month, usd]);
+        },
+    };
+}
+/** The spend in a file, for a nixamp with no database (its own state directory must survive restarts). */
+export function fileLedger(file) {
+    let spent = {};
+    try {
+        spent = JSON.parse(readFileSync(file, "utf8")).spent ?? {};
+    }
+    catch {
+        spent = {};
+    }
+    const save = () => {
+        mkdirSync(dirname(file), { recursive: true });
+        const temporary = `${file}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${JSON.stringify({ version: 1, spent }, null, 2)}\n`, { mode: 0o600 });
+        renameSync(temporary, file);
+    };
+    return {
+        spent: async (month) => spent[month] ?? 0,
+        async reserve(month, usd, cap) {
+            if ((spent[month] ?? 0) + usd > cap + 1e-9)
+                return false;
+            spent[month] = (spent[month] ?? 0) + usd;
+            save();
+            return true;
+        },
+        async refund(month, usd) {
+            spent[month] = Math.max(0, (spent[month] ?? 0) - usd);
+            save();
+        },
+    };
+}
 const BASE = "https://generativelanguage.googleapis.com/v1beta";
 export class VeoStudio {
     options;
-    spent = {};
     constructor(options) {
         this.options = options;
-        try {
-            this.spent = JSON.parse(readFileSync(options.file, "utf8")).spent ?? {};
-        }
-        catch {
-            this.spent = {};
-        }
     }
     static fileFor(stateDir, port) {
         return join(stateDir, `veo-${port}.json`);
@@ -39,14 +87,8 @@ export class VeoStudio {
     }
     get cap() { return this.options.monthlyUsd ?? 50; }
     get rate() { return this.options.usdPerSecond ?? 0.15; }
-    save() {
-        mkdirSync(dirname(this.options.file), { recursive: true });
-        const temporary = `${this.options.file}.${process.pid}.tmp`;
-        writeFileSync(temporary, `${JSON.stringify({ version: 1, spent: this.spent }, null, 2)}\n`, { mode: 0o600 });
-        renameSync(temporary, this.options.file);
-    }
-    status() {
-        const spent = this.spent[this.month()] ?? 0;
+    async status() {
+        const spent = await this.options.ledger.spent(this.month());
         const left = Math.max(0, this.cap - spent);
         return { month: this.month(), spentUsd: Math.round(spent * 100) / 100, capUsd: this.cap, leftUsd: Math.round(left * 100) / 100, usdPerSecond: this.rate, secondsLeft: Math.floor(left / this.rate) };
     }
@@ -55,17 +97,14 @@ export class VeoStudio {
         const seconds = [4, 6, 8].includes(input.seconds) ? input.seconds : 8;
         const cost = seconds * this.rate;
         const month = this.month();
-        if ((this.spent[month] ?? 0) + cost > this.cap + 1e-9)
+        // Reserved first, in one step that will not go over: two at once cannot both squeeze under the cap.
+        if (!(await this.options.ledger.reserve(month, cost, this.cap)))
             throw new VeoBudgetError(`this month's $${this.cap} of Veo is spent`);
-        // Reserved first, so two at once cannot both squeeze under the cap.
-        this.spent[month] = (this.spent[month] ?? 0) + cost;
-        this.save();
         try {
             return await this.make(input.prompt, seconds, input.references.slice(0, 3));
         }
         catch (error) {
-            this.spent[month] = Math.max(0, (this.spent[month] ?? 0) - cost);
-            this.save();
+            await this.options.ledger.refund(month, cost).catch(() => undefined);
             throw error;
         }
     }

package/package.json

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

package/src/known-servers.ts

@@ -0,0 +1,53 @@
+/**
+ * The servers nixamp.com has seen listed lately, and who owns each, kept in
+ * Postgres.
+ *
+ * The directory lives in memory and fills again only as servers heartbeat, so
+ * for a minute after every deploy nixamp.com/music had no catalogue and a
+ * label server's Veo or release call was refused as "not listed". This keeps
+ * the last day's servers so both work straight away; a server still listed
+ * always wins over what is remembered.
+ */
+import type { Queryable } from "./veo-studio.ts";
+
+export interface KnownServer { base: string; ownerId: string; seenAt: number }
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+export class KnownServers {
+  private known = new Map<string, KnownServer>();
+  private ready: Promise<unknown> | null = null;
+
+  constructor(private readonly db: Queryable, private readonly now: () => number = Date.now) {}
+
+  private ensure(): Promise<unknown> {
+    return (this.ready ??= this.db.query("CREATE TABLE IF NOT EXISTS music_servers (base TEXT PRIMARY KEY, owner_id TEXT NOT NULL, seen_at TIMESTAMPTZ NOT NULL DEFAULT now())").catch((error: unknown) => { this.ready = null; throw error; }));
+  }
+
+  /** What the last process saw in the last day. */
+  async load(): Promise<void> {
+    await this.ensure();
+    const { rows } = await this.db.query("SELECT base, owner_id, seen_at FROM music_servers WHERE seen_at > $1", [new Date(this.now() - DAY_MS)]);
+    for (const row of rows) {
+      const base = String(row["base"]);
+      if (!this.known.has(base)) this.known.set(base, { base, ownerId: String(row["owner_id"]), seenAt: new Date(String(row["seen_at"])).getTime() });
+    }
+  }
+
+  /** The servers listed now: remembered here and in the database. */
+  async sync(listed: Array<{ base: string; ownerId: string }>): Promise<void> {
+    await this.ensure();
+    const at = this.now();
+    for (const one of listed) {
+      if (!one.base || !one.ownerId) continue;
+      this.known.set(one.base, { base: one.base, ownerId: one.ownerId, seenAt: at });
+      await this.db.query("INSERT INTO music_servers (base, owner_id, seen_at) VALUES ($1, $2, now()) ON CONFLICT (base) DO UPDATE SET owner_id = EXCLUDED.owner_id, seen_at = now()", [one.base, one.ownerId]);
+    }
+  }
+
+  /** Servers seen in the last day. */
+  list(): KnownServer[] {
+    const since = this.now() - DAY_MS;
+    return [...this.known.values()].filter((one) => one.seenAt > since);
+  }
+}

package/src/music-hub.ts

@@ -13,7 +13,8 @@
  */
 import { createHash } from "node:crypto";
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { musicPage, renderMusicPage } from "./music-seo.ts";
+import { memberProfile, musicPage, renderMusicPage } from "./music-seo.ts";
+import { readMember } from "./label-profiles.ts";
 
 /** A server's opaque id: the first 10 hex of the SHA-256 of its https origin. Both sides can work it out. */
 export function serverId(base: string): string {
@@ -149,8 +150,11 @@ export async function musicPageFor(hub: MusicHub, path: string): Promise<string>
   return "";
 }
 
+/** A band member's OpenProfile as JSON (music-seo.ts memberProfile), read from their page on the server that holds it. */
+const MEMBER_JSON = /^\/api\/v1\/music\/member\/([a-f0-9]{10})\/([a-f0-9]{10})\/([a-z0-9-]{1,40})\.json$/;
+
 export function isMusicPath(path: string): boolean {
-  return path === "/music" || path.startsWith("/music/") || path === "/api/v1/music" || FILE.test(path) || path === "/api/v1/music/released" || path === "/api/v1/music/veo";
+  return path === "/music" || path.startsWith("/music/") || path === "/api/v1/music" || FILE.test(path) || MEMBER_JSON.test(path) || path === "/api/v1/music/released" || path === "/api/v1/music/veo";
 }
 
 export interface MusicRoutesContext {
@@ -192,6 +196,25 @@ export async function handleMusicRoutes(request: IncomingMessage, response: Serv
     ctx.json(response, 200, await ctx.hub.catalogue());
     return true;
   }
+  const person = MEMBER_JSON.exec(path);
+  if (person) {
+    const [, server, artistKey, slug] = person as unknown as [string, string, string, string];
+    const base = ctx.hub.resolve(server);
+    if (!base) { ctx.json(response, 404, { error: "no such server" }); return true; }
+    try {
+      const upstream = await fetch(`${base}/api/v1/label/${artistKey}/members/${slug}.md`, { signal: AbortSignal.timeout(10_000) });
+      const member = upstream.ok ? readMember(await upstream.text(), slug) : null;
+      if (!member) { ctx.json(response, 404, { error: "no such person" }); return true; }
+      const catalogue = await ctx.hub.catalogue().catch(() => null);
+      const band = catalogue?.genres.flatMap((one) => one.artists).find((one) => one.server === server && one.key === artistKey)?.name ?? "";
+      const profile = memberProfile(member, { site: (ctx.site ?? "https://nixamp.com").replace(/\/+$/, ""), server, artist: artistKey, band, holder: catalogue?.holders[0] ?? "Profullstack, Inc." });
+      response.writeHead(200, { "content-type": "application/json; charset=utf-8", "cache-control": "public, max-age=300", "access-control-allow-origin": "*" });
+      response.end(method === "HEAD" ? undefined : JSON.stringify(profile, null, 2));
+    } catch {
+      if (!response.headersSent) ctx.json(response, 502, { error: "the server holding it did not answer" });
+    }
+    return true;
+  }
   const file = FILE.exec(path);
   if (file) {
     const base = ctx.hub.resolve(file[1]!);
@@ -232,7 +255,7 @@ export async function handleMusicRoutes(request: IncomingMessage, response: Serv
   // one without the server a page names is not knowing, not "no such page": the
   // shell as it is, never a 404 a crawler would drop the page for.
   const servers = new Set(catalogue?.genres.flatMap((one) => one.artists.map((artist) => artist.server)) ?? []);
-  const named = /^\/music\/(?:artist|album)\/([a-f0-9]{10})\//.exec(path)?.[1];
+  const named = /^\/music\/(?:artist|album|member)\/([a-f0-9]{10})\//.exec(path)?.[1];
   const known = servers.size > 0 && (!named || servers.has(named));
   const view = catalogue && known ? musicPage(path, catalogue, site) : null;
   const html = view ? renderMusicPage(shell, view, `${site}${path.replace(/\/+$/, "") || "/music"}`) : shell;