nixamp 0.28.45 → 0.29.1

package/dist/playlist-input.js

@@ -1,5 +1,12 @@
 import { spawn } from "node:child_process";
+import { protocolArgs } from "./decoder-policy.js";
 import { codecsOf } from "./audio.js";
+/**
+ * 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 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
@@ -12,11 +19,26 @@ export class PlaylistInputStream {
     constructor(options) {
         this.options = options;
     }
+    /** Every entry that has started, in the order it started, with where it sits in the stream. */
+    get history() {
+        return this.entries;
+    }
     place(seconds) {
         const entry = this.entries.findLast(one => seconds >= one.start) ?? this.entries[0];
         return entry ? { at: entry.at, position: Math.max(0, seconds - entry.start + entry.position) }
             : { at: this.options.at, position: this.options.position };
     }
+    /** The decoder for the entry that is on, so skip() can end it early. */
+    stopCurrent = null;
+    skipping = false;
+    /** End the entry that is on and go to the next. False when nothing is on. */
+    skip() {
+        if (!this.stopCurrent)
+            return false;
+        this.skipping = true;
+        this.stopCurrent();
+        return true;
+    }
     async *open(signal) {
         const o = this.options;
         const [command, ...prefix] = o.ffmpeg;
@@ -24,66 +46,148 @@ export class PlaylistInputStream {
         const width = Math.max(2, Math.floor((o.width || 1280) * ratio / 2) * 2);
         const height = Math.max(2, Math.floor((o.height || 720) * ratio / 2) * 2);
         let offset = 0;
+        let failuresInARow = 0;
+        let first = true;
         try {
-            for (let at = o.at; at < o.files.length && !signal.aborted; at++) {
-                const file = o.files[at];
-                const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
+            const orderFor = (list) => o.order ? o.order(list.length).filter((one) => one >= 0 && one < list.length) : list.map((_, index) => index);
+            let files = o.current?.() ?? o.files;
+            if (files.length === 0)
+                throw new Error("The playlist is empty");
+            let order = orderFor(files);
+            let step = Math.min(o.at, order.length);
+            let played = 0;
+            let last = "";
+            for (;;) {
                 if (signal.aborted)
-                    return;
-                if (!codecs.audio && !codecs.video)
-                    throw new Error(`Cannot decode playlist entry ${at + 1}`);
-                const position = at === o.at ? o.position : 0;
-                const duration = (codecs.duration ?? 0) - position;
-                if (duration <= 0)
-                    throw new Error(`No playable duration for playlist entry ${at + 1}`);
-                this.entries.push({ at, start: offset, position });
-                const hasVideo = Boolean(codecs.video);
-                const extra = o.video && !hasVideo
-                    ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]
-                    : o.video && !codecs.audio ? ["-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo"] : [];
-                const args = [
-                    ...prefix, "-hide_banner", "-loglevel", "error", "-nostdin", "-filter_threads", "2",
-                    "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), "-i", file,
-                    ...extra, "-t", String(duration),
-                    ...(o.video ? [
-                        "-map", hasVideo ? "0:v:0" : "1:v:0", "-map", codecs.audio ? "0:a:0" : "1:a:0",
-                        "-vf", `fps=30,scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1,setpts=PTS-STARTPTS`,
-                        "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-tune", "zerolatency",
-                        "-crf", "23", "-pix_fmt", "yuv420p", "-g", "60", "-keyint_min", "60", "-sc_threshold", "0",
-                    ] : ["-map", "0:a:0", "-vn"]),
-                    "-af", "aresample=48000,asetpts=PTS-STARTPTS", "-c:a", "aac", "-b:a", "160k", "-ac", "2",
-                    "-mpegts_flags", "+initial_discontinuity", "-output_ts_offset", String(offset), "-mpegts_copyts", "1", "-muxdelay", "0", "-muxpreload", "0",
-                    "-f", "mpegts", "pipe:1",
-                ];
-                const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-                let tail = "";
-                child.stderr.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
-                const closed = new Promise((resolve) => {
-                    child.once("error", error => { tail = error.message; resolve(-1); });
-                    child.once("close", code => resolve(code));
-                });
-                const abort = () => { child.kill("SIGKILL"); };
-                signal.addEventListener("abort", abort, { once: true });
-                try {
-                    for await (const chunk of child.stdout) {
+                    break;
+                // Asked at every boundary, so an edit lands on the next track. The
+                // list goes on after the file that just played, where the new list
+                // has it; a shuffled list draws a new order.
+                if (o.current) {
+                    const fresh = o.current();
+                    if (fresh.length !== files.length || fresh.some((one, index) => one !== files[index])) {
+                        if (fresh.length === 0)
+                            throw new Error("The playlist is empty");
+                        files = fresh;
+                        order = orderFor(files);
+                        const where = last ? files.indexOf(last) : -1;
+                        step = o.order ? 0 : where >= 0 ? where + 1 : Math.min(step, files.length);
+                    }
+                }
+                if (step >= order.length) {
+                    if (!o.repeat)
+                        break;
+                    // A pass where everything was passed over is a list with nothing
+                    // to play, and repeating it would be the loop this exists to avoid.
+                    if (played === 0)
+                        throw new Error("Nothing in this playlist would play");
+                    played = 0;
+                    order = orderFor(files);
+                    step = 0;
+                    continue;
+                }
+                {
+                    const at = order[step];
+                    step += 1;
+                    const file = files[at];
+                    last = file;
+                    if (o.excluded?.(file))
+                        continue;
+                    const position = first && step - 1 === o.at ? o.position : 0;
+                    first = false;
+                    let reached = 0;
+                    try {
+                        const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
                         if (signal.aborted)
                             return;
-                        yield chunk;
+                        if (!codecs.audio && !codecs.video)
+                            throw new Error(`Cannot decode playlist entry ${at + 1}`);
+                        const duration = (codecs.duration ?? 0) - position;
+                        if (duration <= 0)
+                            throw new Error(`No playable duration for playlist entry ${at + 1}`);
+                        this.entries.push({ at, file, start: offset, position });
+                        const hasVideo = Boolean(codecs.video);
+                        const extra = o.video && !hasVideo
+                            ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]
+                            : o.video && !codecs.audio ? ["-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo"] : [];
+                        const args = [
+                            ...prefix, "-hide_banner", "-loglevel", "error", "-nostdin", "-filter_threads", "2",
+                            // How far this entry got, so an entry cut short -- skipped, or
+                            // broken halfway -- moves the clock by what was played and the
+                            // next one starts where this one stopped, not after a gap.
+                            "-progress", "pipe:3", "-stats_period", "0.5",
+                            "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), ...protocolArgs(file), "-i", file,
+                            ...extra, "-t", String(duration),
+                            ...(o.video ? [
+                                "-map", hasVideo ? "0:v:0" : "1:v:0", "-map", codecs.audio ? "0:a:0" : "1:a:0",
+                                "-vf", `fps=30,scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1,setpts=PTS-STARTPTS`,
+                                "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-tune", "zerolatency",
+                                "-crf", "23", "-pix_fmt", "yuv420p", "-g", "60", "-keyint_min", "60", "-sc_threshold", "0",
+                            ] : ["-map", "0:a:0", "-vn"]),
+                            "-af", "aresample=48000,asetpts=PTS-STARTPTS", "-c:a", "aac", "-b:a", "160k", "-ac", "2",
+                            "-mpegts_flags", "+initial_discontinuity", "-output_ts_offset", String(offset), "-mpegts_copyts", "1", "-muxdelay", "0", "-muxpreload", "0",
+                            "-f", "mpegts", "pipe:1",
+                        ];
+                        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe", "pipe"] });
+                        let tail = "";
+                        child.stderr.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
+                        child.stdio[3]?.on("data", (chunk) => {
+                            const found = /out_time_us=(\d+)/g;
+                            let match;
+                            while ((match = found.exec(chunk.toString())) !== null)
+                                reached = Math.max(reached, Number(match[1]) / 1e6);
+                        });
+                        const closed = new Promise((resolve) => {
+                            child.once("error", error => { tail = error.message; resolve(-1); });
+                            child.once("close", code => resolve(code));
+                        });
+                        const abort = () => { child.kill("SIGKILL"); };
+                        signal.addEventListener("abort", abort, { once: true });
+                        this.stopCurrent = abort;
+                        let skipped = false;
+                        try {
+                            for await (const chunk of child.stdout) {
+                                if (signal.aborted)
+                                    return;
+                                yield chunk;
+                            }
+                            const code = await closed;
+                            if (signal.aborted)
+                                return;
+                            skipped = this.skipping;
+                            if (code !== 0 && !skipped)
+                                throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
+                        }
+                        finally {
+                            this.stopCurrent = null;
+                            this.skipping = false;
+                            signal.removeEventListener("abort", abort);
+                            abort();
+                            await closed;
+                        }
+                        failuresInARow = 0;
+                        played += 1;
+                        // Match the frame grid used above so rounding cannot accumulate a
+                        // backwards timestamp over hundreds of short files.
+                        const length = skipped ? Math.min(duration, reached) : duration;
+                        offset += o.video ? Math.ceil(length * 30) / 30 : length;
+                    }
+                    catch (error) {
+                        if (signal.aborted || !o.passOver)
+                            throw error;
+                        // Passed over, not dialled again: the next entry is what a
+                        // listener should hear, and a file that will not decode now will
+                        // not decode in two seconds either.
+                        const reason = error instanceof Error ? error.message : String(error);
+                        o.onFailure?.({ at, file, reason });
+                        if (reached > 0)
+                            offset += o.video ? Math.ceil(reached * 30) / 30 : reached;
+                        failuresInARow += 1;
+                        if (failuresInARow >= Math.min(MAX_FAILURES_IN_A_ROW, Math.max(1, files.length))) {
+                            throw new Error(`Nothing in this playlist would play: ${reason}`);
+                        }
                     }
-                    const code = await closed;
-                    if (signal.aborted)
-                        return;
-                    if (code !== 0)
-                        throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
-                }
-                finally {
-                    signal.removeEventListener("abort", abort);
-                    abort();
-                    await closed;
                 }
-                // Match the frame grid used above so rounding cannot accumulate a
-                // backwards timestamp over hundreds of short files.
-                offset += o.video ? Math.ceil(duration * 30) / 30 : duration;
             }
             this.complete = !signal.aborted;
         }

package/dist/publish-choice.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Whether this server goes in the public directory.
+ *
+ * A listing is a phone code and a link anybody can open, so it is a thing
+ * somebody chose, not a thing that happens because a daemon had no terminal
+ * to ask on. The choice is asked once, or taken from a flag, and written into
+ * config.json beside the library, and every later start reads it back.
+ *
+ * Servers that were listed before the choice was written down keep being
+ * listed: a daemon without a terminal used to publish by itself, and quietly
+ * taking it off the directory on an update would be changing somebody's
+ * choice for them. A server new to this machine is not listed until asked.
+ */
+export type PublishFlag = "ask" | "yes" | "no";
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export declare function publishChoice(flag: PublishFlag, recorded: boolean | undefined, interactive: boolean, established: boolean): "yes" | "no" | "ask";
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export declare function shouldRecord(flag: PublishFlag, recorded: boolean | undefined): boolean;

package/dist/publish-choice.js

@@ -0,0 +1,17 @@
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export function publishChoice(flag, recorded, interactive, established) {
+    if (flag !== "ask")
+        return flag;
+    if (recorded !== undefined)
+        return recorded ? "yes" : "no";
+    if (interactive)
+        return "ask";
+    return established ? "yes" : "no";
+}
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export function shouldRecord(flag, recorded) {
+    return flag === "ask" && recorded === undefined;
+}

package/dist/server.js

@@ -9,7 +9,9 @@
  * a WebSocket because SSE is plain HTTP: no dependency, and it reconnects on
  * its own when the laptop running the remote goes to sleep.
  */
-import { createReadStream, statSync } from "node:fs";
+import { publishChoice, shouldRecord } from "./publish-choice.js";
+import { protocolArgs } from "./decoder-policy.js";
+import { createReadStream, existsSync, statSync } from "node:fs";
 import { createServer as createHttpServer } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
 import { randomBytes } from "node:crypto";
@@ -51,6 +53,7 @@ import { Directory, ENDED_TTL_MS, parseAnnouncement } from "./directory.js";
 import { ArtCache, coverArtOf, stillFrom } from "./art.js";
 import { PartyLine, telnyxSms } from "./partyline.js";
 import { HlsPackagers, segmentType, withKey } from "./hls.js";
+import { refusedDestination } from "./destinations.js";
 import { CompressionService } from "./compression/service.js";
 import { handleChannelCompression, handleCompressionApi, handleStaticRelay } from "./compression/routes.js";
 import { DEFAULT_SITE as NICHEDB, Enricher, FIXTURE_TTL_MS } from "./enrich.js";
@@ -65,7 +68,7 @@ import { Porkbun, isIPv4, isIPv6 } from "./dns.js";
 import { NameError, Names } from "./names.js";
 import { AcmeIssuer, Certs } from "./certs.js";
 import { claimName, fetchCert, humanizeSource, labelFor, readCertFiles, writeCertFiles } from "./naming.js";
-import { forbiddenLibrary, readLibrary } from "./library.js";
+import { forbiddenLibrary, readConfig, readLibrary, writeConfig } from "./library.js";
 import { createThrottle, presentedCredential } from "@profullstack/throttle";
 import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
@@ -1469,7 +1472,7 @@ export function createHandler(engine, options) {
                 json(response, 404, { error: "not found" });
                 return;
             }
-            response.writeHead(302, { ...CORS, "set-cookie": keyCookie(offered), location: "/" });
+            response.writeHead(302, { ...CORS, "set-cookie": keyCookie(offered, request.socket.encrypted === true || (options.secureCookies ?? false)), location: "/" });
             response.end();
             return;
         }
@@ -2061,12 +2064,18 @@ export function createHandler(engine, options) {
         // port is open from another device before wondering whether the link is
         // wrong, and it says nothing about the library.
         const eventChannelRequest = Boolean(channelId && await eventForChannel());
+        // Whether this request holds only the listen key. A listener may browse
+        // and hear the library, but where it lives on this machine is the
+        // owner's business: the absolute path names the user account and the disk.
+        let listening = false;
         if (key !== null &&
             path !== "/api/health" &&
             path !== "/api/directory" &&
             !isSignInPath(path) &&
             !eventChannelRequest) {
             let scope = scopeOf(keyFrom(request, url), key, listenKey);
+            // Kept for the routes below that answer a listener with less.
+            const settle = () => { listening = scope === "listen"; };
             // A key is how somebody who was invited proves it. It is not the only way
             // to be allowed in: the person who owns this server is allowed in whether
             // or not they still have the link, and their nixamp.com session says who
@@ -2093,6 +2102,7 @@ export function createHandler(engine, options) {
                 });
                 return;
             }
+            settle();
             if (scope === "listen" && !allowedForListening(path)) {
                 json(response, 403, { error: "this link can listen, not drive" });
                 return;
@@ -4204,11 +4214,32 @@ export function createHandler(engine, options) {
                 json(response, 429, { error: `this server is already carrying ${MAX_ON_DEMAND} channels on demand; try again in a minute` });
                 return;
             }
-            const resolved = known ?? await resolveLink(options.ytdlp ?? null, link, { cookies: options.cookies ?? "" });
+            // A member's link is fetched from inside the owner's network, so it has
+            // to lead somewhere public: the link, every hop of a playlist, and
+            // whatever yt-dlp says the media is. The owner's is theirs to aim.
+            const guard = liveBy && !known ? (one) => refusedDestination(one) : undefined;
+            if (guard) {
+                const refused = await guard(link);
+                if (refused) {
+                    json(response, 403, { error: refused });
+                    return;
+                }
+            }
+            const resolved = known ?? await resolveLink(options.ytdlp ?? null, link, { cookies: options.cookies ?? "", guard });
             if ("error" in resolved) {
-                json(response, 422, { error: resolved.error });
+                json(response, guard && resolved.error.includes("private network") ? 403 : 422, { error: resolved.error });
                 return;
             }
+            if (guard) {
+                const reached = [resolved.media, resolved.audio, ...(resolved.playlist ?? [])].filter((one) => one && /^(https?|rtmps?):\/\//i.test(one));
+                for (const one of [...new Set(reached)].slice(0, 200)) {
+                    const refused = await guard(one);
+                    if (refused) {
+                        json(response, 403, { error: refused });
+                        return;
+                    }
+                }
+            }
             links.set(link, resolved);
             // A channel already on -- put back by a restart, which forgets where
             // it came from -- learns its picture and its line from the link pasted
@@ -5068,7 +5099,7 @@ export function createHandler(engine, options) {
             return;
         }
         if (path === "/api/state") {
-            json(response, 200, engine.snapshot());
+            json(response, 200, listening ? { ...engine.snapshot(), root: "" } : engine.snapshot());
             return;
         }
         // Everything the admin view draws, in one request: who is connected, and
@@ -5132,7 +5163,7 @@ export function createHandler(engine, options) {
                 "x-accel-buffering": "no",
             });
             const send = (snapshot) => {
-                response.write(`data: ${JSON.stringify(snapshot)}\n\n`);
+                response.write(`data: ${JSON.stringify(listening ? { ...snapshot, root: "" } : snapshot)}\n\n`);
             };
             const unsubscribe = engine.subscribe(send);
             // A comment line keeps proxies from closing an idle stream.
@@ -5577,6 +5608,7 @@ async function liveAudio(request, response, engine, ffmpeg, ffprobe) {
             // A live source has no beginning to seek from.
             ...(from > 1 && !isRemote(source) ? ["-ss", String(from)] : []),
             "-re",
+            ...protocolArgs(source),
             "-i", source,
             ...(asVideo
                 // Copied where it can be, because a room full of viewers is a room
@@ -5681,6 +5713,7 @@ inputArgs = []) {
         // when they are handed to it for a file on disk.
         ...(isRemote(source) ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
         ...inputArgs,
+        ...protocolArgs(source),
         "-i", source,
         ...outputArgs,
         "-",
@@ -5860,6 +5893,15 @@ export async function serve(argv, version = "0.1.0") {
     // still works after a restart -- and a server is restarted to pick up a new
     // version, which is to say often. `--new-key` mints a fresh pair and forgets
     // the old one, which is the way to revoke a link that got out.
+    // Whether this port had keys before this start: a server that has run
+    // here before, whose directory listing (see publishChoice) is kept.
+    const established = existsSync(join(stateDir(), "keys.json")) &&
+        (() => { try {
+            return String(options.port) in JSON.parse(readFileSync(join(stateDir(), "keys.json"), "utf8"));
+        }
+        catch {
+            return false;
+        } })();
     const remembered = options.key ? rememberedKeys(stateDir(), options.port, options.newKey) : null;
     const key = remembered?.key ?? null;
     // Kept whether or not it is published, so `nixamp admin` and the operator
@@ -6959,10 +7001,23 @@ export async function serve(argv, version = "0.1.0") {
         // public at all.
         //
         // Still asked when a person is at the terminal to answer, because that is
-        // somebody who can say no.
-        const wanted = options.publish === "yes" || !process.stdin.isTTY
-            ? true
-            : await confirm(`\n  List this stream at ${DEFAULT_DIRECTORY}/directory so anyone can find it?\n  It publishes ${listen} — listen only, not the controls.`);
+        // somebody who can say no -- and since 0.29 the answer is kept, so a
+        // daemon started later does what the person said, not what it guesses.
+        const recorded = readConfig().publish;
+        const choice = publishChoice(options.publish, recorded, Boolean(process.stdin.isTTY), established);
+        const wanted = choice === "ask"
+            ? await confirm(`\n  List this stream at ${DEFAULT_DIRECTORY}/directory so anyone can find it?\n  It publishes ${listen} — listen only, not the controls.`)
+            : choice === "yes";
+        if (shouldRecord(options.publish, recorded)) {
+            try {
+                writeConfig({ publish: wanted });
+            }
+            catch { /* unwritable state: asked again next time */ }
+        }
+        if (!wanted && options.publish === "ask") {
+            console.log("");
+            console.log(`  Not listed at ${DEFAULT_DIRECTORY}/directory. Start with --publish to list it.`);
+        }
         if (wanted) {
             publisher = makePublisher();
             listing = (await publisher?.start()) ?? null;

package/dist/share.d.ts

@@ -47,7 +47,7 @@ export declare function keysMatch(a: string, b: string): boolean;
 /** Every place a key is accepted from, in the order they are looked for. */
 export declare function keyFrom(request: IncomingMessage, url: URL): string | null;
 /** The Set-Cookie for a browser that just opened the link. */
-export declare function keyCookie(key: string): string;
+export declare function keyCookie(key: string, secure?: boolean): string;
 /** Where an address actually goes, which is not always where you would like. */
 export declare function classify(address: string): "private" | "cgnat" | "public";
 /** Looks like an address, rather than an error page or a rate-limit notice. */

package/dist/share.js

@@ -108,11 +108,12 @@ export function keyFrom(request, url) {
     return null;
 }
 /** The Set-Cookie for a browser that just opened the link. */
-export function keyCookie(key) {
+export function keyCookie(key, secure = false) {
     // HttpOnly because nothing in the page reads it: the browser attaches it to
-    // every same-origin request by itself. No Secure, because the whole point is
-    // a plain-http address on your own network.
-    return `${KEY_COOKIE}=${encodeURIComponent(key)}; Path=/; Max-Age=31536000; SameSite=Lax; HttpOnly`;
+    // every same-origin request by itself. Secure only when the link was opened
+    // over https: a plain-http address on your own network is still a thing,
+    // and a Secure cookie there would never be sent back.
+    return `${KEY_COOKIE}=${encodeURIComponent(key)}; Path=/; Max-Age=31536000; SameSite=Lax; HttpOnly${secure ? "; Secure" : ""}`;
 }
 /**
  * Interfaces that exist for containers and virtual machines. An address on one

package/package.json

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

package/src/audio.ts

@@ -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.ts";
 import { spawn, spawnSync, type ChildProcess } from "node:child_process";
 import { readdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -136,6 +137,7 @@ export function probe(tools: Tools, path: string): Track {
     ...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) return fallback;
@@ -224,6 +226,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/src/channels.ts

@@ -14,11 +14,12 @@
  * 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.ts";
 import { spawn, type ChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { PlaylistInputStream } from "./playlist-input.ts";
+import { PlaylistInputStream, type PlaylistInput } from "./playlist-input.ts";
 import type { Readable } from "node:stream";
 import { FragmentClock, Fragments, isOpening } from "./fragments.ts";
 
@@ -122,6 +123,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">;
 }
 
 /**
@@ -284,6 +292,13 @@ export class Channel {
   private redial: (() => void) | null = null;
   /** For a channel playing a list: move to the next entry. Null when there is no list. */
   private advance: (() => boolean) | null = null;
+  /** The list being played entry by entry, when it is one; what skip() moves on. */
+  private playlistInput: PlaylistInputStream | null = null;
+
+  /** On to the next entry of a list of files. False when this is not one. */
+  skip(): boolean {
+    return this.playlistInput?.skip() ?? false;
+  }
   private failures = 0;
   private timer: ReturnType<typeof setTimeout> | null = null;
   /** Fires when a pulled source has said nothing for STALL. */
@@ -400,7 +415,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;
@@ -450,7 +465,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: AbortSignal) => playlistInput.open(signal) }
         : this.options.through?.(this.info, from, input, audio) ?? null;
@@ -503,10 +520,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",
@@ -1324,6 +1341,11 @@ export class Channels {
     return this.open.get(id)?.info.kind;
   }
 
+  /** The next entry, now, on a channel playing a list of files. */
+  skip(id: string): boolean {
+    return this.open.get(id)?.skip() ?? false;
+  }
+
   stop(id: string): boolean {
     const channel = this.open.get(id);
     if (!channel) return false;