nixamp 0.78.6 → 0.80.1

package/dist/ai-label.js

@@ -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.js";
 import { composerFromEnv, OutOfCredit } from "./ai-radio.js";
@@ -1742,6 +1742,54 @@ export function fileName(text) {
 export function genreSlug(genre) {
     return genre.normalize("NFKD").toLowerCase().replace(/&/g, "n").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "music";
 }
+/** The folders in a folder, hidden ones left out; none when it cannot be read. */
+function listDirs(folder) {
+    try {
+        return readdirSync(folder, { withFileTypes: true }).filter((one) => one.isDirectory() && !one.name.startsWith(".")).map((one) => one.name).sort();
+    }
+    catch {
+        return [];
+    }
+}
+function readText(file) {
+    try {
+        return readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function readJson(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function mtimeOf(file) {
+    try {
+        return Math.round(statSync(file).mtimeMs);
+    }
+    catch {
+        return 0;
+    }
+}
+/** The text under "## <heading>" in an artist.md (bandMarkdown). */
+function section(page, heading) {
+    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) {
+    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) {
     return `${String(song.n).padStart(3, "0")}. ${fileName(song.title)}`;
@@ -2452,7 +2500,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,
@@ -2615,7 +2663,7 @@ export class AiLabel {
     async plan(key) {
         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);
+            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);
@@ -2644,6 +2692,175 @@ export class AiLabel {
         this.log(`${artist.name} has a new album planned: "${album.title}" (${album.songs.length} songs)`);
         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 = {}) {
+        const report = { 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) => {
+            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, title) => {
+            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();
+        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"] : [];
+                    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 = [];
+                    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) => 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 = {
+                            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) => this.log(`could not put ${genre} on the air: ${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. */
+    async isFilmed(video) {
+        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) {
         if (this.timer)
             return;
@@ -3038,7 +3255,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)
@@ -3342,7 +3559,22 @@ export class AiLabel {
         return [...new Set(this.list().map((one) => one.genre))].sort();
     }
     stationFor(genre) {
-        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. */
+    labelName() {
+        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.
+     */
+    claimed(key, name) {
+        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. */
     place(genre) {

package/dist/ai-text.d.ts

@@ -1,9 +1,20 @@
+/**
+ * One question to a language model, one JSON answer.
+ *
+ * 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 --
+ * 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 { type AiRouter } from "@profullstack/ai-providers";
 export interface AskOptions {
     /** What the model is for, said once. */
     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;
@@ -27,6 +38,36 @@ export declare class NoModel extends Error {
 export declare function escapeInStrings(text: string): string;
 /** The first JSON object in a model's answer. */
 export declare function firstObject(text: string): Record<string, unknown>;
+/** The c0mpute key, or "" when there is none or C0MPUTE_DISABLED turns it off. */
+export declare function c0mputeKey(env?: Record<string, string | undefined>): string;
 /** Whether any model can be asked. */
 export declare function hasModel(env?: Record<string, string | undefined>): boolean;
+/**
+ * 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 declare const C0MPUTE_MIN_WAIT_MS = 120000;
+/** c0mpute alone: the fallbacks are this file's own chain, not the package's. */
+export declare function c0mputeRouter(key: string, options?: {
+    env?: Record<string, string | undefined>;
+    fetcher?: typeof fetch;
+    concurrency?: number;
+}): AiRouter;
+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 declare function askC0mpute<T>(router: AiRouter, ask: C0mputeAsk, read: (text: string) => T): Promise<{
+    model: string;
+    value: T;
+}>;
 export declare function askJson(options: AskOptions): Promise<Answer>;

package/dist/ai-text.js

@@ -3,15 +3,16 @@
  *
  * 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 } from "@profullstack/ai-providers";
 import { aiKey } from "./ai-keys.js";
 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)");
     }
 }
 /**
@@ -49,7 +50,7 @@ export function escapeInStrings(text) {
 }
 /** The first JSON object in a model's answer. */
 export function firstObject(text) {
-    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);
@@ -76,13 +77,67 @@ export function firstObject(text) {
     }
     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 = process.env) {
+    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 = process.env) {
-    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, options = {}) {
+    return createAiProviders({
+        env: { ...(options.env ?? process.env), C0MPUTE_API_KEY: key },
+        paidFallback: false,
+        c0mpute: {
+            ...(options.fetcher ? { fetch: options.fetcher } : {}),
+            ...(options.concurrency ? { concurrency: options.concurrency } : {}),
+        },
+    });
+}
+/**
+ * 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(router, ask, read) {
+    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.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.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;
+function sharedRouter(key, env) {
+    if (shared?.key !== key)
+        shared = { key, router: c0mputeRouter(key, { env }) };
+    return shared.router;
 }
 export async function askJson(options) {
     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);
@@ -90,6 +145,13 @@ export async function askJson(options) {
     // 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 = [];
+    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";

package/dist/event-writer.d.ts

@@ -10,9 +10,10 @@ export interface WriterInput extends EventDraft {
     duration: string;
     recurrence: string;
 }
+type Provider = "c0mpute" | "openai" | "claude";
 export interface EventDraftResult {
     draft: EventDraft;
-    provider: "openai" | "claude";
+    provider: Provider;
 }
 export declare class EventWriterError extends Error {
     readonly status: number;
@@ -21,19 +22,27 @@ export declare class EventWriterError extends Error {
 }
 export declare function writerInput(value: unknown): WriterInput;
 export interface EventWriterOptions {
+    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 declare class EventWriter {
     private readonly options;
     private readonly guard;
     private readonly active;
+    private readonly c0mpute?;
     constructor(options: EventWriterOptions);
+    private key;
     draft(accountId: string, value: unknown, signal?: AbortSignal): Promise<EventDraftResult>;
+    private generateC0mpute;
     private generate;
 }
+export {};

package/dist/event-writer.js

@@ -1,3 +1,5 @@
+import { jsonInstructions } from "@profullstack/ai-providers";
+import { askC0mpute, c0mputeRouter, C0MPUTE_MIN_WAIT_MS, firstObject } from "./ai-text.js";
 import { Guard } from "./guard.js";
 export class EventWriterError extends Error {
     status;
@@ -37,8 +39,7 @@ Return a clear title (at most 160 characters), a description (at most 5000 chara
 Write in the language of the host's notes. Describe what students will learn and what will happen, using only information supported by the notes.
 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) {
-    const value = JSON.parse(text);
+function draftOf(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("invalid draft");
     const row = value;
@@ -56,14 +57,22 @@ export class EventWriter {
     options;
     guard = new Guard();
     active = new Set();
+    // 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.
+    c0mpute;
     constructor(options) {
         this.options = options;
+        if (options.c0mputeKey)
+            this.c0mpute = c0mputeRouter(options.c0mputeKey, { concurrency: 4, ...(options.fetch ? { fetcher: options.fetch } : {}) });
+    }
+    key(provider) {
+        return provider === "openai" ? this.options.openaiKey : this.options.anthropicKey;
     }
     async draft(accountId, value, signal) {
         if (!accountId)
             throw new EventWriterError("Sign in to use the AI writer.", 401);
         const input = writerInput(value);
-        if (!this.options.openaiKey && !this.options.anthropicKey)
+        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);
@@ -74,14 +83,14 @@ export class EventWriter {
             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"]) {
-                const key = provider === "openai" ? this.options.openaiKey : this.options.anthropicKey;
-                if (!key)
+            for (const provider of ["c0mpute", "openai", "claude"]) {
+                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, input, signal);
                     if (signal?.aborted)
                         throw new EventWriterError("Draft cancelled.", 499);
                     return { draft, provider };
@@ -102,6 +111,16 @@ export class EventWriter {
             this.active.delete(accountId);
         }
     }
+    async generateC0mpute(input, signal) {
+        const { value } = await askC0mpute(this.c0mpute, {
+            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;
+    }
     async generate(provider, key, input, signal) {
         const timeout = AbortSignal.timeout(this.options.timeoutMs ?? 25_000);
         const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
@@ -134,6 +153,6 @@ export class EventWriter {
         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/dist/label-routes.js

@@ -181,6 +181,15 @@ export async function handleLabelRoutes(request, response, path, ctx) {
             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) => value && typeof value === "object" && !Array.isArray(value)
+                ? Object.fromEntries(Object.entries(value).filter(([, one]) => typeof one === "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) {