nixamp 0.23.0 → 0.23.2

package/README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <a href="https://nixamp.com"><img src="web/public/hero.png" alt="nixamp" width="800" /></a>
+</p>
+
 # nixamp
 
 It really whips the terminal's ass.
@@ -378,8 +382,17 @@ its own audience.
 GET  /api/channels              what is live now
 POST /api/channels/<id>         publish to one
 GET  /api/channels/<id>         listen to one
+GET  /api/channels/<id>/art     a picture of it, as JPEG
 ```
 
+The picture is what a share link unfurls into on a chat or a timeline, and
+what the lock screen shows while it plays. A pasted link's thumbnail is sent
+on as it is; a podcast's sleeve is read out of the file; a moving picture
+gets one frame of what the channel is sending, taken from the channel's own
+backlog rather than by opening the source a second time. The page for a
+share link (`/?url=...&play=channel:<id>`) carries it as `og:image` with a
+Twitter card, on nixamp.com and on the server itself.
+
 One ffmpeg decodes each publisher once and the result is written to every
 listener on that channel. A decode per listener would cost a core each and, for
 a live stream, would not even agree with itself about what "now" is.

package/dist/art.d.ts

@@ -0,0 +1,41 @@
+/** As wide as a preview card is drawn; anything bigger is bytes for nothing. */
+export declare const ART_WIDTH = 960;
+/** A picture bigger than this is not a thumbnail. */
+export declare const ART_MAX_BYTES: number;
+/** How long ffmpeg gets to produce one frame before it is not going to. */
+export declare const ART_TIMEOUT_MS = 20000;
+/** How long a frame of a live picture stays the frame: it changes, but not that fast. */
+export declare const STILL_TTL_MS = 60000;
+/**
+ * The sleeve in a file: the attached picture at the head of a podcast's
+ * MP3 or M4A, read with the same input arguments the channel dials with
+ * (a site's headers, say). ffmpeg stops after the one frame, so a file of
+ * an hour costs the head of it. Null when there is none.
+ */
+export declare function coverArtOf(ffmpeg: string[], source: string, input?: string[]): Promise<Buffer | null>;
+/**
+ * One frame of what a channel is sending now, decoded from the opening
+ * boxes and the recent backlog it hands every new listener. The bytes are
+ * a fragmented MP4 that ffmpeg reads from a pipe as it would from a file.
+ * Null while the channel has no backlog yet, or for a channel of sound.
+ */
+export declare function stillFrom(ffmpeg: string[], opening: Buffer[]): Promise<Buffer | null>;
+/**
+ * The pictures already taken, so a card that is unfurled by five crawlers
+ * at once costs one ffmpeg, and a sleeve is read from the file once. A
+ * still of a live picture is kept for a minute and taken again; a sleeve
+ * is kept for as long as the channel is on.
+ */
+export declare class ArtCache {
+    private readonly now;
+    private readonly kept;
+    constructor(now?: () => number);
+    /**
+     * The picture for a key, taking it with `take` when there is none fresh
+     * enough. A picture that came back null is remembered as null for the
+     * same while, so a channel with no picture is not asked every second.
+     */
+    get(key: string, forever: boolean, take: () => Promise<Buffer | null>): Promise<Buffer | null>;
+    /** A channel went off: its pictures with it. */
+    forget(prefix: string): void;
+}

package/dist/art.js

@@ -0,0 +1,154 @@
+/**
+ * A picture of a channel, for the places a picture goes: the card a link
+ * unfurls into on a chat or a timeline, the lock screen while it plays,
+ * the row in the directory.
+ *
+ * Three places one can come from, tried in this order by whoever asks.
+ * The site's own, when a pasted link resolved to a thumbnail -- that is a
+ * URL and costs nothing. The sleeve in the file, when a podcast's MP3
+ * carries its cover as an attached picture; ffmpeg reads that one frame
+ * out of the head of the file. And for anything with a picture, a frame
+ * of the picture itself: the channel keeps the last few seconds of what
+ * it is sending, and one frame of that is a screenshot of what is on --
+ * taken from our own output, never by opening the source a second time,
+ * because a panel that allows one connection per film counts that one
+ * against the channel and drops it.
+ *
+ * Every picture comes back as a JPEG no wider than a card wants.
+ */
+import { spawn } from "node:child_process";
+/** As wide as a preview card is drawn; anything bigger is bytes for nothing. */
+export const ART_WIDTH = 960;
+/** A picture bigger than this is not a thumbnail. */
+export const ART_MAX_BYTES = 2 * 1024 * 1024;
+/** How long ffmpeg gets to produce one frame before it is not going to. */
+export const ART_TIMEOUT_MS = 20_000;
+/** How long a frame of a live picture stays the frame: it changes, but not that fast. */
+export const STILL_TTL_MS = 60_000;
+/** The ffmpeg arguments that turn whatever is on `-i` into one JPEG on stdout. */
+function oneFrame(input, scale = true) {
+    return [
+        "-hide_banner", "-loglevel", "error", "-nostdin",
+        ...input,
+        "-map", "0:v:0",
+        "-frames:v", "1",
+        // No wider than the card, never upscaled, and an even height so the
+        // encoder does not refuse an odd one.
+        ...(scale ? ["-vf", `scale='min(${ART_WIDTH},iw)':-2`] : []),
+        "-c:v", "mjpeg", "-q:v", "4",
+        "-f", "image2", "pipe:1",
+    ];
+}
+/**
+ * Run ffmpeg for one picture: feed it `stdin` when there is something to
+ * feed, read stdout until it ends, and answer the JPEG or null. Never
+ * throws: a source with no picture, a decoder that cannot start, a frame
+ * that takes too long, all answer null and the caller shows nothing.
+ */
+function picture(ffmpeg, args, stdin) {
+    const [command, ...prefix] = ffmpeg;
+    if (!command)
+        return Promise.resolve(null);
+    return new Promise((done) => {
+        const chunks = [];
+        let size = 0;
+        let settled = false;
+        const finish = (answer) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            done(answer);
+        };
+        let child;
+        try {
+            child = spawn(command, [...prefix, ...args], { stdio: [stdin ? "pipe" : "ignore", "pipe", "ignore"] });
+        }
+        catch {
+            finish(null);
+            return;
+        }
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            finish(null);
+        }, ART_TIMEOUT_MS);
+        child.on("error", () => finish(null));
+        child.stdout?.on("data", (chunk) => {
+            size += chunk.byteLength;
+            if (size <= ART_MAX_BYTES)
+                chunks.push(chunk);
+        });
+        child.on("close", () => {
+            const bytes = Buffer.concat(chunks);
+            // A JPEG starts FF D8; anything else is ffmpeg having written nothing.
+            finish(size > 0 && size <= ART_MAX_BYTES && bytes[0] === 0xff && bytes[1] === 0xd8 ? bytes : null);
+        });
+        if (stdin && child.stdin) {
+            const input = child.stdin;
+            input.on("error", () => { });
+            for (const piece of stdin)
+                input.write(piece);
+            input.end();
+        }
+    });
+}
+/**
+ * The sleeve in a file: the attached picture at the head of a podcast's
+ * MP3 or M4A, read with the same input arguments the channel dials with
+ * (a site's headers, say). ffmpeg stops after the one frame, so a file of
+ * an hour costs the head of it. Null when there is none.
+ */
+export function coverArtOf(ffmpeg, source, input = []) {
+    return picture(ffmpeg, oneFrame([...input, "-i", source]), null);
+}
+/**
+ * One frame of what a channel is sending now, decoded from the opening
+ * boxes and the recent backlog it hands every new listener. The bytes are
+ * a fragmented MP4 that ffmpeg reads from a pipe as it would from a file.
+ * Null while the channel has no backlog yet, or for a channel of sound.
+ */
+export function stillFrom(ffmpeg, opening) {
+    if (opening.length === 0 || opening.every((piece) => piece.byteLength === 0))
+        return Promise.resolve(null);
+    return picture(ffmpeg, oneFrame(["-f", "mp4", "-i", "pipe:0"]), opening);
+}
+/**
+ * The pictures already taken, so a card that is unfurled by five crawlers
+ * at once costs one ffmpeg, and a sleeve is read from the file once. A
+ * still of a live picture is kept for a minute and taken again; a sleeve
+ * is kept for as long as the channel is on.
+ */
+export class ArtCache {
+    now;
+    kept = new Map();
+    constructor(now = () => Date.now()) {
+        this.now = now;
+    }
+    /**
+     * The picture for a key, taking it with `take` when there is none fresh
+     * enough. A picture that came back null is remembered as null for the
+     * same while, so a channel with no picture is not asked every second.
+     */
+    async get(key, forever, take) {
+        const have = this.kept.get(key);
+        if (have) {
+            if (have.pending)
+                return have.pending;
+            if (have.forever || this.now() - have.at < STILL_TTL_MS)
+                return have.bytes;
+        }
+        const pending = take().then((bytes) => {
+            this.kept.set(key, { at: this.now(), forever: forever && bytes !== null, bytes });
+            return bytes;
+        });
+        this.kept.set(key, { at: this.now(), forever: false, bytes: null, pending });
+        return pending;
+    }
+    /** A channel went off: its pictures with it. */
+    forget(prefix) {
+        for (const key of this.kept.keys()) {
+            if (key === prefix || key.startsWith(`${prefix}:`))
+                this.kept.delete(key);
+        }
+    }
+}

package/dist/audio.d.ts

@@ -117,6 +117,18 @@ export interface Codecs {
      */
     width?: number;
     height?: number;
+    /**
+     * Whether a sleeve is embedded: the attached picture an MP3 or M4A of a
+     * podcast carries. Not a picture to play, but a picture to show -- on
+     * the link preview and the lock screen -- and `coverArtOf` reads it out.
+     */
+    cover?: boolean;
+    /** What the file says about itself in its tags, for naming a bare file. */
+    tags?: {
+        title?: string;
+        artist?: string;
+        album?: string;
+    };
 }
 /**
  * Ask ffprobe what the streams are, without holding the event loop.
@@ -126,6 +138,12 @@ export interface Codecs {
  * the whole library came to be tagged with the process wedged solid.
  */
 export declare function codecsOf(tools: Tools, path: string, input?: string[]): Promise<Codecs>;
+/**
+ * The title, artist and album a file carries in its tags, however the
+ * container spells the keys (ID3 says TIT2 but ffprobe says title; MP4 and
+ * Matroska say Title). Absent when it carries none worth keeping.
+ */
+export declare function tagsOf(raw: Record<string, unknown> | undefined): Codecs["tags"] | undefined;
 export declare function isCoverArt(stream: {
     codec_name?: string;
     disposition?: {

package/dist/audio.js

@@ -369,7 +369,7 @@ export async function codecsOf(tools, path, input = []) {
             // The disposition too: an MP3 with its cover art in it carries that
             // art as a video stream of one JPEG, and a probe that took it for a
             // picture put a podcast on the air as a film with no frames.
-            "-show_entries", "format=format_name,duration:stream=codec_type,codec_name,width,height:stream_disposition=attached_pic",
+            "-show_entries", "format=format_name,duration:format_tags=title,artist,album:stream=codec_type,codec_name,width,height:stream_disposition=attached_pic",
             // A transport stream needs looking further into than a file with an
             // index does: there is no header listing the tracks, only packets, and
             // a 4K recording can carry a second of null padding and a long gap to
@@ -390,6 +390,8 @@ export async function codecsOf(tools, path, input = []) {
             try {
                 const parsed = JSON.parse(out);
                 const streams = parsed.streams ?? [];
+                const cover = streams.some((s) => s.codec_type === "video" && s.disposition?.attached_pic === 1);
+                const tags = tagsOf(parsed.format?.tags);
                 // ffprobe prints seconds as a string, and "N/A" for a stream with no
                 // end; both of those read as 0.
                 const seconds = Number(parsed.format?.duration ?? 0);
@@ -401,6 +403,8 @@ export async function codecsOf(tools, path, input = []) {
                     duration: Number.isFinite(seconds) && seconds > 0 ? seconds : 0,
                     ...(typeof picture?.width === "number" && picture.width > 0 ? { width: picture.width } : {}),
                     ...(typeof picture?.height === "number" && picture.height > 0 ? { height: picture.height } : {}),
+                    ...(cover ? { cover } : {}),
+                    ...(tags ? { tags } : {}),
                 });
             }
             catch {
@@ -409,6 +413,28 @@ export async function codecsOf(tools, path, input = []) {
         });
     });
 }
+/**
+ * The title, artist and album a file carries in its tags, however the
+ * container spells the keys (ID3 says TIT2 but ffprobe says title; MP4 and
+ * Matroska say Title). Absent when it carries none worth keeping.
+ */
+export function tagsOf(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const lower = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === "string")
+            lower[key.toLowerCase()] = value.replace(/[\u0000-\u001F\u007F]+/g, " ").trim().slice(0, 200);
+    }
+    const tags = {};
+    if (lower["title"])
+        tags.title = lower["title"];
+    if (lower["artist"])
+        tags.artist = lower["artist"];
+    if (lower["album"])
+        tags.album = lower["album"];
+    return Object.keys(tags).length > 0 ? tags : undefined;
+}
 /**
  * Cover art is not a picture.
  *

package/dist/channels.d.ts

@@ -56,6 +56,7 @@ export interface ChannelInfo {
         duration?: number;
         width?: number;
         height?: number;
+        cover?: boolean;
     };
     /**
      * What the channel itself is producing, which is not always what its source
@@ -79,6 +80,15 @@ export interface ChannelInfo {
      * plain URL is read this way, and only when a policy asks for it.
      */
     teed?: boolean;
+    /**
+     * A picture of it from somewhere else: the thumbnail the site offered
+     * for a pasted link, the logo a catalog gave a channel. A channel with
+     * none may still have one of its own -- a sleeve in the file, a frame of
+     * the picture -- which /api/channels/:id/art reads out on demand.
+     */
+    art?: string;
+    /** A line about it for a preview: the show, the uploader, the first line of the notes. */
+    about?: string;
 }
 /** Where a pulled source is picked up from, and whether it can be at all. */
 export interface PullResume {
@@ -483,6 +493,7 @@ export interface RememberedChannel {
         duration?: number;
         width?: number;
         height?: number;
+        cover?: boolean;
     };
     /** Where a film had got to, in seconds, so it picks up there. */
     position?: number;
@@ -493,6 +504,9 @@ export interface RememberedChannel {
     /** For a list: every entry, and which was on, so it carries on from there. */
     playlist?: string[];
     playlistAt?: number;
+    /** Its picture and its line, as the site gave them, so a restart need not ask. */
+    art?: string;
+    about?: string;
 }
 export declare function rememberedChannels(dir: string, port: number): RememberedChannel[];
 /**

package/dist/channels.js

@@ -1053,6 +1053,10 @@ export function rememberedChannels(dir, port) {
                         kept.codecs.width = c["width"];
                     if (typeof c["height"] === "number" && Number.isFinite(c["height"]))
                         kept.codecs.height = c["height"];
+                    // A sleeve in the file is a picture for the card, and knowing it
+                    // is there saves reading the file again to find out.
+                    if (c["cover"] === true)
+                        kept.codecs.cover = true;
                 }
             }
             if (typeof one["position"] === "number" && Number.isFinite(one["position"]) && one["position"] > 0)
@@ -1068,6 +1072,10 @@ export function rememberedChannels(dir, port) {
                 if (typeof one["playlistAt"] === "number" && Number.isInteger(one["playlistAt"]) && one["playlistAt"] >= 0)
                     kept.playlistAt = one["playlistAt"];
             }
+            if (typeof one["art"] === "string" && /^https?:\/\//i.test(one["art"]))
+                kept.art = one["art"].slice(0, 2048);
+            if (typeof one["about"] === "string" && one["about"] !== "")
+                kept.about = one["about"].slice(0, 200);
             return kept;
         });
     }
@@ -1100,6 +1108,10 @@ export function rememberedNow(channels) {
             kept.playlist = one.playlist;
             kept.playlistAt = one.playlistAt ?? 0;
         }
+        if (one.art)
+            kept.art = one.art;
+        if (one.about)
+            kept.about = one.about;
         return kept;
     });
 }

package/dist/directory.d.ts

@@ -75,6 +75,12 @@ export interface Listing {
      * about another on the same server.
      */
     channelCodes: Record<string, string>;
+    /**
+     * The same channels with what a preview needs: the id a join link names
+     * them by, a picture, a line. `channels` stays the list of names for
+     * the phone line and for anything reading an older listing.
+     */
+    lineup: LineupEntry[];
     /** Set by the directory from the request, never by the publisher. */
     updatedAt: number;
     /** When this stream first announced itself: the "started at" a caller hears. */
@@ -124,6 +130,20 @@ export interface Announcement {
     playing?: boolean;
     /** Names of the live channels on it. Absent from an older publisher. */
     channels?: string[];
+    /** Each of those with its id, picture and line. Absent from an older publisher. */
+    lineup?: LineupEntry[];
+}
+/**
+ * One live channel as a preview sees it. The picture is a web address the
+ * publisher vouches for -- its own art route, or the thumbnail a site gave
+ * it -- and a crawler fetches it, so it is only ever http(s).
+ */
+export interface LineupEntry {
+    id: string;
+    name: string;
+    kind: "audio" | "video";
+    art: string;
+    about: string;
 }
 /** Trim and flatten, so one publisher cannot draw a box in someone's terminal. */
 export declare function clean(value: unknown, max: number): string;
@@ -135,6 +155,8 @@ export declare function clean(value: unknown, max: number): string;
  */
 export declare function publishable(raw: string): URL | null;
 export declare function parseAnnouncement(input: unknown): Announcement | null;
+/** One lineup entry as a publisher sent it, cleaned, or null when it is not one. */
+export declare function parseLineupEntry(input: unknown): LineupEntry | null;
 /**
  * The registry. In memory on purpose: see the note at the top of the file.
  * One entry per URL, so a publisher restarting does not leave a ghost of

package/dist/directory.js

@@ -19,6 +19,9 @@ export const DEFAULT_DIRECTORY = "https://nixamp.com";
 /** How long an ended stream is still worth telling a caller about. */
 export const ENDED_TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_NAME = 60;
+const MAX_ID = 64;
+const MAX_ABOUT = 200;
+const MAX_ART = 2048;
 const MAX_TRACK = 120;
 /** How many channel names a listing carries. A multiview is four; eight is plenty. */
 const MAX_CHANNELS = 8;
@@ -91,6 +94,29 @@ export function parseAnnouncement(input) {
                     .slice(0, MAX_CHANNELS),
             }
             : {}),
+        ...(Array.isArray(record["lineup"])
+            ? { lineup: record["lineup"].map(parseLineupEntry).filter((one) => one !== null).slice(0, MAX_CHANNELS) }
+            : {}),
+    };
+}
+/** One lineup entry as a publisher sent it, cleaned, or null when it is not one. */
+export function parseLineupEntry(input) {
+    if (typeof input !== "object" || input === null)
+        return null;
+    const record = input;
+    const id = clean(record["id"], MAX_ID);
+    const name = clean(record["name"], MAX_NAME);
+    if (id === "" || name === "")
+        return null;
+    const art = clean(record["art"], MAX_ART);
+    return {
+        id,
+        name,
+        kind: record["kind"] === "video" ? "video" : "audio",
+        // A picture is somewhere a crawler can go, or nothing: a data: URL is a
+        // page in a tag, and javascript: is a page in a tag that runs.
+        art: publishable(art) !== null ? art : "",
+        about: clean(record["about"], MAX_ABOUT),
     };
 }
 /**
@@ -187,6 +213,7 @@ export class Directory {
             // listing always meant, and no channels is the honest empty list.
             playing: announcement.playing ?? true,
             channels: announcement.channels ?? [],
+            lineup: announcement.lineup ?? [],
             channelCodes: this.codesFor(announcement.channels ?? [], 
             // What each channel has been called before, on this listing: a
             // channel that was gone for a heartbeat -- a server restarting puts

package/dist/links.d.ts

@@ -26,6 +26,17 @@ export interface ResolvedLink {
     ext: string;
     /** The page it came from. */
     page: string;
+    /**
+     * A picture of it, when the site offered one: the video's thumbnail, the
+     * podcast's cover. This is what a link preview shows, and the lock screen
+     * while it plays. "" when there is none.
+     */
+    thumbnail: string;
+    /**
+     * A line about it for a preview: who put it up, and the first line of
+     * what they said about it. "" when the site said nothing.
+     */
+    about: string;
     /**
      * For a pasted .m3u: every entry in it, in order. The channel plays them
      * one after another and starts over at the end, a station rather than a
@@ -81,6 +92,12 @@ export declare function resolveArgs(url: string, cookies?: string, format?: stri
 export declare function downloadArgs(url: string, audioOnly: boolean, cookies?: string): string[];
 /** yt-dlp's answer, read into what the player needs. Null when it is not an answer. */
 export declare function parseResolved(json: unknown, page: string): ResolvedLink | null;
+/** A web address a preview can fetch, or "". Only http(s): a data: URL is a page in a tag. */
+export declare function pictureUrl(value: unknown): string;
+/** How much of a description a preview gets. A card is a line or two, not the notes. */
+export declare const ABOUT_MAX = 200;
+/** One line of plain text, no longer than a card wants. */
+export declare function oneLine(text: string): string;
 /** A bare file link, described without asking anybody. */
 export declare function directLink(url: string): ResolvedLink;
 /**

package/dist/links.js

@@ -147,6 +147,8 @@ export async function resolvePlaylist(url, options = {}) {
         extractor: "playlist",
         ext: "",
         page: url,
+        thumbnail: "",
+        about: "",
         playlist: list.sources,
     };
 }
@@ -278,8 +280,56 @@ export function parseResolved(json, page) {
         extractor: typeof record["extractor"] === "string" ? record["extractor"] : "",
         ext: typeof record["ext"] === "string" && /^[a-z0-9]{1,5}$/i.test(record["ext"]) ? record["ext"].toLowerCase() : "",
         page,
+        thumbnail: thumbnailOf(record),
+        about: aboutOf(record),
     };
 }
+/** A web address a preview can fetch, or "". Only http(s): a data: URL is a page in a tag. */
+export function pictureUrl(value) {
+    if (typeof value !== "string" || value.length > 2048)
+        return "";
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === "https:" || parsed.protocol === "http:" ? parsed.toString() : "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * The picture yt-dlp found: `thumbnail` is its pick, and failing that the
+ * last of `thumbnails`, which it lists smallest first.
+ */
+function thumbnailOf(record) {
+    const chosen = pictureUrl(record["thumbnail"]);
+    if (chosen !== "")
+        return chosen;
+    const list = Array.isArray(record["thumbnails"]) ? record["thumbnails"] : [];
+    for (let index = list.length - 1; index >= 0; index -= 1) {
+        const one = list[index];
+        const url = one && typeof one === "object" ? pictureUrl(one["url"]) : "";
+        if (url !== "")
+            return url;
+    }
+    return "";
+}
+/** How much of a description a preview gets. A card is a line or two, not the notes. */
+export const ABOUT_MAX = 200;
+/** Who put it up, and the first line they wrote about it, as one line. */
+function aboutOf(record) {
+    const who = ["uploader", "channel", "artist", "album"]
+        .map((field) => (typeof record[field] === "string" ? record[field].trim() : ""))
+        .find((one) => one !== "") ?? "";
+    const said = typeof record["description"] === "string"
+        ? record["description"].split(/\r?\n/).map((line) => line.trim()).find((line) => line !== "") ?? ""
+        : "";
+    return oneLine([who, said].filter((one) => one !== "").join(" — "));
+}
+/** One line of plain text, no longer than a card wants. */
+export function oneLine(text) {
+    const flat = text.replace(/[\u0000-\u001F\u007F]+/g, " ").replace(/\s+/g, " ").trim();
+    return flat.length > ABOUT_MAX ? `${flat.slice(0, ABOUT_MAX - 1).trimEnd()}…` : flat;
+}
 /** A bare file link, described without asking anybody. */
 export function directLink(url) {
     return {
@@ -294,6 +344,8 @@ export function directLink(url) {
         extractor: "direct",
         ext: (url.match(/\.([a-z0-9]{2,5})(\?.*)?$/i)?.[1] ?? "").toLowerCase(),
         page: url,
+        thumbnail: "",
+        about: "",
     };
 }
 function fileNameOf(url) {

package/dist/publish.d.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_DIRECTORY, type Listing } from "./directory.ts";
+import { DEFAULT_DIRECTORY, type LineupEntry, type Listing } from "./directory.ts";
 export interface PublishTarget {
     directory: string;
     name: string;
@@ -27,6 +27,8 @@ export interface PublishTarget {
     playing?: () => boolean;
     /** The live channels on this server, by name, for the listing to show. */
     channels?: () => string[];
+    /** The same channels with their id, picture and line, for a link preview. */
+    lineup?: () => LineupEntry[];
     /**
      * The account this stream belongs to, from `nixamp login`.
      *

package/dist/publish.js

@@ -65,6 +65,7 @@ export class Publisher {
                     nowPlaying: this.target.nowPlaying(),
                     ...(this.target.playing ? { playing: this.target.playing() } : {}),
                     ...(this.target.channels ? { channels: this.target.channels() } : {}),
+                    ...(this.target.lineup ? { lineup: this.target.lineup() } : {}),
                 }),
             });
             if (!response.ok) {