nixamp 0.34.0 → 0.36.0

package/dist/station-routes.js

@@ -1,9 +1,10 @@
+import { alertsFor } from "./station-metering.js";
 import { StationError, channelOf, tokensMatch, } from "./stations.js";
 /** The three things a station's link opens. */
 const LISTEN = /^\/api\/v1\/stations\/([a-z0-9]{10})\/(stream|state|listen\.m3u|events)$/;
 /** Whether this path is one a station's own link may open, without the server's key. */
 export function isStationListenPath(path) {
-    return LISTEN.test(path);
+    return LISTEN.test(path) || path === "/api/v1/stations/guide";
 }
 function fail(ctx, response, error) {
     if (error instanceof StationError) {
@@ -42,7 +43,10 @@ export function publicView(ctx, station) {
         state,
         // Tags, or nothing: a bare file name is the owner's, not the public's.
         nowPlaying: track && (track.title || track.artist) ? track : null,
-        format: state === "stopped" || state === "offline" ? null : { codec: "mp3", bitrateKbps: station.bitrate, sampleRate: 48_000, channels: 2 },
+        kind: station.video ? "video" : "audio",
+        format: state === "stopped" || state === "offline" ? null : station.video
+            ? { codec: "h264+aac", bitrateKbps: station.bitrate, sampleRate: 48_000, channels: 2 }
+            : { codec: "mp3", bitrateKbps: station.bitrate, sampleRate: 48_000, channels: 2 },
         listeners: ctx.runner.listeners(station.id),
     };
 }
@@ -56,6 +60,10 @@ export function ownerView(ctx, station) {
         error: ctx.runner.error(station.id),
         links: links(ctx, station),
         nowPlaying: nowPlayingFile(ctx, station),
+        ...(ctx.usage && ctx.limits ? {
+            metrics: { listeners: ctx.usage.listeners(station.id), month: ctx.usage.thisMonth(station.id), limits: ctx.limits },
+            alerts: alertsFor(station, ctx.runner.observed(station.id), ctx.runner.downSince(station.id), ctx.usage.thisMonth(station.id), ctx.limits),
+        } : {}),
     };
 }
 /** Answers anything under /api/v1/stations; false when the path is not one. */
@@ -63,6 +71,15 @@ export async function handleStations(request, response, path, url, ctx) {
     if (path !== "/api/v1/stations" && !path.startsWith("/api/v1/stations/"))
         return false;
     const method = request.method ?? "GET";
+    // The public guide: only stations their owner made public and listed, with
+    // their links, because public is what that means. Nothing else, ever.
+    if (path === "/api/v1/stations/guide" && (method === "GET" || method === "HEAD")) {
+        const listed = ctx.store.list().filter((one) => one.visibility === "public" && one.listed);
+        ctx.json(response, 200, {
+            stations: listed.map((one) => ({ ...publicView(ctx, one), page: links(ctx, one).page, m3u: links(ctx, one).m3u })),
+        });
+        return true;
+    }
     const listen = LISTEN.exec(path);
     if (listen) {
         const station = ctx.store.get(listen[1]);
@@ -153,20 +170,46 @@ export async function handleStations(request, response, path, url, ctx) {
             ctx.json(response, 503, { error: "the station is not on the air", code: "not_live", state: ctx.runner.observed(station.id) });
             return true;
         }
+        // Admitted only within the station's and the server's limits, and the
+        // month's allowance; refused with what to do about it.
+        const refused = method === "GET" && ctx.usage && ctx.limits ? ctx.usage.admit(station.id, ctx.limits) : null;
+        if (refused) {
+            response.writeHead(refused.status, { ...ctx.headers, "content-type": "application/json; charset=utf-8", "retry-after": String(refused.retryAfter) });
+            response.end(JSON.stringify({ error: refused.error, code: refused.code, retryAfter: refused.retryAfter }));
+            return true;
+        }
         response.writeHead(200, { ...ctx.headers, "content-type": ctx.channels.contentType(channelId), "cache-control": "no-store" });
         if (method === "HEAD") {
             response.end();
             return true;
         }
-        const detach = ctx.channels.listen(channelId, response);
+        // Every byte that goes out through the link is counted against the station.
+        const usage = ctx.usage;
+        const counted = usage
+            ? {
+                write: (chunk) => {
+                    usage.delivered(station.id, chunk.length);
+                    return response.write(chunk);
+                },
+                end: () => { response.end(); },
+                pending: () => response.writableLength,
+            }
+            : response;
+        const detach = ctx.channels.listen(channelId, counted);
         if (detach === null) {
             response.end();
             return true;
         }
+        const left = usage?.joined(station.id);
         const untrack = ctx.runner.track(station.id, { end: () => response.destroy() });
+        let gone = false;
         const leave = () => {
+            if (gone)
+                return;
+            gone = true;
             detach();
             untrack();
+            left?.();
         };
         request.on("close", leave);
         response.on("close", leave);
@@ -177,6 +220,15 @@ export async function handleStations(request, response, path, url, ctx) {
         ctx.json(response, 403, { error: "only this server's owner manages its stations", code: "forbidden" });
         return true;
     }
+    // Changes are limited apart from listening, so neither starves the other.
+    if (method !== "GET" && ctx.throttle) {
+        const wait = ctx.throttle();
+        if (wait) {
+            response.setHeader("retry-after", String(wait.retryAfter));
+            ctx.json(response, 429, { error: "too many changes at once; wait a moment", code: "rate_limited", retryAfter: wait.retryAfter });
+            return true;
+        }
+    }
     const body = async () => {
         if (method === "GET" || method === "DELETE")
             return {};
@@ -221,6 +273,22 @@ export async function handleStations(request, response, path, url, ctx) {
             ctx.json(response, 405, { error: "GET or POST", code: "method_not_allowed" });
             return true;
         }
+        if (path === "/api/v1/stations/auto") {
+            if (!ctx.auto) {
+                ctx.json(response, 404, { error: "auto stations are not available here", code: "not_found" });
+                return true;
+            }
+            if (method === "GET") {
+                ctx.json(response, 200, { setting: ctx.auto.setting() });
+                return true;
+            }
+            if (method === "POST") {
+                ctx.json(response, 200, { report: await ctx.auto.sync(await body()) });
+                return true;
+            }
+            ctx.json(response, 405, { error: "GET or POST", code: "method_not_allowed" });
+            return true;
+        }
         const match = /^\/api\/v1\/stations\/([a-z0-9]{10})(?:\/([a-z-]+))?$/.exec(path);
         if (!match) {
             ctx.json(response, 404, { error: "no such station", code: "not_found" });
@@ -253,11 +321,30 @@ export async function handleStations(request, response, path, url, ctx) {
             ctx.json(response, 405, { error: "GET, PATCH or DELETE", code: "method_not_allowed" });
             return true;
         }
+        if (action === "metrics" && method === "GET") {
+            if (!ctx.usage || !ctx.limits) {
+                ctx.json(response, 404, { error: "metering is off on this server", code: "not_found" });
+                return true;
+            }
+            ctx.json(response, 200, {
+                listeners: ctx.usage.listeners(station.id),
+                month: ctx.usage.thisMonth(station.id),
+                history: ctx.usage.history(station.id),
+                limits: ctx.limits,
+                alerts: alertsFor(station, ctx.runner.observed(station.id), ctx.runner.downSince(station.id), ctx.usage.thisMonth(station.id), ctx.limits),
+            });
+            return true;
+        }
         if (method !== "POST") {
             ctx.json(response, 405, { error: "POST", code: "method_not_allowed" });
             return true;
         }
         if (action === "start") {
+            const running = ctx.store.list().filter((one) => one.desired === "running" && one.id !== id).length;
+            if (ctx.limits && ctx.limits.runningStations > 0 && running >= ctx.limits.runningStations) {
+                ctx.json(response, 409, { error: `this server runs at most ${ctx.limits.runningStations} stations at once; stop one first`, code: "too_many_running" });
+                return true;
+            }
             const started = await ctx.runner.start(id);
             ctx.json(response, 200, { station: ownerView(ctx, started) });
             return true;

package/dist/station-runner.d.ts

@@ -23,6 +23,11 @@ export interface RunnerDeps {
     roots: () => string[];
     log?: (line: string) => void;
     now?: () => number;
+    /** Told when a station is restarted after an unexpected end, and when a file will not play. */
+    onRestart?: (id: string) => void;
+    onFailure?: (id: string) => void;
+    /** A file for a break on a radio (false) or TV (true) station, or null for none. */
+    breaks?: (video: boolean) => Promise<string | null>;
 }
 /** Something a listener is connected through, that can be ended. */
 export interface Ending {
@@ -37,6 +42,8 @@ export declare class StationRunner {
     private starting;
     private errors;
     private listening;
+    /** When a station that should be on went off, for "off the air for N minutes". */
+    private down;
     constructor(deps: RunnerDeps);
     private now;
     private log;
@@ -58,6 +65,8 @@ export declare class StationRunner {
     private scheduleRecovery;
     private cancelRecovery;
     observed(id: string): Observed;
+    /** When it went off while wanted, or 0 when it is not off. */
+    downSince(id: string): number;
     error(id: string): string;
     /** A listener on a station's link, ended if the link is revoked. */
     track(id: string, listener: Ending): () => void;

package/dist/station-runner.js

@@ -10,6 +10,8 @@ export class StationRunner {
     starting = new Set();
     errors = new Map();
     listening = new Map();
+    /** When a station that should be on went off, for "off the air for N minutes". */
+    down = new Map();
     constructor(deps) {
         this.deps = deps;
     }
@@ -41,6 +43,7 @@ export class StationRunner {
     /** Wanted off, and taken off. Stays off across restarts. */
     stop(id) {
         const station = this.deps.store.setDesired(id, "stopped", this.now());
+        this.down.delete(id);
         this.cancelRecovery(id);
         this.attempts.delete(id);
         this.errors.delete(id);
@@ -104,8 +107,12 @@ export class StationRunner {
                         return now ? this.playable(now) : [];
                     },
                     excluded: (file) => store.isExcluded(id, file),
+                    ...(station.breaksEvery > 0 && this.deps.breaks
+                        ? { breaks: { everySeconds: station.breaksEvery, next: () => this.deps.breaks(station.video) } }
+                        : {}),
                     onFailure: ({ file, reason }) => {
                         this.errors.set(id, reason);
+                        this.deps.onFailure?.(id);
                         if (store.recordFailure(id, file)) {
                             this.log(`  Station "${station.name}": left out a file that failed ${EXCLUDE_AFTER} times.`);
                         }
@@ -118,6 +125,7 @@ export class StationRunner {
                 return false;
             }
             this.startedAt.set(id, this.now());
+            this.down.delete(id);
             this.deps.channels.keep(channelId);
             return true;
         }
@@ -147,6 +155,9 @@ export class StationRunner {
             this.errors.delete(id);
             return;
         }
+        if (!this.down.has(id))
+            this.down.set(id, this.now());
+        this.deps.onRestart?.(id);
         const ran = this.now() - (this.startedAt.get(id) ?? 0);
         if (ran >= HEALTHY_RUN_MS)
             this.attempts.delete(id);
@@ -185,6 +196,10 @@ export class StationRunner {
             return info.redials ? "recovering" : "live";
         return (this.attempts.get(id) ?? 0) <= RECOVERY_DELAYS_MS.length && this.timers.has(id) ? "recovering" : "offline";
     }
+    /** When it went off while wanted, or 0 when it is not off. */
+    downSince(id) {
+        return this.down.get(id) ?? 0;
+    }
     error(id) {
         return this.errors.get(id) ?? "";
     }

package/dist/station-usage.d.ts

@@ -1,2 +1,2 @@
 /** `nixamp station` usage, apart so `nixamp help station` does not load the client. */
-export declare const USAGE = "nixamp station \u2014 make a collection into a station\n\n  nixamp station list\n  nixamp station create --name NAME (--folder PATH | --playlist ID | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128]\n  nixamp station show ID\n  nixamp station status ID\n  nixamp station start ID\n  nixamp station stop ID\n  nixamp station skip ID\n  nixamp station retry ID          try every left-out file again\n  nixamp station publish ID --basis owned|permission|licensed|public-domain [--note TEXT] [--unlisted] [--no-list]\n  nixamp station unpublish ID [--private]\n  nixamp station link ID [--rotate]\n  nixamp station delete ID\n\n  --json        machine-readable output\n  --url, --key  another server, as with `nixamp admin`\n\nA new station is private and stopped. Starting it does not publish it.";
+export declare const USAGE = "nixamp station \u2014 make a collection into a station\n\n  nixamp station list\n  nixamp station create --name NAME (--folder PATH | --playlist ID | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128]\n  nixamp station show ID\n  nixamp station status ID\n  nixamp station start ID\n  nixamp station stop ID\n  nixamp station skip ID\n  nixamp station retry ID          try every left-out file again\n  nixamp station publish ID --basis owned|permission|licensed|public-domain [--note TEXT] [--unlisted] [--no-list]\n  nixamp station unpublish ID [--private]\n  nixamp station link ID [--rotate]\n  nixamp station delete ID\n  nixamp station auto [--no-video] [--min 10] [--films 3] [--tv 2] [--breaks 600] [--no-start]\n                     a station per genre, kept in step with the library (--off stops it)\n\n  --json        machine-readable output\n  --url, --key  another server, as with `nixamp admin`\n\nA new station is private and stopped. Starting it does not publish it.";

package/dist/station-usage.js

@@ -13,6 +13,8 @@ export const USAGE = `nixamp station — make a collection into a station
   nixamp station unpublish ID [--private]
   nixamp station link ID [--rotate]
   nixamp station delete ID
+  nixamp station auto [--no-video] [--min 10] [--films 3] [--tv 2] [--breaks 600] [--no-start]
+                     a station per genre, kept in step with the library (--off stops it)
 
   --json        machine-readable output
   --url, --key  another server, as with \`nixamp admin\`

package/dist/stations.d.ts

@@ -26,6 +26,12 @@ export interface Station {
     listenToken: string;
     /** Audio bitrate of the station's rendition, in kbps. */
     bitrate: number;
+    /** A TV station: pictures as well as sound. */
+    video: boolean;
+    /** A break (advert or ident) at most this often, in seconds; 0 for none. */
+    breaksEvery: number;
+    /** Made and kept up to date by auto stations (e.g. "genre:audio:rock"); "" for one a person made. */
+    auto: string;
     rights: Rights | null;
     /** nixamp.com account that made it, "" when made with the control key. */
     owner: string;
@@ -59,6 +65,8 @@ export interface StationInput {
     shuffle?: unknown;
     repeat?: unknown;
     bitrate?: unknown;
+    video?: unknown;
+    breaksEvery?: unknown;
 }
 /** The stations of one server, kept in one file beside its keys. */
 export declare class StationStore {
@@ -77,6 +85,10 @@ export declare class StationStore {
     /** The station a create with this key already made. */
     byIdempotencyKey(key: string): Station | undefined;
     create(input: StationInput, items: string[], owner: string, now?: number, idempotencyKey?: string): Station;
+    private breaksFrom;
+    /** Mark a station as made by auto stations, so a later sync updates it rather than making another. */
+    markAuto(id: string, key: string): Station;
+    byAuto(key: string): Station | undefined;
     private bitrateFrom;
     /** Name, words, files and rotation. Who may listen is changed by publish/unpublish. */
     update(id: string, input: StationInput, items: string[] | null, now?: number): Station;
@@ -126,6 +138,8 @@ export interface PublicStation {
     description: string;
     visibility: Visibility;
     state: Observed;
+    /** Radio or TV. */
+    kind: "audio" | "video";
     nowPlaying: {
         title: string;
         artist: string;

package/dist/stations.js

@@ -121,6 +121,9 @@ export class StationStore {
                         owner: one.owner ?? "",
                         description: one.description ?? "",
                         idempotencyKey: one.idempotencyKey ?? "",
+                        video: one.video ?? false,
+                        breaksEvery: one.breaksEvery ?? 0,
+                        auto: one.auto ?? "",
                     });
                 }
             }
@@ -169,6 +172,9 @@ export class StationStore {
             desired: "stopped",
             listenToken: newToken(),
             bitrate: this.bitrateFrom(input.bitrate),
+            video: input.video === true,
+            breaksEvery: this.breaksFrom(input.breaksEvery),
+            auto: "",
             rights: null,
             owner,
             failures: {},
@@ -180,6 +186,24 @@ export class StationStore {
         this.save();
         return station;
     }
+    breaksFrom(value) {
+        if (value === undefined || value === null || value === 0)
+            return 0;
+        if (typeof value !== "number" || !Number.isInteger(value) || value < 120 || value > 86_400) {
+            throw new StationError("invalid_breaks", "breaksEvery is seconds between breaks, from 120 to 86400, or 0 for none");
+        }
+        return value;
+    }
+    /** Mark a station as made by auto stations, so a later sync updates it rather than making another. */
+    markAuto(id, key) {
+        const station = this.require(id);
+        station.auto = key;
+        this.save();
+        return station;
+    }
+    byAuto(key) {
+        return [...this.stations.values()].find((one) => one.auto === key);
+    }
     bitrateFrom(value) {
         if (value === undefined)
             return DEFAULT_BITRATE;
@@ -205,6 +229,8 @@ export class StationStore {
             station.repeat = input.repeat !== false;
         if (input.bitrate !== undefined)
             station.bitrate = this.bitrateFrom(input.bitrate);
+        if (input.breaksEvery !== undefined)
+            station.breaksEvery = this.breaksFrom(input.breaksEvery);
         if (items !== null) {
             if (items.length === 0)
                 throw new StationError("empty_station", "a station needs at least one file that plays");

package/package.json

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

package/src/auto-stations.ts

@@ -0,0 +1,171 @@
+/**
+ * Auto stations: a station for every genre the library has, kept up to date.
+ *
+ * Radio from the music's own genre tags, folded into genres a listener would
+ * recognise ("Rap/Hip-Hop", "Hip Hop" and "Gangsta" are all Hip-Hop; "Pop,
+ * Rock, Metal" is in three). TV from the genres nichedb knows for each film.
+ * Lectures, interviews and talk are not music and stay out of radio.
+ *
+ * Each genre's station is found again by its key on the next sync and its
+ * files replaced, so new music lands in the right station by itself and a
+ * station's link never changes. Nothing is published: an auto station is
+ * unlisted, a link for whoever the owner hands it to. Making one public is
+ * the owner's decision, with the rights basis that asks for.
+ *
+ * TV costs a core per running station (it is re-encoded), so only the
+ * biggest few run; the rest are made and wait, stopped.
+ */
+import type { LibraryIndex, LibraryItem } from "./library-index.ts";
+import { shown } from "./library-index.ts";
+import type { StationRunner } from "./station-runner.ts";
+import type { Station, StationStore } from "./stations.ts";
+
+const RULES: Array<[RegExp, string]> = [
+  [/metal|thrash|trash|doom|death|grind|neue deutsche|h(a|ä)rte|djent|metalcore/i, "Metal"],
+  [/punk|hardcore|emo|screamo/i, "Punk"],
+  [/hip.?hop|\brap\b|gangsta|trap|grime|drill/i, "Hip-Hop"],
+  [/industrial/i, "Industrial"],
+  [/electro|techno|house|edm|dance|trance|ambient|drum.?n.?bass|dubstep|synth/i, "Electronic"],
+  [/reggae|\bska\b|\bdub\b|dancehall/i, "Reggae"],
+  [/jazz|swing|bebop/i, "Jazz"],
+  [/blues/i, "Blues"],
+  [/classical|symphon|orchestr|baroque|opera/i, "Classical"],
+  [/country|folk|bluegrass|americana/i, "Country & Folk"],
+  [/soul|r&b|rnb|funk|motown|gospel/i, "Soul & R&B"],
+  [/latin|reggaeton|salsa|bachata|cumbia/i, "Latin"],
+  [/alternat|indie|ind(e|é)|grunge|shoegaze/i, "Alternative"],
+  [/rock/i, "Rock"],
+  [/pop/i, "Pop"],
+];
+
+const NOT_MUSIC = /lecture|interview|audiobook|podcast|speech|spoken|talk|course|sermon|lesson|comedy/i;
+
+/** The genres a tag belongs to, recognisably named; [] when it is not music or not known. */
+export function genreBuckets(raw: string): string[] {
+  if (!raw || NOT_MUSIC.test(raw)) return [];
+  const out = new Set<string>();
+  for (const part of raw.split(/[,;/|]+|\s+&\s+/)) {
+    const hit = RULES.find(([pattern]) => pattern.test(part));
+    if (hit) out.add(hit[1]);
+  }
+  return [...out];
+}
+
+export interface AutoOptions {
+  /** Radio from tags; TV from nichedb's genres. */
+  video: boolean;
+  /** A genre needs at least this many files (radio) to get a station. */
+  minItems: number;
+  /** Films for a TV station. */
+  minFilms: number;
+  start: boolean;
+  /** TV stations running at once. */
+  maxVideoRunning: number;
+  /** Seconds between breaks on the stations this makes. */
+  breaksEvery: number;
+}
+
+export const DEFAULT_AUTO: AutoOptions = { video: true, minItems: 10, minFilms: 3, start: true, maxVideoRunning: 2, breaksEvery: 600 };
+
+export interface AutoReport {
+  radio: Array<{ genre: string; id: string; files: number; made: boolean; running: boolean }>;
+  tv: Array<{ genre: string; id: string; films: number; made: boolean; running: boolean }>;
+  skipped: string[];
+}
+
+export interface AutoDeps {
+  index: LibraryIndex;
+  store: StationStore;
+  runner: StationRunner;
+  owner: string;
+  /** nichedb's genres for a film, from the enrichment cache or a lookup; [] when unknown. */
+  filmGenres?: (title: string) => Promise<string[]>;
+  /** Whether another station may be started now (the server's running limit). */
+  mayStart: () => boolean;
+  log?: (line: string) => void;
+}
+
+function order(items: LibraryItem[]): LibraryItem[] {
+  return [...items].sort((a, b) => {
+    const x = shown(a), y = shown(b);
+    return (x.albumArtist || x.artist).localeCompare(y.albumArtist || y.artist) || x.album.localeCompare(y.album) || x.disc - y.disc || x.track - y.track || a.rel.localeCompare(b.rel);
+  });
+}
+
+async function upsert(
+  deps: AutoDeps,
+  key: string,
+  name: string,
+  paths: string[],
+  video: boolean,
+  options: AutoOptions,
+): Promise<{ station: Station; made: boolean }> {
+  const existing = deps.store.byAuto(key);
+  if (existing) {
+    const same = existing.items.length === paths.length && existing.items.every((one, at) => one === paths[at]);
+    return { station: same ? existing : deps.store.update(existing.id, {}, paths), made: false };
+  }
+  const station = deps.store.create({ name, shuffle: true, repeat: true, video, breaksEvery: options.breaksEvery }, paths, deps.owner);
+  deps.store.markAuto(station.id, key);
+  // A link, not a listing: unlisted needs no rights basis and publishes nothing.
+  deps.store.setAccess(station.id, { visibility: "unlisted" }, deps.owner || "auto");
+  return { station, made: true };
+}
+
+/** Make or update a station per genre; start what the limits allow. */
+export async function syncAutoStations(deps: AutoDeps, options: AutoOptions = DEFAULT_AUTO): Promise<AutoReport> {
+  const report: AutoReport = { radio: [], tv: [], skipped: [] };
+  const ready = deps.index.search({ state: "ready", limit: 500, offset: 0 });
+  // search() pages at 500; walk them all.
+  const all: LibraryItem[] = [...ready.items];
+  for (let offset = 500; offset < ready.total; offset += 500) all.push(...deps.index.search({ state: "ready", limit: 500, offset }).items);
+
+  const radio = new Map<string, LibraryItem[]>();
+  for (const item of all) {
+    if (item.video) continue;
+    for (const genre of genreBuckets(shown(item).genre)) {
+      const list = radio.get(genre) ?? [];
+      list.push(item);
+      radio.set(genre, list);
+    }
+  }
+  for (const [genre, items] of [...radio].sort((a, b) => b[1].length - a[1].length)) {
+    if (items.length < options.minItems) {
+      report.skipped.push(`${genre} radio (${items.length} files)`);
+      continue;
+    }
+    const { station, made } = await upsert(deps, `genre:audio:${genre.toLowerCase()}`, `${genre} Radio`, order(items).map((one) => one.path), false, options);
+    let running = station.desired === "running";
+    if (!running && options.start && deps.mayStart()) {
+      await deps.runner.start(station.id).then(() => { running = true; }, (error: Error) => deps.log?.(`  auto stations: ${genre} Radio did not start: ${error.message}`));
+    }
+    report.radio.push({ genre, id: station.id, files: items.length, made, running });
+  }
+
+  if (options.video && deps.filmGenres) {
+    const tv = new Map<string, LibraryItem[]>();
+    for (const item of all) {
+      if (!item.video || item.duration < 40 * 60) continue;
+      const genres = await deps.filmGenres(shown(item).title).catch(() => []);
+      for (const genre of genres.slice(0, 2)) {
+        const list = tv.get(genre) ?? [];
+        list.push(item);
+        tv.set(genre, list);
+      }
+    }
+    let runningTv = deps.store.list().filter((one) => one.video && one.auto && one.desired === "running").length;
+    for (const [genre, films] of [...tv].sort((a, b) => b[1].length - a[1].length)) {
+      if (films.length < options.minFilms) {
+        report.skipped.push(`${genre} TV (${films.length} films)`);
+        continue;
+      }
+      const { station, made } = await upsert(deps, `genre:video:${genre.toLowerCase()}`, `${genre} TV`, films.map((one) => one.path), true, options);
+      let running = station.desired === "running";
+      if (!running && options.start && runningTv < options.maxVideoRunning && deps.mayStart()) {
+        await deps.runner.start(station.id).then(() => { running = true; runningTv += 1; }, (error: Error) => deps.log?.(`  auto stations: ${genre} TV did not start: ${error.message}`));
+      }
+      report.tv.push({ genre, id: station.id, films: films.length, made, running });
+    }
+  }
+  return report;
+}

package/src/channels.ts

@@ -129,7 +129,7 @@ export interface PullResume {
    * lists of files on this machine; not remembered, because whoever owns the
    * rotation (the station) puts it back.
    */
-  rotation?: Pick<PlaylistInput, "repeat" | "order" | "current" | "excluded" | "onFailure" | "passOver">;
+  rotation?: Pick<PlaylistInput, "repeat" | "order" | "current" | "excluded" | "onFailure" | "passOver" | "breaks">;
 }
 
 /**

package/src/library-index.ts

@@ -335,6 +335,8 @@ export class LibraryIndex {
   private timer: ReturnType<typeof setTimeout> | null = null;
   private dirty = false;
   private jobs = new Map<string, { report: ScanReport; abort: AbortController }>();
+  /** Told when any scan finishes, for whatever keeps up with the library (auto stations). */
+  onScanned: ((report: ScanReport) => void) | null = null;
 
   constructor(
     private readonly file: string,
@@ -622,6 +624,9 @@ export class LibraryIndex {
     report.status = signal.aborted ? "cancelled" : "done";
     report.finishedAt = this.now();
     this.touch();
+    if (report.status === "done") {
+      try { this.onScanned?.(report); } catch { /* a listener's trouble is not the scan's */ }
+    }
     return report;
   }
 

package/src/library.ts

@@ -25,6 +25,8 @@ export interface Config {
   library?: string;
   /** Whether this machine is listed in the public directory; unset until chosen. */
   publish?: boolean;
+  /** Auto stations: a station per genre, re-synced after every library scan. */
+  autoStations?: Record<string, unknown>;
 }
 
 export function configPath(): string {
@@ -39,6 +41,7 @@ export function readConfig(): Config {
     return {
       ...(typeof record["library"] === "string" ? { library: record["library"] } : {}),
       ...(typeof record["publish"] === "boolean" ? { publish: record["publish"] } : {}),
+      ...(typeof record["autoStations"] === "object" && record["autoStations"] !== null ? { autoStations: record["autoStations"] as Record<string, unknown> } : {}),
     };
   } catch {
     return {};