nixamp 0.45.5 → 0.46.1

package/dist/break-silence.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Silence in place of a break, for one listener of a station: the last resort.
+ *
+ * A listener with a listen pass (listen-pass.ts) skips breaks out of a head
+ * start of music (Channel.listenWithoutBreaks). Only when that is spent is a
+ * break replaced, by MP3 silence lasting as long as the bytes it stands in
+ * for, rather than a gap that stalls the player. Audio only; a
+ * fragmented MP4 cannot have fragments swapped, so a TV station's breaks are
+ * everybody's.
+ *
+ * The silent frame is MPEG-1 Layer III at 48 kHz (the rate every station is
+ * resampled to) with empty side information: four header bytes and zeros,
+ * which every decoder plays as nothing.
+ */
+/** One silent frame at this bitrate (128 kbps when the bitrate is not a Layer III one). */
+export declare function silentFrame(kbps: number): Buffer;
+export interface Writer {
+    write: (chunk: Buffer) => boolean;
+    end: () => void;
+    pending?: () => number;
+}
+/**
+ * A writer that sends silence instead of whatever is written while `inBreak()`
+ * says yes. `kbps` is the stream's bitrate, which is how a chunk's bytes become
+ * seconds.
+ */
+export declare function quietDuringBreaks(out: Writer, kbps: number, inBreak: () => boolean): Writer;

package/dist/break-silence.js

@@ -0,0 +1,57 @@
+/**
+ * Silence in place of a break, for one listener of a station: the last resort.
+ *
+ * A listener with a listen pass (listen-pass.ts) skips breaks out of a head
+ * start of music (Channel.listenWithoutBreaks). Only when that is spent is a
+ * break replaced, by MP3 silence lasting as long as the bytes it stands in
+ * for, rather than a gap that stalls the player. Audio only; a
+ * fragmented MP4 cannot have fragments swapped, so a TV station's breaks are
+ * everybody's.
+ *
+ * The silent frame is MPEG-1 Layer III at 48 kHz (the rate every station is
+ * resampled to) with empty side information: four header bytes and zeros,
+ * which every decoder plays as nothing.
+ */
+const SAMPLE_RATE = 48_000;
+const FRAME_SECONDS = 1152 / SAMPLE_RATE;
+/** MPEG-1 Layer III bitrate index by kbps. */
+const BITRATE_INDEX = {
+    32: 1, 40: 2, 48: 3, 56: 4, 64: 5, 80: 6, 96: 7, 112: 8, 128: 9, 160: 10, 192: 11, 224: 12, 256: 13, 320: 14,
+};
+/** One silent frame at this bitrate (128 kbps when the bitrate is not a Layer III one). */
+export function silentFrame(kbps) {
+    const rate = BITRATE_INDEX[kbps] ? kbps : 128;
+    const frame = Buffer.alloc((144 * rate * 1000) / SAMPLE_RATE);
+    // Sync, MPEG-1, Layer III, no CRC; bitrate, 48 kHz (01), no padding; stereo.
+    frame[0] = 0xff;
+    frame[1] = 0xfb;
+    frame[2] = (BITRATE_INDEX[rate] << 4) | (0b01 << 2);
+    frame[3] = 0x00;
+    return frame;
+}
+/**
+ * A writer that sends silence instead of whatever is written while `inBreak()`
+ * says yes. `kbps` is the stream's bitrate, which is how a chunk's bytes become
+ * seconds.
+ */
+export function quietDuringBreaks(out, kbps, inBreak) {
+    const frame = silentFrame(kbps);
+    const bytesPerSecond = (kbps * 1000) / 8;
+    let owed = 0;
+    return {
+        write: (chunk) => {
+            if (!inBreak()) {
+                owed = 0;
+                return out.write(chunk);
+            }
+            owed += chunk.length / bytesPerSecond;
+            const frames = Math.floor(owed / FRAME_SECONDS);
+            if (frames === 0)
+                return true;
+            owed -= frames * FRAME_SECONDS;
+            return out.write(Buffer.concat(Array.from({ length: frames }, () => frame)));
+        },
+        end: () => out.end(),
+        ...(out.pending ? { pending: out.pending } : {}),
+    };
+}

package/dist/channels.d.ts

@@ -168,6 +168,12 @@ export declare const BACKLOG_AUDIO: number;
  * until the channel ended, however long that was.
  */
 export declare const LISTENER_QUEUE: number;
+/**
+ * How much break-free radio a listener who skips breaks is handed on arrival:
+ * two minutes at 192k. Their player holds it, and each break they skip spends
+ * the length of the spot from it, so they never hear a gap.
+ */
+export declare const MUSIC_BACKLOG: number;
 /** Media-time window for complete MP4 fragments. Byte limits are a separate
  * memory ceiling; the measured byte rate is only a fallback for inputs with
  * no usable fragment timestamps. It must never make low-bitrate video old. */
@@ -270,6 +276,11 @@ export declare class Channel {
      * can begin at; for MP3 any point will do, a frame announces itself.
      */
     private recent;
+    /** Whether what the encoder is writing now is a break (a radio list's spot). */
+    private breakOn;
+    /** The last couple of minutes of a radio list without its breaks, for listenWithoutBreaks. */
+    private music;
+    private musicBytes;
     private fragmentClock;
     private fragmentTimes;
     private recentBytes;
@@ -420,6 +431,14 @@ export declare class Channel {
      */
     private feedThrough;
     listen(listener: Listener): () => void;
+    /**
+     * A radio list's listener who hears no breaks: handed the last couple of
+     * minutes of music at once, which their player holds, then everything but
+     * the breaks. Each skipped break spends its length of that head start, so
+     * there is no gap; only once it is all spent does a break become silence of
+     * the same length (`silence`), never the spot. Joining again refills it.
+     */
+    listenWithoutBreaks(listener: Listener, kbps: number, silence: (out: Listener) => Listener): () => void;
     /** Stay up with nobody watching: no longer on demand. */
     keep(): void;
     /** Nobody is watching an on-demand channel: give it a minute, then stop. */
@@ -485,6 +504,8 @@ export declare class Channels {
     contentType(id: string): string;
     /** Attach a listener, or null when nothing is playing on that channel. */
     listen(id: string, listener: Listener): (() => void) | null;
+    /** Attach a listener who skips a radio list's breaks (Channel.listenWithoutBreaks). */
+    listenWithoutBreaks(id: string, listener: Listener, kbps: number, silence: (out: Listener) => Listener): (() => void) | null;
     /** Feed a channel that already exists, for a publisher sending chunks. */
     writeTo(id: string, chunk: Buffer): boolean;
     /**

package/dist/channels.js

@@ -66,6 +66,12 @@ export const BACKLOG_AUDIO = 64 * 1024;
  * until the channel ended, however long that was.
  */
 export const LISTENER_QUEUE = 16 * 1024 * 1024;
+/**
+ * How much break-free radio a listener who skips breaks is handed on arrival:
+ * two minutes at 192k. Their player holds it, and each break they skip spends
+ * the length of the spot from it, so they never hear a gap.
+ */
+export const MUSIC_BACKLOG = 3 * 1024 * 1024;
 /** Media-time window for complete MP4 fragments. Byte limits are a separate
  * memory ceiling; the measured byte rate is only a fallback for inputs with
  * no usable fragment timestamps. It must never make low-bitrate video old. */
@@ -190,6 +196,11 @@ export class Channel {
      * can begin at; for MP3 any point will do, a frame announces itself.
      */
     recent = [];
+    /** Whether what the encoder is writing now is a break (a radio list's spot). */
+    breakOn = false;
+    /** The last couple of minutes of a radio list without its breaks, for listenWithoutBreaks. */
+    music = [];
+    musicBytes = 0;
     fragmentClock = new FragmentClock();
     fragmentTimes = new WeakMap();
     recentBytes = 0;
@@ -412,6 +423,13 @@ export class Channel {
                 }
             });
             child.stdio[3]?.on("error", () => undefined);
+            // A radio list's output is constant-bitrate MP3, so how many bytes it
+            // has written is exactly how far it has played: whether this chunk is
+            // a break, to the frame, rather than to progress's once a second.
+            const kbps = playlistInput && this.info.kind !== "video"
+                ? Number(/^(\d+)k$/.exec((playlistEncode ?? [])[playlistEncode.indexOf("-b:a") + 1] ?? "")?.[1] ?? 0)
+                : 0;
+            let written = 0;
             child.stdout?.on("data", (chunk) => {
                 // An ffmpeg that was replaced can still have a chunk in the pipe.
                 if (this.child !== child)
@@ -421,6 +439,12 @@ export class Channel {
                 sent = true;
                 this.info.bytes += chunk.byteLength;
                 this.rearm(child);
+                if (kbps > 0 && playlistInput) {
+                    this.breakOn = playlistInput.place((written * 8) / (kbps * 1000)).at === -1;
+                    written += chunk.byteLength;
+                }
+                else
+                    this.breakOn = this.info.playlistAt === -1;
                 this.emit(chunk);
             });
             child.stdout?.on("error", () => undefined);
@@ -669,6 +693,13 @@ export class Channel {
         this.measure(chunk.byteLength);
         if (!this.fragments) {
             this.remember(chunk, BACKLOG_AUDIO, false);
+            if (this.info.playlist && !this.breakOn) {
+                this.music.push(chunk);
+                this.musicBytes += chunk.byteLength;
+                while (this.music.length > 1 && this.musicBytes - this.music[0].byteLength > MUSIC_BACKLOG) {
+                    this.musicBytes -= this.music.shift().byteLength;
+                }
+            }
             this.send(chunk);
             return;
         }
@@ -934,6 +965,52 @@ export class Channel {
                 this.idleOut();
         };
     }
+    /**
+     * A radio list's listener who hears no breaks: handed the last couple of
+     * minutes of music at once, which their player holds, then everything but
+     * the breaks. Each skipped break spends its length of that head start, so
+     * there is no gap; only once it is all spent does a break become silence of
+     * the same length (`silence`), never the spot. Joining again refills it.
+     */
+    listenWithoutBreaks(listener, kbps, silence) {
+        const bytesPerSecond = (kbps * 1000) / 8;
+        let ahead = 0;
+        for (const piece of this.music) {
+            try {
+                listener.write(piece);
+            }
+            catch {
+                break;
+            }
+            ahead += piece.byteLength / bytesPerSecond;
+        }
+        const quiet = silence(listener);
+        const skipping = {
+            write: (chunk) => {
+                if (!this.breakOn)
+                    return listener.write(chunk);
+                const seconds = chunk.byteLength / bytesPerSecond;
+                if (ahead >= seconds) {
+                    ahead -= seconds;
+                    return true;
+                }
+                return quiet.write(chunk);
+            },
+            end: () => listener.end(),
+            ...(listener.pending ? { pending: () => listener.pending() } : {}),
+        };
+        this.listeners.add(skipping);
+        this.info.listeners = this.listeners.size;
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = null;
+        return () => {
+            this.listeners.delete(skipping);
+            this.info.listeners = this.listeners.size;
+            if (this.ephemeral && this.listeners.size === 0)
+                this.idleOut();
+        };
+    }
     /** Stay up with nobody watching: no longer on demand. */
     keep() {
         this.ephemeral = false;
@@ -1140,6 +1217,11 @@ export class Channels {
         const channel = this.open.get(id);
         return channel ? channel.listen(listener) : null;
     }
+    /** Attach a listener who skips a radio list's breaks (Channel.listenWithoutBreaks). */
+    listenWithoutBreaks(id, listener, kbps, silence) {
+        const channel = this.open.get(id);
+        return channel ? channel.listenWithoutBreaks(listener, kbps, silence) : null;
+    }
     /** Feed a channel that already exists, for a publisher sending chunks. */
     writeTo(id, chunk) {
         return this.open.get(id)?.write(chunk) ?? false;

package/dist/listen-pass.d.ts

@@ -0,0 +1,29 @@
+/** How long a pass is good for. The page asks again on every load. */
+export declare const PASS_TTL_SECONDS: number;
+/** Where a pass rides on a stream link (an audio element sends no headers). */
+export declare const PASS_PARAM = "pass";
+/** The signing secret, or "" where passes cannot be signed (every server but nixamp.com). */
+export declare function listenPassSecret(env?: NodeJS.ProcessEnv): string;
+export declare function mintListenPass(secret: string, nowMs?: number, ttlSeconds?: number): {
+    pass: string;
+    expires: number;
+};
+/** The expiry of a good pass in seconds, or 0. */
+export declare function checkListenPass(secret: string, pass: string, nowMs?: number): number;
+export interface VerifierOptions {
+    /** nixamp.com, which signed the pass. */
+    site: string;
+    /** Set on nixamp.com itself, which checks its own passes without asking. */
+    secret?: string;
+    fetcher?: typeof fetch;
+    now?: () => number;
+}
+/** Whether a pass is good, asked of nixamp.com once and then remembered until it expires. */
+export declare class ListenPassVerifier {
+    private readonly options;
+    /** pass -> whether it is good, and until when that answer stands. */
+    private readonly known;
+    constructor(options: VerifierOptions);
+    private now;
+    good(pass: string): Promise<boolean>;
+}

package/dist/listen-pass.js

@@ -0,0 +1,93 @@
+/**
+ * The listen pass: what a signed-in nixamp.com listener carries to a station
+ * on another server, so its breaks go quiet for them.
+ *
+ * Breaks are in the stream (playlist-input.ts), one stream for every
+ * listener, so a station cannot leave a spot out for one person: it can only
+ * send that person silence while everybody else hears it. To do even that it
+ * has to know who is signed in, and a station on server1 holds no accounts.
+ * nixamp.com does, so nixamp.com signs a short pass for a signed-in account
+ * (GET /api/v1/me/pass, credentialed from any *.nixamp.com page) and the
+ * station asks nixamp.com whether a pass is good (GET
+ * /api/v1/listen-pass/check), remembering the answer.
+ *
+ * A pass is `v1.<expiry seconds>.<signature>` and nothing else: no account
+ * id, because a station has no use for one and a link gets pasted around.
+ * Anybody holding a fresh pass hears no breaks until it expires, which is the
+ * same thing a signed-in listener sharing their screen would give away.
+ */
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+/** How long a pass is good for. The page asks again on every load. */
+export const PASS_TTL_SECONDS = 24 * 60 * 60;
+/** Where a pass rides on a stream link (an audio element sends no headers). */
+export const PASS_PARAM = "pass";
+/** The signing secret, or "" where passes cannot be signed (every server but nixamp.com). */
+export function listenPassSecret(env = process.env) {
+    if (env["NIXAMP_LISTEN_PASS_SECRET"])
+        return env["NIXAMP_LISTEN_PASS_SECRET"];
+    // Derived, so nixamp.com needs no new variable: a pass is not a session.
+    const jwt = env["NIXAMP_JWT_SECRET"] ?? "";
+    return jwt ? createHash("sha256").update(`listen-pass:${jwt}`).digest("hex") : "";
+}
+function sign(secret, body) {
+    return createHmac("sha256", secret).update(body).digest("base64url").slice(0, 32);
+}
+export function mintListenPass(secret, nowMs = Date.now(), ttlSeconds = PASS_TTL_SECONDS) {
+    const expires = Math.floor(nowMs / 1000) + ttlSeconds;
+    const body = `v1.${expires}`;
+    return { pass: `${body}.${sign(secret, body)}`, expires };
+}
+/** The expiry of a good pass in seconds, or 0. */
+export function checkListenPass(secret, pass, nowMs = Date.now()) {
+    const match = /^v1\.(\d{1,12})\.([A-Za-z0-9_-]{32})$/.exec(pass);
+    if (!secret || !match)
+        return 0;
+    const expires = Number(match[1]);
+    if (expires * 1000 <= nowMs)
+        return 0;
+    const want = Buffer.from(sign(secret, `v1.${expires}`));
+    const got = Buffer.from(match[2]);
+    return want.length === got.length && timingSafeEqual(want, got) ? expires : 0;
+}
+/** How long a refused pass is remembered, so a bad one cannot make us ask nixamp.com per request. */
+const REFUSED_MS = 5 * 60 * 1000;
+const MAX_REMEMBERED = 5_000;
+/** Whether a pass is good, asked of nixamp.com once and then remembered until it expires. */
+export class ListenPassVerifier {
+    options;
+    /** pass -> whether it is good, and until when that answer stands. */
+    known = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    async good(pass) {
+        if (!/^v1\.\d{1,12}\.[A-Za-z0-9_-]{32}$/.test(pass))
+            return false;
+        if (this.options.secret)
+            return checkListenPass(this.options.secret, pass, this.now()) > 0;
+        const seen = this.known.get(pass);
+        if (seen && seen.until > this.now())
+            return seen.good;
+        let expires = 0;
+        try {
+            const answer = await (this.options.fetcher ?? fetch)(`${this.options.site.replace(/\/+$/, "")}/api/v1/listen-pass/check?${PASS_PARAM}=${encodeURIComponent(pass)}`, { signal: AbortSignal.timeout(2_000) });
+            // nixamp.com down is not a refusal: nothing is remembered, and this
+            // listener hears the break this time.
+            if (answer.status >= 500)
+                return false;
+            const body = (await answer.json().catch(() => ({})));
+            expires = body.ok === true && typeof body.expires === "number" ? body.expires : 0;
+        }
+        catch {
+            return false;
+        }
+        if (this.known.size >= MAX_REMEMBERED)
+            this.known.clear();
+        const good = expires * 1000 > this.now();
+        this.known.set(pass, { good, until: good ? expires * 1000 : this.now() + REFUSED_MS });
+        return good;
+    }
+}

package/dist/server.js

@@ -101,6 +101,7 @@ import { EventWriter } from "./event-writer.js";
 import { handleLiveApi } from "./live-api.js";
 import { LiveEvents, eventStructuredData, isTicketed } from "./live-events.js";
 import { Tickets, needsTicket, ticketFrom, ticketsFromEnv } from "./tickets.js";
+import { ListenPassVerifier, PASS_PARAM, checkListenPass, listenPassSecret, mintListenPass } from "./listen-pass.js";
 import { Layouts } from "./layouts.js";
 import { Rooms } from "./rooms.js";
 import { Trollbox, TrollboxError, fallbackHandle, roomFor } from "./trollbox.js";
@@ -1246,6 +1247,9 @@ export function isSignInPath(path) {
         path === "/api/v1/servers" ||
         path.startsWith("/api/v1/servers/") ||
         path === "/api/v1/me/handle" ||
+        // A listen pass is the session's to ask for and anybody's to check.
+        path === "/api/v1/me/pass" ||
+        path === "/api/v1/listen-pass/check" ||
         path === "/api/v1/me/profile" ||
         path.startsWith("/api/v1/me/profile/") ||
         // A stored photo is public: it is on every class the host runs.
@@ -1478,6 +1482,12 @@ export function createHandler(engine, options) {
         // away, which are the same thing as far as "is it still going" goes.
         response.once("close", () => tracker.close(id));
     };
+    // Signs listen passes where accounts live (nixamp.com); "" everywhere else.
+    const listenPassKey = listenPassSecret();
+    const listenPasses = new ListenPassVerifier({
+        site: process.env["NIXAMP_SITE"] || "https://nixamp.com",
+        ...(listenPassKey ? { secret: listenPassKey } : {}),
+    });
     return async function handle(request, response) {
         const url = new URL(request.url ?? "/", "http://localhost");
         const path = url.pathname;
@@ -2521,6 +2531,7 @@ export function createHandler(engine, options) {
                 ...(options.stations.cover ? { cover: options.stations.cover } : {}),
                 ...(options.stations.lyrics ? { lyrics: options.stations.lyrics } : {}),
                 ...(options.stations.lyricsPublisher ? { lyricsPublisher: options.stations.lyricsPublisher } : {}),
+                passes: listenPasses,
                 ...(options.stations.peers ? { peers: () => options.stations.peers.entries() } : {}),
                 ...(options.stations.rooms ? {
                     rooms: () => roomEntries(options.stations.rooms.store, options.stations.rooms.probe, watchBase(options.stations.publicBase?.() || `${scheme}://${request.headers.host ?? "localhost"}`)),
@@ -3758,6 +3769,26 @@ export function createHandler(engine, options) {
             });
             return;
         }
+        // A listen pass (listen-pass.ts): a station page on any *.nixamp.com server
+        // asks for one with this site's cookie, which is same-site there, so a
+        // signed-in listener hears no breaks. Credentialed, so never "*".
+        if (path === "/api/v1/me/pass" && request.method === "GET" && options.accounts && listenPassKey) {
+            const origin = String(request.headers.origin ?? "");
+            const cors = /^https:\/\/([a-z0-9-]+\.)*nixamp\.com(:\d+)?$/.test(origin)
+                ? { "access-control-allow-origin": origin, "access-control-allow-credentials": "true", vary: "origin" }
+                : {};
+            const who = await options.accounts.whoIs(tokenFrom(request.headers));
+            const body = who === null ? { error: "not signed in" } : mintListenPass(listenPassKey);
+            response.writeHead(who === null ? 401 : 200, { ...cors, "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+            response.end(JSON.stringify(body));
+            return;
+        }
+        // Asked by a station on another server about a pass it was handed.
+        if (path === "/api/v1/listen-pass/check" && request.method === "GET" && listenPassKey) {
+            const expires = checkListenPass(listenPassKey, url.searchParams.get(PASS_PARAM) ?? "");
+            json(response, 200, expires > 0 ? { ok: true, expires } : { ok: false });
+            return;
+        }
         if (path === "/api/v1/me/handle" && options.handles && options.accounts) {
             const handles = options.handles;
             const who = await options.accounts.whoIs(tokenFrom(request.headers));

package/dist/station-page.js

@@ -188,7 +188,8 @@ export const STATION_APP_CSP = [
     "media-src 'self' blob:",
     "worker-src 'self' blob:",
     "img-src 'self' data: blob:",
-    "connect-src 'self'",
+    // nixamp.com for a listen pass, so a signed-in listener's breaks go quiet.
+    "connect-src 'self' https://nixamp.com",
     "base-uri 'none'",
     "form-action 'none'",
     "frame-ancestors 'none'",

package/dist/station-routes.d.ts

@@ -76,6 +76,10 @@ export interface StationContext {
         status: () => unknown;
         publish: (station: Station) => Promise<PublishReport>;
     };
+    /** Whether a listen pass is good: its holder hears silence in place of a radio station's breaks. */
+    passes?: {
+        good: (pass: string) => Promise<boolean>;
+    };
     /** Auto stations: run a sync with these settings (and keep them), or read them. */
     auto?: {
         sync: (input: Record<string, unknown>) => Promise<unknown>;

package/dist/station-routes.js

@@ -1,5 +1,7 @@
 import { alertsFor } from "./station-metering.js";
 import { aiFromTags } from "./track-facts.js";
+import { quietDuringBreaks } from "./break-silence.js";
+import { PASS_PARAM } from "./listen-pass.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|now|art|lyrics)$/;
@@ -244,6 +246,10 @@ export async function handleStations(request, response, path, url, ctx) {
             response.end(JSON.stringify({ error: refused.error, code: refused.code, retryAfter: refused.retryAfter }));
             return true;
         }
+        // Signed in at nixamp.com: no breaks, starting a little behind live so
+        // they can be left out without a gap. Radio only (Channel.listenWithoutBreaks).
+        const pass = url.searchParams.get(PASS_PARAM) ?? "";
+        const spared = method === "GET" && !station.video && pass !== "" && ctx.passes ? await ctx.passes.good(pass).catch(() => false) : false;
         response.writeHead(200, { ...ctx.headers, "content-type": ctx.channels.contentType(channelId), "cache-control": "no-store" });
         if (method === "HEAD") {
             response.end();
@@ -251,7 +257,7 @@ export async function handleStations(request, response, path, url, ctx) {
         }
         // Every byte that goes out through the link is counted against the station.
         const usage = ctx.usage;
-        const counted = usage
+        const metered = usage
             ? {
                 write: (chunk) => {
                     usage.delivered(station.id, chunk.length);
@@ -261,7 +267,9 @@ export async function handleStations(request, response, path, url, ctx) {
                 pending: () => response.writableLength,
             }
             : response;
-        const detach = ctx.channels.listen(channelId, counted);
+        const detach = spared
+            ? ctx.channels.listenWithoutBreaks(channelId, metered, station.bitrate, (out) => quietDuringBreaks(out, station.bitrate, () => true))
+            : ctx.channels.listen(channelId, metered);
         if (detach === null) {
             response.end();
             return true;

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] [--breaks 600]\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 breaks ID SECONDS a spot between entries every SECONDS (120..86400; --off for none)\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 guide-host NAME [--remove]\n                     NAME's front page is the public station guide (e.g. a Moshpit name)\n  nixamp station guide-ads [--site ID] [--slot ID] [--format banner_300x250|text_link] [--off]\n                     crawlproof analytics (project ID) and an ad unit (slot ID) on the guide\n  nixamp station guide-peer URL [--remove]\n                     the guide also lists the public, listed stations of the server at URL\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  AI radio (music composed for a station, a few tracks a day):\n  nixamp station ai                          what is composing, this month's seconds, the stations\n  nixamp station ai create (--preset lofi|synthwave|ambient|chiptune|punk|jazz | --name NAME --style TEXT)\n                     [--vocals] [--seconds 120] [--per-day 2] [--unlisted]   public on the guide unless --unlisted\n  nixamp station ai generate KEY             compose one now\n  nixamp station ai set KEY [--style TEXT] [--per-day N] [--seconds N] [--off|--on]\n  nixamp station ai remove KEY [--files]\n  nixamp station ai budget SECONDS           seconds of music a month across AI stations (0: no cap)\n  nixamp station ai resume                   after the provider ran out of credit\n  nixamp station ai key NAME                 ELEVENLABS_API_KEY | GEMINI_API_KEY | OPENAI_API_KEY | ANTHROPIC_API_KEY,\n                                             NIXAMP_OPENAI_URL | NIXAMP_OPENAI_MODEL (an OpenAI-compatible stand-in), from stdin\n\n  Listener shares (anybody shares an MP3 link or file from the guide; AI files and checks it):\n  nixamp station shares                      the setting and what is waiting\n  nixamp station shares on [--owner-moderation] [--unlisted] [--max-mb 60] [--per-hour 6]\n  nixamp station shares off\n  nixamp station shares list [--state held|approved|reported|rejected]\n  nixamp station shares approve|reject|delete SHARE\n  nixamp station shares trust ADDRESS [--remove]   believe this proxy's X-Forwarded-For\n\n  Lyrics (shown on the station page from each file's own tag, else nichedb.dev; ours published back):\n  nixamp station lyrics                      the key, what was published, which stations may publish\n  nixamp station lyrics publish ID           publish a station's words now (public, listed, basis owned only)\n  nixamp station lyrics key                  nichedb's key (NIXAMP_LYRICS_KEY), from stdin (--clear forgets it)\n\n  Copyright holders (the now-playing card: who holds a track's copyright, and how to support them):\n  nixamp station holder list\n  nixamp station holder set NAME [--artist ARTIST]... [--station ID]... [--support https://...] [--label Subscribe] [--license TEXT]\n  nixamp station holder remove 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] [--breaks 600 (the default; 0 for none)]\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 breaks ID SECONDS a spot between entries every SECONDS (120..86400; --off for none)\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 guide-host NAME [--remove]\n                     NAME's front page is the public station guide (e.g. a Moshpit name)\n  nixamp station guide-ads [--site ID] [--slot ID] [--format banner_300x250|text_link] [--off]\n                     crawlproof analytics (project ID) and an ad unit (slot ID) on the guide\n  nixamp station guide-peer URL [--remove]\n                     the guide also lists the public, listed stations of the server at URL\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  AI radio (music composed for a station, a few tracks a day):\n  nixamp station ai                          what is composing, this month's seconds, the stations\n  nixamp station ai create (--preset lofi|synthwave|ambient|chiptune|punk|jazz | --name NAME --style TEXT)\n                     [--vocals] [--seconds 120] [--per-day 2] [--unlisted]   public on the guide unless --unlisted\n  nixamp station ai generate KEY             compose one now\n  nixamp station ai set KEY [--style TEXT] [--per-day N] [--seconds N] [--off|--on]\n  nixamp station ai remove KEY [--files]\n  nixamp station ai budget SECONDS           seconds of music a month across AI stations (0: no cap)\n  nixamp station ai resume                   after the provider ran out of credit\n  nixamp station ai key NAME                 ELEVENLABS_API_KEY | GEMINI_API_KEY | OPENAI_API_KEY | ANTHROPIC_API_KEY,\n                                             NIXAMP_OPENAI_URL | NIXAMP_OPENAI_MODEL (an OpenAI-compatible stand-in), from stdin\n\n  Listener shares (anybody shares an MP3 link or file from the guide; AI files and checks it):\n  nixamp station shares                      the setting and what is waiting\n  nixamp station shares on [--owner-moderation] [--unlisted] [--max-mb 60] [--per-hour 6]\n  nixamp station shares off\n  nixamp station shares list [--state held|approved|reported|rejected]\n  nixamp station shares approve|reject|delete SHARE\n  nixamp station shares trust ADDRESS [--remove]   believe this proxy's X-Forwarded-For\n\n  Lyrics (shown on the station page from each file's own tag, else nichedb.dev; ours published back):\n  nixamp station lyrics                      the key, what was published, which stations may publish\n  nixamp station lyrics publish ID           publish a station's words now (public, listed, basis owned only)\n  nixamp station lyrics key                  nichedb's key (NIXAMP_LYRICS_KEY), from stdin (--clear forgets it)\n\n  Copyright holders (the now-playing card: who holds a track's copyright, and how to support them):\n  nixamp station holder list\n  nixamp station holder set NAME [--artist ARTIST]... [--station ID]... [--support https://...] [--label Subscribe] [--license TEXT]\n  nixamp station holder remove 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.";

package/dist/station-usage.js

@@ -2,7 +2,7 @@
 export const USAGE = `nixamp station — make a collection into a station
 
   nixamp station list
-  nixamp station create --name NAME (--folder PATH | --playlist ID | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128] [--breaks 600]
+  nixamp station create --name NAME (--folder PATH | --playlist ID | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128] [--breaks 600 (the default; 0 for none)]
   nixamp station show ID
   nixamp station status ID
   nixamp station start ID

package/dist/stations.d.ts

@@ -45,6 +45,8 @@ export interface Station {
 /** Times an item may fail in a row before rotation leaves it out. */
 export declare const EXCLUDE_AFTER = 3;
 export declare const DEFAULT_BITRATE = 128;
+/** Seconds between breaks on a new station that did not say. */
+export declare const DEFAULT_BREAKS_EVERY = 600;
 export declare const BITRATES: number[];
 /** A station's channel id. */
 export declare function channelOf(id: string): string;

package/dist/stations.js

@@ -26,6 +26,8 @@ export const RIGHTS_BASES = ["owned", "permission", "licensed", "public-domain"]
 /** Times an item may fail in a row before rotation leaves it out. */
 export const EXCLUDE_AFTER = 3;
 export const DEFAULT_BITRATE = 128;
+/** Seconds between breaks on a new station that did not say. */
+export const DEFAULT_BREAKS_EVERY = 600;
 export const BITRATES = [64, 96, 128, 160, 192, 256, 320];
 const MAX_ITEMS = 20_000;
 const MAX_NAME = 120;
@@ -179,7 +181,9 @@ export class StationStore {
             listenToken: newToken(),
             bitrate: this.bitrateFrom(input.bitrate),
             video: input.video === true,
-            breaksEvery: this.breaksFrom(input.breaksEvery),
+            // On unless asked for none: a station is free to listen to, and the
+            // spot is what pays for it. Signed-in listeners hear silence instead.
+            breaksEvery: input.breaksEvery === undefined ? DEFAULT_BREAKS_EVERY : this.breaksFrom(input.breaksEvery),
             auto: "",
             rights: null,
             owner,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.45.5",
+  "version": "0.46.1",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",
@@ -51,7 +51,7 @@
     "@profullstack/notifications": "^0.1.0",
     "@profullstack/synconfig": "^0.1.2",
     "@profullstack/throttle": "0.2.2",
-    "@profullstack/x402-gateway": "^0.7.0",
+    "@profullstack/x402-gateway": "^0.10.1",
     "acme-client": "5.4.0",
     "pg": "^8.23.0"
   },
@@ -84,6 +84,6 @@
   "overrides": {
     "https-proxy-agent": "7.0.6",
     "tslib": "2.8.1",
-    "@profullstack/x402-gateway": "^0.7.0"
+    "@profullstack/x402-gateway": "^0.10.1"
   }
 }