nixamp 0.78.5 → 0.80.1

package/src/ai-label.ts

@@ -28,7 +28,7 @@
  */
 import { execFile } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { aiKey } from "./ai-keys.ts";
 import { composerFromEnv, OutOfCredit, type Composer } from "./ai-radio.ts";
@@ -1895,6 +1895,69 @@ export function genreSlug(genre: string): string {
   return genre.normalize("NFKD").toLowerCase().replace(/&/g, "n").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "music";
 }
 
+/** What `adopt` took back from disk. */
+export interface AdoptReport {
+  artists: number;
+  albums: number;
+  /** Recorded songs (planned ones without a file are kept too, to be made). */
+  songs: number;
+  /** Filmed music videos, shown on /music. */
+  videos: number;
+  /** Artists that kept the key they had before. */
+  oldKeys: number;
+  /** Folders left alone, and why. */
+  skipped: string[];
+}
+
+/** The folders in a folder, hidden ones left out; none when it cannot be read. */
+function listDirs(folder: string): string[] {
+  try {
+    return readdirSync(folder, { withFileTypes: true }).filter((one) => one.isDirectory() && !one.name.startsWith(".")).map((one) => one.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+function readText(file: string): string {
+  try {
+    return readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function readJson(file: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8")) as unknown;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : null;
+  } catch {
+    return null;
+  }
+}
+
+function mtimeOf(file: string): number {
+  try {
+    return Math.round(statSync(file).mtimeMs);
+  } catch {
+    return 0;
+  }
+}
+
+/** The text under "## <heading>" in an artist.md (bandMarkdown). */
+function section(page: string, heading: string): string {
+  const at = page.indexOf(`\n## ${heading}\n`);
+  if (at < 0) return "";
+  const rest = page.slice(at + heading.length + 5);
+  const end = rest.indexOf("\n## ");
+  return (end < 0 ? rest : rest.slice(0, end)).trim();
+}
+
+/** The bio: the paragraph between the facts list and the first section of an artist.md. */
+function intro(page: string): string {
+  const head = page.split("\n## ")[0] ?? "";
+  return head.split("\n").filter((one) => one.trim() && !one.startsWith("#") && !one.startsWith("- ")).join(" ").trim();
+}
+
 /** "001. Title", the start of a song's file names. */
 export function songBase(song: Pick<LabelSong, "n" | "title">): string {
   return `${String(song.n).padStart(3, "0")}. ${fileName(song.title)}`;
@@ -2680,7 +2743,7 @@ export class AiLabel {
     const why = !this.settings.enabled ? "the label is switched off"
       : this.settings.pausedReason
         || (composer ? "" : "no composer: set ELEVENLABS_API_KEY (nixamp station ai key ELEVENLABS_API_KEY) or NIXAMP_AI_MUSIC_COMMAND")
-        || (this.canAsk() ? "" : "no language model to write the albums: set GEMINI_API_KEY, OPENAI_API_KEY (or NIXAMP_OPENAI_URL) or ANTHROPIC_API_KEY")
+        || (this.canAsk() ? "" : "no language model to write the albums: set C0MPUTE_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY (or NIXAMP_OPENAI_URL) or ANTHROPIC_API_KEY")
         || (this.budgetLeft() < this.settings.songSeconds ? `this month's ${this.settings.monthlySeconds} s are used` : "");
     return {
       root: this.root,
@@ -2816,7 +2879,7 @@ export class AiLabel {
   /** Plan the next album for this artist now, whatever its schedule; it is composed song by song from here. */
   async plan(key: string): Promise<LabelAlbum> {
     const artist = this.require(key);
-    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);
+    if (!this.canAsk()) throw new StationError("no_writer", "no language model to write the album: set C0MPUTE_API_KEY, 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);
     await this.ensureProfile(artist).catch(() => undefined);
@@ -2844,6 +2907,162 @@ export class AiLabel {
     return album;
   }
 
+  /**
+   * Take back a catalogue that is on disk but not in the state file: the label's
+   * folders copied from another server (or a state file lost with its box).
+   * Every <genre>/<artist>/<year>-<album>/ under the root becomes the artist and
+   * album it was, from artist.md, album.json, the members' pages and the songs'
+   * own files, so /music, the genre stations, zips and purchases work again.
+   * `keys` gives artists their old keys by name and `albums` their albums' by
+   * "<artist key>/<album title>", so links and grants made before still match;
+   * the rest get new ones. Nothing is composed or drawn and nothing is moved;
+   * artists and albums already on the label are left as they are.
+   */
+  async adopt(input: { keys?: Record<string, string>; albums?: Record<string, string>; enabled?: boolean } = {}): Promise<AdoptReport> {
+    const report: AdoptReport = { artists: 0, albums: 0, songs: 0, videos: 0, oldKeys: 0, skipped: [] };
+    const used = new Set([...this.artists.keys()]);
+    const usedAlbums = new Set(this.list().flatMap((one) => one.albums.map((album) => album.key)));
+    const keyFor = (name: string): string => {
+      const old = input.keys?.[name];
+      if (old && /^[a-f0-9]{10}$/.test(old) && !used.has(old)) {
+        report.oldKeys += 1;
+        return old;
+      }
+      let key = randomBytes(5).toString("hex");
+      while (used.has(key)) key = randomBytes(5).toString("hex");
+      return key;
+    };
+    const albumKeyFor = (artistKey: string, title: string): string => {
+      const old = input.albums?.[`${artistKey}/${title}`];
+      if (old && /^[a-f0-9]{8}$/.test(old) && !usedAlbums.has(old)) return old;
+      let key = randomBytes(4).toString("hex");
+      while (usedAlbums.has(key)) key = randomBytes(4).toString("hex");
+      return key;
+    };
+    const touched = new Set<string>();
+    for (const genreDir of listDirs(this.root)) {
+      for (const artistDir of listDirs(join(this.root, genreDir))) {
+        const folder = join(this.root, genreDir, artistDir);
+        const page = readText(join(folder, "artist.md"));
+        const albumDirs = listDirs(folder).filter((one) => /^\d{4}-./.test(one));
+        const firstJson = albumDirs.map((one) => readJson(join(folder, one, "album.json"))).find((one) => one);
+        const name = clean(/^# (.+)$/m.exec(page)?.[1] ?? firstJson?.["artist"] ?? artistDir, 80);
+        const genre = clean(/^- \*\*Genre\*\*: (.+)$/m.exec(page)?.[1] ?? firstJson?.["genre"] ?? genreDir, 40);
+        if (genreSlug(genre) !== genreDir || fileName(name) !== artistDir) {
+          report.skipped.push(`${genreDir}/${artistDir}: its pages say ${genre}/${name}, which files elsewhere`);
+          continue;
+        }
+        const preset = Object.values(ROSTER).find((one) => one.name.toLowerCase() === name.toLowerCase());
+        let artist = this.list().find((one) => one.name.toLowerCase() === name.toLowerCase());
+        if (!artist) {
+          const key = keyFor(name);
+          used.add(key);
+          artist = {
+            key, name, genre,
+            sound: clean(section(page, "Sound") || preset?.sound || genre, 600),
+            voice: clean(section(page, "Lead voice") || preset?.voice || "expressive lead vocal", 300),
+            bio: clean(intro(page) || preset?.bio || "", 400),
+            themes: clean(section(page, "Themes") || preset?.themes || "", 300),
+            enabled: input.enabled !== false,
+            albums: [],
+            createdAt: this.now(),
+            lastAttemptAt: 0,
+            lastError: "",
+            failures: 0,
+          };
+          const members = [...page.matchAll(/\(members\/([a-z0-9-]{1,40})\.md\)/g)].map((one) => one[1]!)
+            .filter((slug) => existsSync(join(folder, "members", `${slug}.md`)));
+          if (members.length) artist.members = members;
+          this.artists.set(artist.key, artist);
+          report.artists += 1;
+        }
+        for (const albumDir of albumDirs) {
+          const albumFolder = join(folder, albumDir);
+          const json = readJson(join(albumFolder, "album.json")) ?? {};
+          const title = clean(json["album"] ?? albumDir.replace(/^\d{4}-/, ""), 120);
+          if (artist.albums.some((one) => one.title.toLowerCase() === title.toLowerCase())) continue;
+          const planned = Array.isArray(json["songs"]) ? json["songs"] as Array<Record<string, unknown>> : [];
+          const files = readdirSync(albumFolder).filter((one) => /^\d{3}\. .+\.mp3$/.test(one));
+          const numbers = new Set([...planned.map((one) => Number(one["n"])), ...files.map((one) => Number(one.slice(0, 3)))].filter((n) => Number.isInteger(n) && n > 0));
+          const songs: LabelSong[] = [];
+          for (const n of [...numbers].sort((a, b) => a - b)) {
+            const entry = planned.find((one) => Number(one["n"]) === n);
+            const mp3 = files.find((one) => Number(one.slice(0, 3)) === n);
+            const base = mp3 ? mp3.replace(/\.mp3$/, "") : "";
+            const songTitle = clean(entry?.["title"] ?? base.replace(/^\d{3}\. /, ""), 120);
+            const at = (ext: string): string => base && existsSync(join(albumFolder, `${base}${ext}`)) ? join(albumFolder, `${base}${ext}`) : "";
+            const file = mp3 ? join(albumFolder, mp3) : "";
+            let seconds = Number(entry?.["seconds"]) || this.settings.songSeconds;
+            let made = "";
+            if (file) {
+              try {
+                const probed = await this.deps.probe(file);
+                if (probed.duration > 0) seconds = Math.round(probed.duration);
+              } catch { /* the planned length */ }
+              made = "adopted";
+            }
+            const lyricsFile = at(".lyrics.txt");
+            const song: LabelSong = {
+              n, title: songTitle, style: clean(entry?.["style"] ?? json["concept"] ?? "", 600), lyrics: lyricsFile ? readText(lyricsFile).trim() : "",
+              seconds, file, lyricsFile, made, composedAt: file ? mtimeOf(file) : 0,
+            };
+            const lrc = at(".lrc");
+            if (lrc) song.lrc = lrc;
+            const video = at(".mp4");
+            if (video && file) {
+              song.video = video;
+              song.videoTagged = true;
+              // Filmed videos are 1080p Veo footage (tens of Mbit/s); the older cover-and-waveform ones were never shown.
+              const filmed = await this.isFilmed(video);
+              song.videoVersion = filmed ? FILMED : 1;
+              // Whether its singer was synced is not on disk; it is not filmed again for that.
+              if (filmed) song.singer = "unsynced";
+              if (filmed) report.videos += 1;
+            }
+            songs.push(song);
+            if (file) report.songs += 1;
+          }
+          if (songs.length === 0) continue;
+          const key = albumKeyFor(artist.key, title);
+          usedAlbums.add(key);
+          const year = Number(json["year"]) || Number(albumDir.slice(0, 4)) || new Date(this.now()).getUTCFullYear();
+          const times = songs.filter((one) => one.file).map((one) => one.composedAt);
+          const cover = existsSync(join(albumFolder, "cover.jpg")) ? join(albumFolder, "cover.jpg") : "";
+          artist.albums.push({
+            key, title, year,
+            concept: clean(json["concept"] ?? "", 600),
+            folder: albumFolder,
+            cover,
+            coverTried: true,
+            songs,
+            writer: "",
+            plannedAt: times.length ? Math.min(...times) : mtimeOf(albumFolder),
+            doneAt: songs.every((one) => one.file) ? Math.max(...times) : 0,
+          });
+          artist.albums.sort((a, b) => a.plannedAt - b.plannedAt);
+          artist.createdAt = Math.min(artist.createdAt, artist.albums[0]!.plannedAt || artist.createdAt);
+          report.albums += 1;
+          touched.add(artist.genre);
+        }
+      }
+    }
+    this.save();
+    for (const genre of touched) await this.place(genre).catch((error: unknown) => this.log(`could not put ${genre} on the air: ${(error as Error).message}`));
+    this.log(`adopted ${report.artists} artists, ${report.albums} albums, ${report.songs} songs (${report.oldKeys} kept their old keys)`);
+    return report;
+  }
+
+  /** A music video cut from Veo footage, by its bit rate: those are 1080p at tens of Mbit/s, the old slideshows a couple. */
+  private async isFilmed(video: string): Promise<boolean> {
+    try {
+      const probed = await this.deps.probe(video);
+      if (!(probed.duration > 0)) return false;
+      return (statSync(video).size * 8) / probed.duration > 8_000_000;
+    } catch {
+      return false;
+    }
+  }
+
   startSchedule(everyMs = 5 * 60_000): void {
     if (this.timer) return;
     this.timer = setInterval(() => { void this.tick(); void this.videos(); void this.timeWords(); }, everyMs);
@@ -3190,7 +3409,7 @@ export class AiLabel {
       const files = this.list()
         .flatMap((artist) => artist.albums.flatMap((album) => album.songs.map((song) => ((song.videoVersion ?? 1) >= SHOWN ? song.video ?? "" : ""))))
         .filter((file) => file && this.deps.index.itemAt(file)?.state === "ready");
-      const existing = this.deps.store.byAuto("ai:label:videos");
+      const existing = this.claimed("ai:label:videos", `${this.labelName()} AI · Music Videos`);
       if (files.length === 0) {
         // Nothing filmed yet (older slideshow videos are not shown): off the guide until there is.
         if (existing && existing.listed) this.deps.store.setAccess(existing.id, { visibility: "private", listed: false }, this.deps.owner || "ai-label");
@@ -3476,7 +3695,23 @@ export class AiLabel {
   }
 
   private stationFor(genre: string): ReturnType<StationStore["get"]> {
-    return this.deps.store.byAuto(`ai:label:${genreSlug(genre)}`);
+    return this.claimed(`ai:label:${genreSlug(genre)}`, `${this.labelName()} AI · ${genre}`);
+  }
+
+  /** "Profullstack" for "Profullstack, Inc.": how the label's stations are named. */
+  private labelName(): string {
+    return this.settings.holder.replace(/,?\s+(inc|llc|ltd|gmbh|co)\.?$/i, "");
+  }
+
+  /**
+   * The label's station for this key; else one made by hand under the very name the
+   * label would give it (a label rebuilt on another server), taken over, not doubled.
+   */
+  private claimed(key: string, name: string): ReturnType<StationStore["get"]> {
+    const marked = this.deps.store.byAuto(key);
+    if (marked) return marked;
+    const named = this.deps.store.list().find((one) => !one.auto && one.name === name);
+    return named ? this.deps.store.markAuto(named.id, key) : undefined;
   }
 
   /** The genre's station gets every song of that genre: made with the first, then kept in step. */

package/src/ai-text.ts

@@ -3,11 +3,12 @@
  *
  * AI radio asks for small things: a title and a prompt for the next track, a
  * genre and a verdict for a shared file. Whichever model has a key answers --
- * Gemini, then OpenAI, then Anthropic -- and when none has, the caller is told
- * so and does without (a rule of its own, or a person). The answer is parsed
- * and handed back as an object; a model that rambles round its JSON is read
- * for the first object in what it said.
+ * c0mpute, then Gemini, then OpenAI, then Anthropic -- and when none has, the
+ * caller is told so and does without (a rule of its own, or a person). The
+ * answer is parsed and handed back as an object; a model that rambles round
+ * its JSON is read for the first object in what it said.
  */
+import { ProviderError, createAiProviders, type AiRouter } from "@profullstack/ai-providers";
 import { aiKey } from "./ai-keys.ts";
 
 export interface AskOptions {
@@ -15,7 +16,7 @@ export interface AskOptions {
   system: string;
   /** The question, with what it should answer from. */
   prompt: string;
-  /** Milliseconds before giving up (default 30 s). */
+  /** Milliseconds before giving up on a hosted model (default 30 s); c0mpute gets at least C0MPUTE_MIN_WAIT_MS. */
   timeoutMs?: number;
   /** The longest answer, in tokens (default 1024): a song's words need more than a title does. */
   maxTokens?: number;
@@ -33,7 +34,7 @@ export interface Answer {
 
 export class NoModel extends Error {
   constructor() {
-    super("no language model key is set (GEMINI_API_KEY, OPENAI_API_KEY or ANTHROPIC_API_KEY)");
+    super("no language model key is set (C0MPUTE_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY or ANTHROPIC_API_KEY)");
   }
 }
 
@@ -61,7 +62,7 @@ export function escapeInStrings(text: string): string {
 
 /** The first JSON object in a model's answer. */
 export function firstObject(text: string): Record<string, unknown> {
-  const fenced = text.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "");
+  const fenced = text.replace(/<think>[\s\S]*?<\/think>/gi, "").trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "");
   const cleaned = (() => {
     try { JSON.parse(fenced); return fenced; } catch { return escapeInStrings(fenced); }
   })();
@@ -80,14 +81,79 @@ export function firstObject(text: string): Record<string, unknown> {
   throw new Error("the model did not answer with a JSON object");
 }
 
+/** The c0mpute key, or "" when there is none or C0MPUTE_DISABLED turns it off. */
+export function c0mputeKey(env: Record<string, string | undefined> = process.env): string {
+  return /^(1|true|yes|on)$/i.test(env["C0MPUTE_DISABLED"] ?? "") ? "" : aiKey("C0MPUTE_API_KEY", env);
+}
+
 /** Whether any model can be asked. */
 export function hasModel(env: Record<string, string | undefined> = process.env): boolean {
-  return Boolean(aiKey("GEMINI_API_KEY", env) || aiKey("OPENAI_API_KEY", env) || aiKey("ANTHROPIC_API_KEY", env));
+  return Boolean(c0mputeKey(env) || aiKey("GEMINI_API_KEY", env) || aiKey("OPENAI_API_KEY", env) || aiKey("ANTHROPIC_API_KEY", env));
+}
+
+/**
+ * c0mpute's 9B model takes 30 s for a short JSON answer, longer on a busy
+ * node, so it never gets a hosted model's 30 s budget.
+ */
+export const C0MPUTE_MIN_WAIT_MS = 120_000;
+
+/** c0mpute alone: the fallbacks are this file's own chain, not the package's. */
+export function c0mputeRouter(key: string, options: { env?: Record<string, string | undefined>; fetcher?: typeof fetch; concurrency?: number } = {}): AiRouter {
+  return createAiProviders({
+    env: { ...(options.env ?? process.env), C0MPUTE_API_KEY: key },
+    paidFallback: false,
+    c0mpute: {
+      ...(options.fetcher ? { fetch: options.fetcher } : {}),
+      ...(options.concurrency ? { concurrency: options.concurrency } : {}),
+    },
+  });
+}
+
+export interface C0mputeAsk {
+  system: string;
+  user: string;
+  maxTokens: number;
+  timeoutMs: number;
+  temperature?: number;
+  signal?: AbortSignal;
+}
+
+/**
+ * One answer from c0mpute, read by `read`. An answer `read` refuses gets one
+ * more try on the same model, told what was wrong with it, before the caller
+ * moves on: a small model misses far more often than a hosted one.
+ */
+export async function askC0mpute<T>(router: AiRouter, ask: C0mputeAsk, read: (text: string) => T): Promise<{ model: string; value: T }> {
+  const { value } = await router.run(async (provider) => {
+    const first = await provider.generate(ask);
+    try {
+      return { model: first.model, value: read(first.text) };
+    } catch (error) {
+      const again = await provider.generate({
+        ...ask,
+        user: `${ask.user}\n\nYour previous answer could not be used: ${(error as Error).message}\nAnswer again with only the corrected JSON object.`,
+      });
+      try {
+        return { model: again.model, value: read(again.text) };
+      } catch (second) {
+        throw new ProviderError("c0mpute", (second as Error).message, { kind: "output" });
+      }
+    }
+  });
+  return value;
+}
+
+/** The router askJson shares across calls, so a dead or busy c0mpute is parked for all of them. */
+let shared: { key: string; router: AiRouter } | undefined;
+function sharedRouter(key: string, env: Record<string, string | undefined>): AiRouter {
+  if (shared?.key !== key) shared = { key, router: c0mputeRouter(key, { env }) };
+  return shared.router;
 }
 
 export async function askJson(options: AskOptions): Promise<Answer> {
   const env = options.env ?? process.env;
   const send = options.fetcher ?? fetch;
+  const c0mpute = c0mputeKey(env);
   const gemini = aiKey("GEMINI_API_KEY", env);
   const openai = aiKey("OPENAI_API_KEY", env);
   const anthropic = aiKey("ANTHROPIC_API_KEY", env);
@@ -95,6 +161,16 @@ export async function askJson(options: AskOptions): Promise<Answer> {
   // answers 400 "User location is not supported" from some networks) or is
   // down is not a reason to go without when another can answer.
   const tries: Array<() => Promise<Answer>> = [];
+  if (c0mpute) tries.push(() => askC0mpute(
+    options.fetcher ? c0mputeRouter(c0mpute, { env, fetcher: options.fetcher }) : sharedRouter(c0mpute, env),
+    {
+      system: `${options.system}\nAnswer with one JSON object and nothing else.`,
+      user: options.prompt,
+      maxTokens: options.maxTokens ?? 1024,
+      timeoutMs: Math.max(options.timeoutMs ?? 0, C0MPUTE_MIN_WAIT_MS),
+    },
+    firstObject,
+  ));
   if (gemini) tries.push(async () => {
     const model = env["NIXAMP_GEMINI_MODEL"] || "gemini-flash-latest";
     const response = await send(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {

package/src/event-writer.ts

@@ -1,10 +1,13 @@
+import { jsonInstructions, type AiRouter } from "@profullstack/ai-providers";
+import { askC0mpute, c0mputeRouter, C0MPUTE_MIN_WAIT_MS, firstObject } from "./ai-text.ts";
 import { Guard } from "./guard.ts";
 
 export interface EventDraft { title: string; description: string; topic: string }
 export interface WriterInput extends EventDraft {
   hostName: string; startsAt: string; timezone: string; duration: string; recurrence: string;
 }
-export interface EventDraftResult { draft: EventDraft; provider: "openai" | "claude" }
+type Provider = "c0mpute" | "openai" | "claude";
+export interface EventDraftResult { draft: EventDraft; provider: Provider }
 export class EventWriterError extends Error {
   constructor(message: string, readonly status: number, readonly retryAfter?: number) { super(message); }
 }
@@ -37,8 +40,7 @@ Write in the language of the host's notes. Describe what students will learn and
 Keep concrete names and facts. Do not invent dates, prices, qualifications, prerequisites, links, credentials, or promises. Omit unknown logistics. Do not expand into unrelated subjects.
 The schedule and host name are context only; never propose changing them. Return plain text in the required JSON fields, with no HTML. Short paragraphs or simple bullet lists are fine.`;
 
-function draftFrom(text: string): EventDraft {
-  const value: unknown = JSON.parse(text);
+function draftOf(value: unknown): EventDraft {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid draft");
   const row = value as Record<string, unknown>;
   const draft = {} as EventDraft;
@@ -51,34 +53,46 @@ function draftFrom(text: string): EventDraft {
 }
 
 export interface EventWriterOptions {
-  openaiKey?: string; anthropicKey?: string;
+  c0mputeKey?: string; openaiKey?: string; anthropicKey?: string;
   openaiModel?: string; claudeModel?: string;
   fetch?: typeof globalThis.fetch;
+  /** Per hosted provider (default 25 s). */
   timeoutMs?: number;
+  /** For c0mpute, which needs longer (default C0MPUTE_MIN_WAIT_MS). */
+  c0mputeTimeoutMs?: number;
 }
 
 /** Server-side only. Drafting has no access to the event store and cannot publish. */
 export class EventWriter {
   private readonly guard = new Guard();
   private readonly active = new Set<string>();
-  constructor(private readonly options: EventWriterOptions) {}
+  // Its own router: a cancelled draft must not park c0mpute for AI radio, and
+  // a draft someone is waiting for must not queue behind a label's album.
+  private readonly c0mpute?: AiRouter;
+  constructor(private readonly options: EventWriterOptions) {
+    if (options.c0mputeKey) this.c0mpute = c0mputeRouter(options.c0mputeKey, { concurrency: 4, ...(options.fetch ? { fetcher: options.fetch } : {}) });
+  }
+
+  private key(provider: Exclude<Provider, "c0mpute">): string | undefined {
+    return provider === "openai" ? this.options.openaiKey : this.options.anthropicKey;
+  }
 
   async draft(accountId: string, value: unknown, signal?: AbortSignal): Promise<EventDraftResult> {
     if (!accountId) throw new EventWriterError("Sign in to use the AI writer.", 401);
     const input = writerInput(value);
-    if (!this.options.openaiKey && !this.options.anthropicKey) throw new EventWriterError("The AI writer is temporarily unavailable. You can keep writing here.", 503);
+    if (!this.c0mpute && !this.options.openaiKey && !this.options.anthropicKey) throw new EventWriterError("The AI writer is temporarily unavailable. You can keep writing here.", 503);
     if (this.active.has(accountId)) throw new EventWriterError("A draft is already being written. Wait for it or cancel it first.", 429, 5);
     if (this.active.size >= 4) throw new EventWriterError("The AI writer is busy. Try again in a moment.", 503, 10);
     const limit = this.guard.check(accountId, {allowed: 6, windowMs: 10 * 60_000});
     if (!limit.ok) throw new EventWriterError("You have requested several drafts. Try again in a few minutes.", 429, limit.retryAfter);
     this.active.add(accountId);
     try {
-      for (const provider of ["openai", "claude"] as const) {
-        const key = provider === "openai" ? this.options.openaiKey : this.options.anthropicKey;
-        if (!key) continue;
+      for (const provider of ["c0mpute", "openai", "claude"] as const) {
+        const key = provider === "c0mpute" ? "" : this.key(provider);
+        if (provider === "c0mpute" ? !this.c0mpute : !key) continue;
         if (signal?.aborted) throw new EventWriterError("Draft cancelled.", 499);
         try {
-          const draft = await this.generate(provider, key, input, signal);
+          const draft = provider === "c0mpute" ? await this.generateC0mpute(input, signal) : await this.generate(provider, key as string, input, signal);
           if (signal?.aborted) throw new EventWriterError("Draft cancelled.", 499);
           return {draft, provider};
         }
@@ -94,6 +108,17 @@ export class EventWriter {
     } finally { this.active.delete(accountId); }
   }
 
+  private async generateC0mpute(input: WriterInput, signal?: AbortSignal): Promise<EventDraft> {
+    const {value} = await askC0mpute(this.c0mpute as AiRouter, {
+      system: `${INSTRUCTIONS}\n\n${jsonInstructions("event_draft", SCHEMA)}`,
+      user: JSON.stringify(input),
+      maxTokens: 2048,
+      timeoutMs: this.options.c0mputeTimeoutMs ?? C0MPUTE_MIN_WAIT_MS,
+      ...(signal ? {signal} : {}),
+    }, text => draftOf(firstObject(text)));
+    return value;
+  }
+
   private async generate(provider: "openai" | "claude", key: string, input: WriterInput, signal?: AbortSignal): Promise<EventDraft> {
     const timeout = AbortSignal.timeout(this.options.timeoutMs ?? 25_000);
     const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
@@ -121,6 +146,6 @@ export class EventWriter {
     if (body["stop_reason"] === "refusal" || blocks.some(block => block?.type === "refusal")) throw new Refused();
     if (openai ? body["status"] !== "completed" : body["stop_reason"] !== "end_turn") throw new Error("incomplete draft");
     const text = blocks.filter(block => block?.type === (openai ? "output_text" : "text")).map(block => typeof block.text === "string" ? block.text : "").join("");
-    return draftFrom(text);
+    return draftOf(JSON.parse(text));
   }
 }

package/src/label-routes.ts

@@ -202,6 +202,15 @@ export async function handleLabelRoutes(
       ctx.json(response, 202, label.status());
       return true;
     }
+    if (path === "/api/v1/stations/label/adopt" && method === "POST") {
+      // Albums already on disk (copied from another server) back on the label, with their old keys where given.
+      const input = await jsonBody(ctx, request);
+      const record = (value: unknown): Record<string, string> => value && typeof value === "object" && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value as Record<string, unknown>).filter(([, one]) => typeof one === "string")) as Record<string, string>
+        : {};
+      ctx.json(response, 200, { adopted: await label.adopt({ keys: record(input["keys"]), albums: record(input["albums"]), enabled: input["enabled"] !== false }) });
+      return true;
+    }
     if (path === "/api/v1/stations/label/artists" && method === "POST") {
       const input = await jsonBody(ctx, request);
       if (input["roster"] === true) {

package/src/music-hub.ts

@@ -45,6 +45,21 @@ export interface MusicHubOptions {
   peers: () => string[];
   fetcher?: typeof fetch;
   now?: () => number;
+  /**
+   * Label servers that moved, old https origin to new (a box gone, its label adopted
+   * on another): /music addresses under the old origin's id go to the new one's.
+   */
+  moved?: Record<string, string>;
+}
+
+/** NIXAMP_MUSIC_MOVED: "https://old:4321>https://new:4321", several separated by commas. */
+export function parseMoved(text: string | undefined): Record<string, string> {
+  const moved: Record<string, string> = {};
+  for (const pair of (text ?? "").split(",")) {
+    const [from, to] = pair.split(">").map((one) => one.trim().replace(/\/+$/, ""));
+    if (from && to && /^https?:\/\//.test(from) && /^https?:\/\//.test(to) && from !== to) moved[from] = to;
+  }
+  return moved;
 }
 
 export class MusicHub {
@@ -60,10 +75,22 @@ export class MusicHub {
   /** The https origin behind an opaque id, among the servers known now. */
   resolve(id: string): string {
     if (!/^[a-f0-9]{10}$/.test(id)) return "";
-    if (!this.bases.has(id)) for (const base of this.options.peers()) this.bases.set(serverId(base), base);
+    if (!this.bases.has(id)) for (const base of this.peers()) this.bases.set(serverId(base), base);
     return this.bases.get(id) ?? "";
   }
 
+  /** The servers to gather, less any that moved (the same label would be listed twice). */
+  private peers(): string[] {
+    const moved = this.options.moved ?? {};
+    return this.options.peers().filter((base) => !moved[base.replace(/\/+$/, "")]);
+  }
+
+  /** The id a moved server goes by now, or "" when this id never moved. */
+  movedTo(id: string): string {
+    for (const [from, to] of Object.entries(this.options.moved ?? {})) if (serverId(from) === id) return serverId(to);
+    return "";
+  }
+
   /** The catalogue, gathered at most once a minute (a slow or gone server is left out, not waited on). */
   catalogue(): Promise<HubCatalogue> {
     if (this.cache && this.now() - this.cache.at < 60_000) return this.cache.value;
@@ -85,7 +112,7 @@ export class MusicHub {
   }
 
   private async gather(): Promise<HubCatalogue> {
-    const peers = [...new Set(this.options.peers())];
+    const peers = [...new Set(this.peers())];
     const holders = new Set<string>();
     const genres = new Map<string, { genre: string; stations: HubStation[]; artists: HubArtist[] }>();
     const stations: HubStation[] = [];
@@ -192,6 +219,15 @@ export async function handleMusicRoutes(request: IncomingMessage, response: Serv
     return true;
   }
   if (method !== "GET" && method !== "HEAD") { ctx.json(response, 405, { error: "not like that" }); return true; }
+  // A label that moved to another server: its old addresses (shared links, search results) go to the new ones.
+  const old = /^(\/music\/(?:artist|album|member)\/|\/api\/v1\/music\/(?:file|member)\/)([a-f0-9]{10})(\/.*)$/.exec(path);
+  const now = old ? ctx.hub.movedTo?.(old[2]!) ?? "" : "";
+  if (old && now) {
+    const query = (request.url ?? "").includes("?") ? (request.url ?? "").slice((request.url ?? "").indexOf("?")) : "";
+    response.writeHead(301, { location: `${old[1]}${now}${old[3]}${query}`, "cache-control": "public, max-age=86400" });
+    response.end();
+    return true;
+  }
   if (path === "/api/v1/music") {
     ctx.json(response, 200, await ctx.hub.catalogue());
     return true;