nixamp 0.28.45 → 0.30.1

package/dist/audio.js

@@ -6,6 +6,7 @@
  * same bytes to the output process. Running two decoders instead would drift
  * apart within seconds and the bars would stop matching what you hear.
  */
+import { protocolArgs } from "./decoder-policy.js";
 import { spawn, spawnSync } from "node:child_process";
 import { readdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -109,6 +110,7 @@ export function probe(tools, path) {
         ...rest,
         "-v", "quiet", "-print_format", "json",
         "-show_format", "-show_entries", "format_tags=title,artist,album",
+        ...protocolArgs(path),
         path,
     ], { encoding: "utf8", timeout: 20_000, maxBuffer: 4 * 1024 * 1024 });
     if (result.error || result.status !== 0)
@@ -190,6 +192,7 @@ export class Stream {
             // being on disk. Measured with that condition in place: still 13.8x.
             "-re",
             ...(from > 0 ? ["-ss", String(from)] : []),
+            ...protocolArgs(track.path),
             "-i", track.path,
             "-f", "f32le", "-ac", String(CHANNELS), "-ar", String(RATE), "-",
         ], { stdio: ["ignore", "pipe", "pipe"] });

package/dist/channels.d.ts

@@ -1,3 +1,4 @@
+import { type PlaylistInput } from "./playlist-input.ts";
 import type { Readable } from "node:stream";
 /** Somewhere for a channel's audio to go. A response, in practice. */
 export interface Listener {
@@ -105,6 +106,13 @@ export interface PullResume {
     /** For a list of things rather than one: every entry, in order. */
     playlist?: string[];
     playlistAt?: number;
+    /**
+     * How a station plays its list: round and round, in a shuffled order, with
+     * edits landing on the next track and broken entries passed over. Only for
+     * 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">;
 }
 /**
  * A source read by us rather than by ffmpeg: what to tell ffmpeg it is,
@@ -220,6 +228,10 @@ export declare class Channel {
     private redial;
     /** For a channel playing a list: move to the next entry. Null when there is no list. */
     private advance;
+    /** The list being played entry by entry, when it is one; what skip() moves on. */
+    private playlistInput;
+    /** On to the next entry of a list of files. False when this is not one. */
+    skip(): boolean;
     private failures;
     private timer;
     /** Fires when a pulled source has said nothing for STALL. */
@@ -485,6 +497,8 @@ export declare class Channels {
     setThrough(provider: ThroughProvider | null): void;
     /** The kind of a channel, for a relay to say what it is carrying. */
     kindOf(id: string): "audio" | "video" | undefined;
+    /** The next entry, now, on a channel playing a list of files. */
+    skip(id: string): boolean;
     stop(id: string): boolean;
     stopAll(): void;
 }

package/dist/channels.js

@@ -14,6 +14,7 @@
  * what live means. MP3 frames are self-describing, so a player finds the next
  * frame boundary and carries on; there is nothing to catch up on.
  */
+import { protocolArgs } from "./decoder-policy.js";
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -134,6 +135,12 @@ export class Channel {
     redial = null;
     /** For a channel playing a list: move to the next entry. Null when there is no list. */
     advance = null;
+    /** The list being played entry by entry, when it is one; what skip() moves on. */
+    playlistInput = null;
+    /** On to the next entry of a list of files. False when this is not one. */
+    skip() {
+        return this.playlistInput?.skip() ?? false;
+    }
     failures = 0;
     timer = null;
     /** Fires when a pulled source has said nothing for STALL. */
@@ -236,7 +243,7 @@ export class Channel {
         // A list plays entry by entry: the one that is on is what gets dialled,
         // and an entry that ended is followed by the next, at once.
         const list = resume.playlist && resume.playlist.length > 0 ? resume.playlist : null;
-        const localPlaylist = list && list.length > 1 && list.every(one => !/^https?:\/\//i.test(one)) ? list : null;
+        const localPlaylist = list && (list.length > 1 || resume.rotation) && list.every(one => !/^https?:\/\//i.test(one)) ? list : null;
         let at = 0;
         if (list) {
             this.info.playlist = list;
@@ -287,7 +294,9 @@ export class Channel {
                 ffprobe: this.options.ffprobe ?? this.options.ffmpeg.map(one => one.replace(/ffmpeg(?=(?:\.exe)?$)/, "ffprobe")),
                 files: localPlaylist, at: this.info.playlistAt ?? 0, position: from,
                 video: this.info.kind === "video", width: this.info.codecs?.width, height: this.info.codecs?.height,
+                ...resume.rotation,
             }) : null;
+            this.playlistInput = playlistInput;
             const through = this.outroOn ? null : playlistInput
                 ? { format: "mpegts", open: async (signal) => playlistInput.open(signal) }
                 : this.options.through?.(this.info, from, input, audio) ?? null;
@@ -338,10 +347,10 @@ export class Channel {
                         // What the source's site expects on the request: a user agent, a
                         // referer, a cookie. A link resolved by yt-dlp comes with these,
                         // and a CDN that got them from yt-dlp and not from us answers 403.
-                        ...input, ...seek, "-i", current,
+                        ...input, ...seek, ...protocolArgs(current), "-i", current,
                         // The sound, when the site keeps it apart from the picture: a
                         // second input, dialled the same way, that the encode maps in.
-                        ...(audio ? [...remoteArgs, ...(paced ? ["-re"] : []), ...input, ...seek, "-i", audio] : []),
+                        ...(audio ? [...remoteArgs, ...(paced ? ["-re"] : []), ...input, ...seek, ...protocolArgs(audio), "-i", audio] : []),
                     ]),
                 ...(playlistEncode ?? encode),
                 "pipe:1",
@@ -1159,6 +1168,10 @@ export class Channels {
     kindOf(id) {
         return this.open.get(id)?.info.kind;
     }
+    /** The next entry, now, on a channel playing a list of files. */
+    skip(id) {
+        return this.open.get(id)?.skip() ?? false;
+    }
     stop(id) {
         const channel = this.open.get(id);
         if (!channel)
@@ -1239,7 +1252,10 @@ export function rememberedChannels(dir, port) {
  */
 export function rememberedNow(channels) {
     return channels.list()
-        .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id))
+        // A station's channel is put back by its station, which knows whether it
+        // is still wanted; remembering it here too would bring back one its
+        // owner had stopped.
+        .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id) && !one.id.startsWith("station-"))
         .map((one) => {
         const kept = { id: one.id, name: one.name, source: one.source };
         if (one.kind)

package/dist/decoder-policy.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What a decoder may open while reading one source.
+ *
+ * ffmpeg follows references inside what it reads: an .m3u8 names segments, a
+ * concat list names files, a playlist on disk can name a URL. A file in
+ * somebody's library is untrusted input, and without a list of protocols it
+ * can make this machine fetch any address it likes, on the LAN included. So
+ * a file on disk may open files and pipes and nothing else, and a link may
+ * open the network protocols a stream needs and not the local file system.
+ *
+ * Sources this does not recognise (an ingest URL, a lavfi graph) are left
+ * alone rather than broken: the list is for what comes out of a library or a
+ * pasted link, which is where untrusted references come from.
+ */
+/** A file in a library: itself, and the pipes the pipeline is built from. */
+export declare const LOCAL_PROTOCOLS = "file,pipe,fd";
+/** A link: the network, as streams use it, and never `file`. */
+export declare const REMOTE_PROTOCOLS: string;
+/** The `-protocol_whitelist` to put before this source's `-i`, or nothing. */
+export declare function protocolArgs(source: string): string[];

package/dist/decoder-policy.js

@@ -0,0 +1,34 @@
+/**
+ * What a decoder may open while reading one source.
+ *
+ * ffmpeg follows references inside what it reads: an .m3u8 names segments, a
+ * concat list names files, a playlist on disk can name a URL. A file in
+ * somebody's library is untrusted input, and without a list of protocols it
+ * can make this machine fetch any address it likes, on the LAN included. So
+ * a file on disk may open files and pipes and nothing else, and a link may
+ * open the network protocols a stream needs and not the local file system.
+ *
+ * Sources this does not recognise (an ingest URL, a lavfi graph) are left
+ * alone rather than broken: the list is for what comes out of a library or a
+ * pasted link, which is where untrusted references come from.
+ */
+/** A file in a library: itself, and the pipes the pipeline is built from. */
+export const LOCAL_PROTOCOLS = "file,pipe,fd";
+/** A link: the network, as streams use it, and never `file`. */
+export const REMOTE_PROTOCOLS = [
+    "http", "https", "tcp", "tls", "crypto", "data", "httpproxy",
+    "rtmp", "rtmps", "rtmpt", "rtmpts", "rtmpe", "rtmpte", "ffrtmpcrypt", "ffrtmphttp",
+].join(",");
+/** The `-protocol_whitelist` to put before this source's `-i`, or nothing. */
+export function protocolArgs(source) {
+    if (source === "-" || source.startsWith("pipe:"))
+        return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+    if (/^(https?|rtmp[a-z]*):\/\//i.test(source))
+        return ["-protocol_whitelist", REMOTE_PROTOCOLS];
+    if (/^file:/i.test(source))
+        return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+    // Any other scheme (two letters or more, so `C:\` is still a path).
+    if (/^[a-z][a-z0-9+.-]+:/i.test(source))
+        return [];
+    return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+}

package/dist/destinations.d.ts

@@ -0,0 +1,5 @@
+export type Lookup = (host: string) => Promise<string[]>;
+/** Not somewhere on the public internet: loopback, private, link-local, reserved. */
+export declare function isPrivateAddress(address: string): boolean;
+/** "" when this link may be fetched for a member, else why not. */
+export declare function refusedDestination(link: string, lookup?: Lookup): Promise<string>;

package/dist/destinations.js

@@ -0,0 +1,82 @@
+/**
+ * Whether a link somebody else pasted may be fetched from this machine.
+ *
+ * A member -- any nixamp.com account -- may put a link on the air on a server
+ * that is not theirs. Fetching it is a request from inside the owner's
+ * network, so a link to the router, the cloud metadata address or a service
+ * on localhost would be the member reaching things only the owner can. The
+ * owner may fetch what they like: it is their network. A member's link has to
+ * resolve to a public address, every address it resolves to, at every hop
+ * this code follows.
+ *
+ * What it cannot see: a redirect yt-dlp or ffmpeg follows on its own, and a
+ * name that resolves differently a second later. The decoder's protocol list
+ * (decoder-policy.ts) keeps those off the file system; keeping them off the
+ * LAN entirely needs the fetch to happen here, which is later work.
+ */
+import { lookup as dnsLookup } from "node:dns/promises";
+import { isIP } from "node:net";
+const defaultLookup = async (host) => (await dnsLookup(host, { all: true, verbatim: true })).map((one) => one.address);
+function v4Number(address) {
+    return address.split(".").reduce((sum, part) => sum * 256 + Number(part), 0);
+}
+function inV4(address, base, bits) {
+    const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+    return ((v4Number(address) & mask) >>> 0) === ((v4Number(base) & mask) >>> 0);
+}
+const PRIVATE_V4 = [
+    ["0.0.0.0", 8], ["10.0.0.0", 8], ["100.64.0.0", 10], ["127.0.0.0", 8],
+    ["169.254.0.0", 16], ["172.16.0.0", 12], ["192.0.0.0", 24], ["192.0.2.0", 24],
+    ["192.168.0.0", 16], ["198.18.0.0", 15], ["198.51.100.0", 24], ["203.0.113.0", 24],
+    ["224.0.0.0", 4], ["240.0.0.0", 4],
+];
+/** Not somewhere on the public internet: loopback, private, link-local, reserved. */
+export function isPrivateAddress(address) {
+    const kind = isIP(address);
+    if (kind === 4)
+        return PRIVATE_V4.some(([base, bits]) => inV4(address, base, bits));
+    if (kind !== 6)
+        return true;
+    const lower = address.toLowerCase();
+    const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+    if (mapped)
+        return isPrivateAddress(mapped[1]);
+    if (lower === "::" || lower === "::1")
+        return true;
+    const first = parseInt(lower.split(":")[0] || "0", 16);
+    // fc00::/7 unique local, fe80::/10 link-local, ff00::/8 multicast.
+    if ((first & 0xfe00) === 0xfc00)
+        return true;
+    if ((first & 0xffc0) === 0xfe80)
+        return true;
+    if ((first & 0xff00) === 0xff00)
+        return true;
+    return false;
+}
+/** "" when this link may be fetched for a member, else why not. */
+export async function refusedDestination(link, lookup = defaultLookup) {
+    let url;
+    try {
+        url = new URL(link);
+    }
+    catch {
+        return "that is not a link";
+    }
+    if (!/^(https?|rtmps?):$/i.test(url.protocol))
+        return "only http, https and rtmp links can be played here";
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    if (host === "" || /^localhost$/i.test(host) || /\.localhost$/i.test(host))
+        return "that link points at this machine";
+    let addresses;
+    try {
+        addresses = isIP(host) ? [host] : await lookup(host);
+    }
+    catch {
+        return "that link's host does not resolve";
+    }
+    if (addresses.length === 0)
+        return "that link's host does not resolve";
+    if (addresses.some(isPrivateAddress))
+        return "that link points inside a private network, which only this server's owner may play";
+    return "";
+}

package/dist/directory.d.ts

@@ -146,6 +146,8 @@ export interface LineupEntry {
     kind: "audio" | "video";
     art: string;
     about: string;
+    /** A station's own listening page, on the same server; only for a station its owner listed. */
+    listen?: string;
 }
 /** Trim and flatten, so one publisher cannot draw a box in someone's terminal. */
 export declare function clean(value: unknown, max: number): string;
@@ -158,7 +160,7 @@ 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;
+export declare function parseLineupEntry(input: unknown, origin?: string): 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

@@ -95,12 +95,12 @@ export function parseAnnouncement(input) {
             }
             : {}),
         ...(Array.isArray(record["lineup"])
-            ? { lineup: record["lineup"].map(parseLineupEntry).filter((one) => one !== null).slice(0, MAX_CHANNELS) }
+            ? { lineup: record["lineup"].map((one) => parseLineupEntry(one, listen.origin)).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) {
+export function parseLineupEntry(input, origin = "") {
     if (typeof input !== "object" || input === null)
         return null;
     const record = input;
@@ -120,6 +120,12 @@ export function parseLineupEntry(input) {
         // 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),
+        // The same server as the listing, or nothing, like the audio address.
+        ...(() => {
+            const offered = typeof record["listen"] === "string" ? record["listen"].slice(0, MAX_ART) : "";
+            const parsed = offered && origin ? publishable(offered) : null;
+            return parsed !== null && parsed.origin === origin ? { listen: offered } : {};
+        })(),
     };
 }
 /**

package/dist/library.d.ts

@@ -1,6 +1,8 @@
 export interface Config {
     /** The folder the daemon serves when it is not told which. */
     library?: string;
+    /** Whether this machine is listed in the public directory; unset until chosen. */
+    publish?: boolean;
 }
 export declare function configPath(): string;
 export declare function readConfig(): Config;

package/dist/library.js

@@ -28,7 +28,10 @@ export function readConfig() {
         if (typeof parsed !== "object" || parsed === null)
             return {};
         const record = parsed;
-        return { ...(typeof record["library"] === "string" ? { library: record["library"] } : {}) };
+        return {
+            ...(typeof record["library"] === "string" ? { library: record["library"] } : {}),
+            ...(typeof record["publish"] === "boolean" ? { publish: record["publish"] } : {}),
+        };
     }
     catch {
         return {};

package/dist/links.d.ts

@@ -70,6 +70,8 @@ export declare function playlistFrom(text: string, base: string): {
     sources: string[];
     image: string;
 };
+/** Asked of every address before it is fetched: "" to go ahead, else why not. */
+export type Guard = (url: string) => Promise<string>;
 /**
  * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
  * here rather than by yt-dlp, which would take the first entry and stop, or
@@ -78,6 +80,7 @@ export declare function playlistFrom(text: string, base: string): {
 export declare function resolvePlaylist(url: string, options?: {
     timeoutMs?: number;
     fetcher?: typeof fetch;
+    guard?: Guard;
 }): Promise<ResolvedLink | {
     error: string;
 }>;
@@ -133,6 +136,7 @@ export declare function resolveLink(ytdlp: string[] | null, url: string, options
     cookies?: string;
     timeoutMs?: number;
     format?: string;
+    guard?: Guard;
 }): Promise<ResolvedLink | {
     error: string;
 }>;

package/dist/links.js

@@ -106,6 +106,7 @@ export function playlistFrom(text, base) {
     const image = entries.map((entry) => pictureUrl(entry.logo)).find((one) => one !== "") ?? "";
     return { hls: false, sources: entries.map((entry) => entry.source), image };
 }
+const PLAYLIST_MAX_REDIRECTS = 5;
 /**
  * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
  * here rather than by yt-dlp, which would take the first entry and stop, or
@@ -117,7 +118,24 @@ export async function resolvePlaylist(url, options = {}) {
     const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? PLAYLIST_FETCH_TIMEOUT_MS);
     let text = "";
     try {
-        const answer = await get(url, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: "follow" });
+        // Followed here, one hop at a time, when there is a guard: a public
+        // address that redirects to the router is the router.
+        let at = url;
+        let answer;
+        for (let hop = 0;; hop += 1) {
+            if (options.guard) {
+                const refused = await options.guard(at);
+                if (refused)
+                    return { error: refused };
+            }
+            answer = await get(at, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: options.guard ? "manual" : "follow" });
+            const next = answer.headers.get("location");
+            if (!options.guard || answer.status < 300 || answer.status >= 400 || !next)
+                break;
+            if (hop >= PLAYLIST_MAX_REDIRECTS)
+                return { error: "that playlist redirects too many times" };
+            at = new URL(next, at).toString();
+        }
         if (!answer.ok)
             return { error: `that playlist could not be fetched (HTTP ${answer.status})` };
         text = (await answer.text()).slice(0, PLAYLIST_MAX_BYTES);
@@ -442,7 +460,7 @@ export async function resolveLink(ytdlp, url, options = {}) {
     if (isDirectMedia(url))
         return directLink(url);
     if (isPlaylistLink(url))
-        return resolvePlaylist(url, { timeoutMs: options.timeoutMs });
+        return resolvePlaylist(url, { timeoutMs: options.timeoutMs, guard: options.guard });
     // Without yt-dlp, a link is taken as the media it may well be: an IPTV
     // feed has no extension and no page behind it, and ffprobe -- asked next,
     // before anything goes on the air -- tells a stream from a web page in a

package/dist/main.d.ts

@@ -1,11 +1,3 @@
-/**
- * nixamp — it really whips the terminal's ass.
- *
- *   bunx nixamp ~/Music
- *   bunx nixamp track.flac
- *
- * ffmpeg decodes; we read every sample on its way to the speakers and draw it.
- */
 import { type BrailleCanvas, type Container, type Theme } from "@profullstack/hqtui";
 import { type Track } from "./audio.ts";
 export declare const BAND_COUNT = 24;

package/dist/main.js

@@ -7,6 +7,7 @@ import { t as uiMessage, i18n, terminalUiLanguage, uiLanguage } from "./i18n.js"
  *
  * ffmpeg decodes; we read every sample on its way to the speakers and draw it.
  */
+import { USAGE as STATION_USAGE } from "./station-usage.js";
 import { createApp, themes } from "@profullstack/hqtui";
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
@@ -206,6 +207,7 @@ keeps serving its browser remote. One per user.
 
   nixamp attach   put the player back in front of it
   nixamp admin    who is connected, and re-stream to them
+  nixamp station  make a folder into a station others can join (see: nixamp station help)
 
 From inside the player, d hands the music to a daemon without stopping it.
 `,
@@ -367,6 +369,8 @@ q or d leaves; neither stops anything. \`nixamp daemon stop\` is what stops it.
 `,
 };
 export function helpFor(topic) {
+    if (topic === "station" || topic === "stations")
+        return STATION_USAGE;
     return (topic ? TOPICS[topic] : undefined) ?? HELP;
 }
 /**
@@ -524,6 +528,11 @@ export async function main() {
         process.exitCode = await runDaemon(rest);
         return;
     }
+    if (first === "station" || first === "stations") {
+        const { station } = await import("./station-cli.js");
+        process.exitCode = await station(rest);
+        return;
+    }
     if (first === "admin") {
         const { admin } = await import("./admin.js");
         await admin(rest);

package/dist/playlist-input.d.ts

@@ -7,7 +7,41 @@ export interface PlaylistInput {
     video: boolean;
     width?: number;
     height?: number;
+    /**
+     * Back to the top when the end is reached, instead of finishing: a
+     * station, which plays until somebody stops it.
+     */
+    repeat?: boolean;
+    /**
+     * The order to play a list of this length in, asked at the top of every
+     * pass: a station-wide shuffle is one order for everybody listening, drawn
+     * again each time round. Unset is the list's own order.
+     */
+    order?: (length: number) => number[];
+    /** Read at every entry boundary, so an edit to the list lands on the next track. */
+    current?: () => string[];
+    /** Entries already known not to play, passed over without being tried. */
+    excluded?: (file: string) => boolean;
+    /**
+     * Pass over an entry that will not play, instead of failing the stream.
+     * For a station, where the next track is what a listener should hear. A
+     * folder live leaves it unset: there a missing entry is usually a file
+     * still arriving, and the channel redials and waits for it.
+     */
+    passOver?: boolean;
+    /** Told when an entry is passed over because it would not play. */
+    onFailure?: (event: {
+        at: number;
+        file: string;
+        reason: string;
+    }) => void;
 }
+/**
+ * How many entries in a row may fail before the list is given up on. A
+ * corrupt file is skipped; a list where nothing plays is an error, said once,
+ * not a loop.
+ */
+export declare const MAX_FAILURES_IN_A_ROW = 5;
 /** Decode each file independently; feed one persistent muxer a fixed stream
  * profile and continuous timestamps. A concat demuxer cannot decode a list
  * whose input codecs differ. Only one entry is encoded at a time, with pipe
@@ -18,9 +52,21 @@ export declare class PlaylistInputStream {
     error: Error | null;
     complete: boolean;
     constructor(options: PlaylistInput);
+    /** Every entry that has started, in the order it started, with where it sits in the stream. */
+    get history(): ReadonlyArray<{
+        at: number;
+        file: string;
+        start: number;
+        position: number;
+    }>;
     place(seconds: number): {
         at: number;
         position: number;
     };
+    /** The decoder for the entry that is on, so skip() can end it early. */
+    private stopCurrent;
+    private skipping;
+    /** End the entry that is on and go to the next. False when nothing is on. */
+    skip(): boolean;
     open(signal: AbortSignal): AsyncGenerator<Buffer>;
 }