nixamp 0.13.0 → 0.14.0

package/dist/audio.d.ts

@@ -92,6 +92,12 @@ export interface Codecs {
      * is a track no browser will play.
      */
     container: string;
+    /**
+     * How long it is, in seconds; 0 when it has no end, which is what tells a
+     * live channel from a film. A film has a place to go back to after a
+     * restart; a live channel is wherever it is now.
+     */
+    duration?: number;
 }
 /**
  * Ask ffprobe what the streams are, without holding the event loop.

package/dist/audio.js

@@ -357,7 +357,7 @@ export async function codecsOf(tools, path, input = []) {
             ...rest,
             "-v", "quiet",
             "-print_format", "json",
-            "-show_entries", "format=format_name:stream=codec_type,codec_name",
+            "-show_entries", "format=format_name,duration:stream=codec_type,codec_name",
             // Headers the source's site expects, for a link resolved by yt-dlp.
             ...input,
             path,
@@ -371,10 +371,14 @@ export async function codecsOf(tools, path, input = []) {
             try {
                 const parsed = JSON.parse(out);
                 const streams = parsed.streams ?? [];
+                // 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);
                 return done({
                     video: streams.find((s) => s.codec_type === "video")?.codec_name ?? "",
                     audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
                     container: parsed.format?.format_name ?? "",
+                    duration: Number.isFinite(seconds) && seconds > 0 ? seconds : 0,
                 });
             }
             catch {

package/dist/channels.d.ts

@@ -27,7 +27,35 @@ export interface ChannelInfo {
     error?: string;
     /** How many times the source has been dialled again since it started. */
     redials?: number;
+    /**
+     * For a pulled film: how far into it we are, in seconds, read off ffmpeg
+     * as it goes. This is what a restart and a redial go back to. A live
+     * source has no such place, and says so with `live`.
+     */
+    position?: number;
+    live?: boolean;
+    /** What the source turned out to hold, so a restart need not ask again. */
+    codecs?: {
+        video: string;
+        audio: string;
+        container: string;
+        duration?: number;
+    };
+}
+/** Where a pulled source is picked up from, and whether it can be at all. */
+export interface PullResume {
+    /** A live source is joined where it is now; a film is joined where it was. */
+    live: boolean;
+    /** Seconds into a film to start from. */
+    position: number;
 }
+/**
+ * How far back of the saved place a film is picked up from, in seconds. The
+ * place is written down every so often and a restart lands between two
+ * writes; a few seconds repeated is a hiccup, a few seconds missed is a
+ * line of dialogue.
+ */
+export declare const REWIND = 3;
 /** How long to wait before dialling a dropped source again. */
 export declare const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
@@ -116,7 +144,7 @@ export declare class Channel {
      * because you looked away, and a room where the picture depends on who is
      * in it is not a room anybody can be invited to.
      */
-    pull(source: string, encode: string[], paced?: boolean, stall?: number, input?: string[]): void;
+    pull(source: string, encode: string[], paced?: boolean, stall?: number, input?: string[], audio?: string, resume?: PullResume): void;
     /**
      * Start the source over, now.
      *
@@ -209,7 +237,7 @@ export declare class Channels {
      * about it is the same too, which is the point -- a re-stream stops being a
      * special case and becomes one more thing that is on.
      */
-    pull(id: string, name: string, source: string, encode: string[], kind: "audio" | "video", paced?: boolean, stall?: number, input?: string[]): Channel | null;
+    pull(id: string, name: string, source: string, encode: string[], kind: "audio" | "video", paced?: boolean, stall?: number, input?: string[], audio?: string, resume?: PullResume): Channel | null;
     /**
      * Dial a pulled channel's source again, now. False for a channel that is
      * not there or is not ours to dial: a publisher's stream restarts at the
@@ -265,8 +293,33 @@ export interface RememberedChannel {
     id: string;
     name: string;
     source: string;
+    /**
+     * What it was, so a restart need not ask the source again. Asking is not
+     * free: a film on an IPTV panel allows one connection, and while the old
+     * ffmpeg's is still being counted a probe of it gets an error page and no
+     * streams -- which read as "no picture", and two films came back on the
+     * air as sound alone.
+     */
+    kind?: "audio" | "video";
+    codecs?: {
+        video: string;
+        audio: string;
+        container: string;
+        duration?: number;
+    };
+    /** Where a film had got to, in seconds, so it picks up there. */
+    position?: number;
+    /** A live source has nowhere to pick up from. */
+    live?: boolean;
 }
 export declare function rememberedChannels(dir: string, port: number): RememberedChannel[];
+/**
+ * What to write down about the channels a server is carrying: the pulled,
+ * kept ones, with what they turned out to be and where they have got to.
+ * The same answer everywhere one is added, kept, or taken off, so that no
+ * path forgets the position.
+ */
+export declare function rememberedNow(channels: Channels): RememberedChannel[];
 export declare function rememberChannels(dir: string, port: number, list: RememberedChannel[]): void;
 /** A channel id nobody chose, for a publisher that did not name one. */
 export declare function generatedId(): string;

package/dist/channels.js

@@ -19,6 +19,13 @@ import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { Fragments, isOpening } from "./fragments.js";
+/**
+ * How far back of the saved place a film is picked up from, in seconds. The
+ * place is written down every so often and a restart lands between two
+ * writes; a few seconds repeated is a hiccup, a few seconds missed is a
+ * line of dialogue.
+ */
+export const REWIND = 3;
 /** How long to wait before dialling a dropped source again. */
 export const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
@@ -168,29 +175,48 @@ export class Channel {
      * because you looked away, and a room where the picture depends on who is
      * in it is not a room anybody can be invited to.
      */
-    pull(source, encode, paced = true, stall = STALL, input = []) {
+    pull(source, encode, paced = true, stall = STALL, input = [], audio = "", resume = { live: true, position: 0 }) {
         this.stall = stall;
         if (this.info.kind === "video")
             this.fragments = new Fragments();
         const [command, ...prefix] = this.options.ffmpeg;
         const remote = /^https?:\/\//i.test(source);
+        this.info.live = resume.live;
+        if (!resume.live)
+            this.info.position = Math.max(0, resume.position);
+        // What every remote input is told: dial again when the CDN drops it, and
+        // give up on a socket that has gone quiet. Input options apply to the
+        // input that follows them, so a second input is told again.
+        const remoteArgs = remote
+            ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5", "-rw_timeout", String(stall * 1000)]
+            : [];
         const dial = () => {
             if (this.closing)
                 return;
             this.stderr = "";
+            // Where to pick a film up from: a little before where it was, since
+            // the place was written down a moment ago and a moment of it twice is
+            // better than a moment of it missing. A live source is joined as is,
+            // and a film that has barely started is started.
+            const from = resume.live ? 0 : Math.max(0, Math.floor((this.info.position ?? 0) - REWIND));
+            const seek = from > 0 ? ["-ss", String(from)] : [];
             const child = spawn(command, [
                 ...prefix,
                 "-hide_banner",
                 "-loglevel", "error",
+                // How far it has got, once a second, on a pipe of its own: this is
+                // what is written down for a restart and what a redial goes back
+                // to. Not stderr, which is for what went wrong.
+                "-progress", "pipe:3",
+                "-stats_period", "1",
                 // A dropped source is normal over hours, and a channel that dies
                 // the first time a CDN hiccups is not a channel anybody can rely
                 // on. ffmpeg redials on its own before we have to.
-                ...(remote ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
                 // A connection that stops answering is an error after this long,
-                // and an error is a thing the reconnect above knows what to do
-                // with. Without it a silent socket is waited on for ever. In
+                // and an error is a thing the reconnect knows what to do with.
+                // Without it a silent socket is waited on for ever. In
                 // microseconds, as ffmpeg wants it.
-                ...(remote ? ["-rw_timeout", String(stall * 1000)] : []),
+                ...remoteArgs,
                 // Real time, always. A file read as fast as the disk allows is an
                 // hour of film in ninety seconds and a room that cannot be in it
                 // together; a live source is already paced and loses nothing.
@@ -199,13 +225,35 @@ export class Channel {
                 // 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", source,
+                // 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] : []),
                 ...encode,
                 "pipe:1",
-            ], { stdio: ["ignore", "pipe", "pipe"] });
+            ], { stdio: ["ignore", "pipe", "pipe", "pipe"] });
             let sent = false;
             this.child = child;
             this.rearm(child);
+            // ffmpeg's progress: key=value lines, out_time_us being how much it
+            // has written, from where it was told to start. Read whole lines,
+            // since a chunk can end mid-number. Drained whatever it says, for
+            // the same reason stderr is.
+            let progress = "";
+            child.stdio[3]?.on("data", (chunk) => {
+                progress = (progress + chunk.toString("utf8")).slice(-4000);
+                if (this.child !== child || resume.live)
+                    return;
+                const lines = progress.split("\n");
+                progress = lines.pop() ?? "";
+                for (const line of lines) {
+                    const match = /^out_time_us=(\d+)/.exec(line.trim());
+                    if (match)
+                        this.info.position = from + Number(match[1]) / 1e6;
+                }
+            });
+            child.stdio[3]?.on("error", () => undefined);
             child.stdout?.on("data", (chunk) => {
                 // An ffmpeg that was replaced can still have a chunk in the pipe.
                 if (this.child !== child)
@@ -560,7 +608,7 @@ export class Channels {
      * about it is the same too, which is the point -- a re-stream stops being a
      * special case and becomes one more thing that is on.
      */
-    pull(id, name, source, encode, kind, paced = true, stall = STALL, input = []) {
+    pull(id, name, source, encode, kind, paced = true, stall = STALL, input = [], audio = "", resume = { live: true, position: 0 }) {
         if (this.open.has(id))
             return null;
         const channel = new Channel({
@@ -575,7 +623,7 @@ export class Channels {
             source,
         }, this.options, (gone) => this.open.delete(gone));
         this.open.set(id, channel);
-        channel.pull(source, encode, paced, stall, input);
+        channel.pull(source, encode, paced, stall, input, audio, resume);
         return channel;
     }
     /**
@@ -671,15 +719,57 @@ export function rememberedChannels(dir, port) {
         const list = all[String(port)];
         if (!Array.isArray(list))
             return [];
-        return list.filter((one) => typeof one === "object" && one !== null &&
+        return list
+            .filter((one) => typeof one === "object" && one !== null &&
             typeof one.id === "string" &&
             typeof one.name === "string" &&
-            typeof one.source === "string");
+            typeof one.source === "string")
+            .map((one) => {
+            const kept = { id: one["id"], name: one["name"], source: one["source"] };
+            if (one["kind"] === "audio" || one["kind"] === "video")
+                kept.kind = one["kind"];
+            const codecs = one["codecs"];
+            if (codecs && typeof codecs === "object") {
+                const c = codecs;
+                if (typeof c["video"] === "string" && typeof c["audio"] === "string" && typeof c["container"] === "string") {
+                    kept.codecs = { video: c["video"], audio: c["audio"], container: c["container"] };
+                    if (typeof c["duration"] === "number" && Number.isFinite(c["duration"]))
+                        kept.codecs.duration = c["duration"];
+                }
+            }
+            if (typeof one["position"] === "number" && Number.isFinite(one["position"]) && one["position"] > 0)
+                kept.position = one["position"];
+            if (typeof one["live"] === "boolean")
+                kept.live = one["live"];
+            return kept;
+        });
     }
     catch {
         return [];
     }
 }
+/**
+ * What to write down about the channels a server is carrying: the pulled,
+ * kept ones, with what they turned out to be and where they have got to.
+ * The same answer everywhere one is added, kept, or taken off, so that no
+ * path forgets the position.
+ */
+export function rememberedNow(channels) {
+    return channels.list()
+        .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id))
+        .map((one) => {
+        const kept = { id: one.id, name: one.name, source: one.source };
+        if (one.kind)
+            kept.kind = one.kind;
+        if (one.codecs)
+            kept.codecs = one.codecs;
+        if (typeof one.live === "boolean")
+            kept.live = one.live;
+        if (!one.live && typeof one.position === "number" && one.position > 0)
+            kept.position = Math.floor(one.position);
+        return kept;
+    });
+}
 export function rememberChannels(dir, port, list) {
     let all = {};
     try {

package/dist/links.d.ts

@@ -3,6 +3,15 @@ export interface ResolvedLink {
     title: string;
     /** Where the bytes are: what ffmpeg is pointed at. */
     media: string;
+    /**
+     * The sound, when it comes separately. YouTube stopped offering a single
+     * stream with both picture and sound in it: every format is video alone
+     * or audio alone, and a player that insists on one file gets "Requested
+     * format is not available" for every link. So the two are asked for as a
+     * pair, and ffmpeg reads both and puts them together. "" when `media`
+     * already has the sound in it.
+     */
+    audio: string;
     /** Whether it is on now, which decides pacing and whether it can be saved. */
     live: boolean;
     /** Seconds, when known. */
@@ -41,6 +50,14 @@ export declare function directLink(url: string): ResolvedLink;
  * second ago. The user agent has its own flag; the rest go as one block.
  */
 export declare function inputArgsFor(headers: Record<string, string>): string[];
+/**
+ * How ffmpeg is asked to hand over a picture and a sound as one file, down a
+ * pipe. yt-dlp merges the two only into a file it can seek in, so a pair
+ * cannot go down its pipe; ffmpeg copies both into a fragmented MP4 -- or
+ * Matroska when the picture is not MP4, since a VP9 picture in an MP4 is a
+ * file few things open -- and writes as it goes.
+ */
+export declare function mergeDownloadArgs(link: ResolvedLink): string[];
 /** A file name for a download: the title, made safe, with the right ending. */
 export declare function fileNameFor(link: ResolvedLink, audioOnly: boolean): string;
 /** What a browser should call the bytes, from the file name's ending. */

package/dist/server.d.ts

@@ -20,6 +20,7 @@ import { Names } from "./names.ts";
 import { Certs } from "./certs.ts";
 import { type Throttle } from "@profullstack/throttle";
 import { type Notification } from "./notify.ts";
+import { type Codecs } from "./audio.ts";
 import { type Tools, type Track } from "./audio.ts";
 import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
 export declare const SERVE_BAND_COUNT = 24;
@@ -363,6 +364,11 @@ export declare function answerWith(response: ServerResponse, refused: Response):
  * curious people from becoming a room full of decoders.
  */
 export declare const MAX_ON_DEMAND = 4;
+/**
+ * How often where each film has got to is written down. A restart lands
+ * somewhere inside this, and REWIND covers the gap.
+ */
+export declare const REMEMBER_EVERY_MS = 15000;
 /**
  * Probe a source and start carrying it as a channel of its own.
  *
@@ -370,7 +376,17 @@ export declare const MAX_ON_DEMAND = 4;
  * ones back, so that both agree on what a source is encoded as. Null when
  * that channel id is already on.
  */
-export declare function pullChannel(channels: Channels, ffprobe: string[], id: string, name: string, source: string, input?: string[]): Promise<Channel | null>;
+/** What is already known about a source, so it need not be asked, or asked twice. */
+export interface KnownSource {
+    kind?: "audio" | "video";
+    codecs?: Codecs;
+    position?: number;
+    live?: boolean;
+}
+/** How many times a source that answers nothing is asked, and how far apart. */
+export declare const PROBE_TRIES = 3;
+export declare const PROBE_RETRY_MS = 1500;
+export declare function pullChannel(channels: Channels, ffprobe: string[], id: string, name: string, source: string, input?: string[], audio?: string, known?: KnownSource): Promise<Channel | null>;
 /**
  * A Netscape cookies file beside the state, if the operator has put one there.
  *

package/dist/server.js

@@ -19,7 +19,7 @@ import { readFileSync } from "node:fs";
 import { Connections } from "./connections.js";
 import { Broadcaster, DEFAULT_ENCODER, PRESETS, redact, } from "./broadcast.js";
 import { Ingest, normaliseFormat } from "./ingest.js";
-import { Channels, cleanId, generatedId, rememberChannels, rememberedChannels, } from "./channels.js";
+import { Channels, cleanId, generatedId, rememberChannels, rememberedChannels, rememberedNow, } from "./channels.js";
 import { RtmpListeners } from "./rtmp-in.js";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.js";
 import { anonymousHandle, Handles } from "./handles.js";
@@ -36,7 +36,7 @@ import { Directory, ENDED_TTL_MS, parseAnnouncement } from "./directory.js";
 import { PartyLine, telnyxSms } from "./partyline.js";
 import { HlsPackagers, withKey } from "./hls.js";
 import { DEFAULT_SITE as NICHEDB, Enricher, FIXTURE_TTL_MS } from "./enrich.js";
-import { contentTypeFor, downloadArgs, fileNameFor, inputArgsFor, linkChannelId, playableLink, resolveLink, saveFormat, } from "./links.js";
+import { contentTypeFor, downloadArgs, fileNameFor, inputArgsFor, linkChannelId, mergeDownloadArgs, playableLink, resolveLink, saveFormat, } from "./links.js";
 import { CALL_IN_NUMBER, OPT_IN_PATH, optInPage } from "./optin.js";
 import pg from "pg";
 import { Follows, phoneFrom } from "./follows.js";
@@ -763,21 +763,66 @@ export async function answerWith(response, refused) {
  */
 export const MAX_ON_DEMAND = 4;
 /**
- * Probe a source and start carrying it as a channel of its own.
- *
- * Shared by the request that puts one on and the boot that puts remembered
- * ones back, so that both agree on what a source is encoded as. Null when
- * that channel id is already on.
+ * How often where each film has got to is written down. A restart lands
+ * somewhere inside this, and REWIND covers the gap.
  */
-export async function pullChannel(channels, ffprobe, id, name, source, input = []) {
-    const codecs = await codecsOf({ ffmpeg: [], ffprobe, play: null }, source, input);
-    const kind = codecs.video === "" ? "audio" : "video";
+export const REMEMBER_EVERY_MS = 15_000;
+/** How many times a source that answers nothing is asked, and how far apart. */
+export const PROBE_TRIES = 3;
+export const PROBE_RETRY_MS = 1500;
+export async function pullChannel(channels, ffprobe, id, name, source, input = [], audio = "", known = {}) {
+    const tools = { ffmpeg: [], ffprobe, play: null };
+    const empty = (c) => c.video === "" && c.audio === "";
+    // A pair is probed as a pair: the picture's file has no sound in it, and
+    // asked alone it would read as a silent film. The sound's codec comes from
+    // the sound's file; the picture's, and the container, from the picture's.
+    const probe = async () => {
+        const [picture, sound] = await Promise.all([
+            codecsOf(tools, source, input),
+            audio ? codecsOf(tools, audio, input) : Promise.resolve(null),
+        ]);
+        return sound ? { ...picture, audio: sound.audio } : picture;
+    };
+    // Known already: a restart puts back what it wrote down and asks nobody.
+    // Otherwise ask, and ask again when the answer is nothing: a film on an
+    // IPTV panel allows one connection, and while the last ffmpeg's is still
+    // being counted a probe gets an error page and no streams. Nothing, read
+    // as "no picture", is how two films came back on the air as sound alone.
+    let codecs = known.codecs && !empty(known.codecs) ? known.codecs : { video: "", audio: "", container: "" };
+    let assumed = false;
+    if (empty(codecs)) {
+        for (let attempt = 0; attempt < PROBE_TRIES; attempt++) {
+            if (attempt > 0)
+                await new Promise((r) => setTimeout(r, PROBE_RETRY_MS));
+            codecs = await probe();
+            if (!empty(codecs))
+                break;
+        }
+        assumed = empty(codecs);
+    }
+    // A source that would not say is carried as what it was last time, or as
+    // video: a picture-less MP4 still plays, whereas a film as MP3 is a film
+    // with no picture until somebody notices.
+    const kind = codecs.video !== "" ? "video" : codecs.audio !== "" ? "audio" : (known.kind ?? "video");
+    if (assumed)
+        console.log(`  "${id}": the source would not say what it holds; carrying it as ${kind}.`);
+    // A film has a length and a place to go back to; a live source has neither.
+    const live = known.live ?? !((codecs.duration ?? 0) > 0);
     const encode = kind === "video"
-        ? videoArgs(codecs)
+        ? [
+            // Which streams from which input, when there are two: the picture
+            // from the first, the sound from the second. With one input ffmpeg
+            // picks for itself, as it always did.
+            ...(audio ? ["-map", "0:v:0", "-map", "1:a:0"] : []),
+            ...videoArgs(codecs),
+        ]
         // No picture in it, so none is invented: MP3 is the thing every browser
         // plays and the thing a listener can join halfway through.
         : ["-vn", "-c:a", "libmp3lame", "-b:a", "192k", "-f", "mp3"];
-    return channels.pull(id, name, source, encode, kind, true, undefined, input);
+    const channel = channels.pull(id, name, source, encode, kind, true, undefined, input, kind === "video" ? audio : "", { live, position: known.position ?? 0 });
+    if (channel && !assumed)
+        channel.info.codecs = codecs;
+    return channel;
 }
 /** What a link resolves to, kept so a download can be named without asking twice. */
 const links = new Map();
@@ -2284,11 +2329,7 @@ export function createHandler(engine, options) {
                     }
                 }
                 options.channels.keep(channelId);
-                if (options.rememberChannels) {
-                    options.rememberChannels(options.channels.list()
-                        .filter((one) => one.via === "pull" && one.source && !options.channels?.isEphemeral(one.id))
-                        .map((one) => ({ id: one.id, name: one.name, source: one.source })));
-                }
+                options.rememberChannels?.(rememberedNow(options.channels));
                 void options.live?.announce?.();
                 json(response, 200, { channel: channelId, name: entry.title, kind: entry.live ? "live" : "vod" });
                 return;
@@ -2387,7 +2428,7 @@ export function createHandler(engine, options) {
             }
             links.set(link, resolved);
             if (!options.channels.has(channelId)) {
-                const started = await pullChannel(options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media, inputArgsFor(resolved.headers));
+                const started = await pullChannel(options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media, inputArgsFor(resolved.headers), resolved.audio);
                 if (!started) {
                     json(response, 409, { error: "that link is already starting" });
                     return;
@@ -2430,11 +2471,14 @@ export function createHandler(engine, options) {
             // as the plain MP3 the site also offers, and ".m4a" on an MP3 is a
             // file nothing will open.
             const saved = await resolveLink(options.ytdlp, link, { cookies: options.cookies ?? "", format: saveFormat(audioOnly) });
-            const fileName = fileNameFor("error" in saved ? resolved : { ...resolved, ext: saved.ext || resolved.ext }, audioOnly);
-            const [command, ...prefix] = options.ytdlp;
-            const child = spawn(command, [...prefix, ...downloadArgs(link, audioOnly, options.cookies ?? "")], {
-                stdio: ["ignore", "pipe", "pipe"],
-            });
+            const chosen = "error" in saved ? resolved : { ...resolved, ext: saved.ext || resolved.ext, media: saved.media, audio: saved.audio, headers: saved.headers };
+            const fileName = fileNameFor(chosen, audioOnly);
+            // A picture and a sound kept apart by the site are put together here
+            // by ffmpeg, as they go: yt-dlp only merges into a file it can seek
+            // in, which a pipe is not. Anything else yt-dlp hands over whole.
+            const paired = !audioOnly && chosen.audio !== "";
+            const [command, ...prefix] = (paired ? (options.ffmpeg ?? ["ffmpeg"]) : options.ytdlp);
+            const child = spawn(command, [...prefix, ...(paired ? mergeDownloadArgs(chosen) : downloadArgs(link, audioOnly, options.cookies ?? ""))], { stdio: ["ignore", "pipe", "pipe"] });
             response.writeHead(200, {
                 "content-type": contentTypeFor(fileName),
                 "content-disposition": `attachment; filename="${fileName.replace(/["\\]/g, "")}"; filename*=UTF-8''${encodeURIComponent(fileName)}`,
@@ -2563,11 +2607,8 @@ export function createHandler(engine, options) {
                 const stopped = channels.stop(id);
                 // Taken off on purpose is forgotten on purpose: it must not come back
                 // at the next restart.
-                if (stopped && options.rememberChannels) {
-                    options.rememberChannels(channels.list()
-                        .filter((one) => one.via === "pull" && one.source)
-                        .map((one) => ({ id: one.id, name: one.name, source: one.source })));
-                }
+                if (stopped)
+                    options.rememberChannels?.(rememberedNow(channels));
                 json(response, stopped ? 200 : 404, { ok: stopped });
                 return;
             }
@@ -2608,11 +2649,7 @@ export function createHandler(engine, options) {
                     return;
                 }
                 channels.keep(id);
-                if (options.rememberChannels) {
-                    options.rememberChannels(channels.list()
-                        .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id))
-                        .map((one) => ({ id: one.id, name: one.name, source: one.source })));
-                }
+                options.rememberChannels?.(rememberedNow(channels));
                 void options.live?.announce?.();
                 json(response, 200, { ok: true });
                 return;
@@ -2665,14 +2702,7 @@ export function createHandler(engine, options) {
                     return;
                 }
                 // Written down, so a restart puts it back on the air.
-                if (options.rememberChannels) {
-                    options.rememberChannels([
-                        ...channels.list()
-                            .filter((one) => one.via === "pull" && one.source && one.id !== wanted)
-                            .map((one) => ({ id: one.id, name: one.name, source: one.source })),
-                        { id: wanted, name: called, source },
-                    ]);
-                }
+                options.rememberChannels?.(rememberedNow(channels));
                 json(response, 200, { ok: true, channel: channel.info });
                 return;
             }
@@ -3573,12 +3603,35 @@ export async function serve(argv, version = "0.1.0") {
     // every restart used to take CNN off the air until somebody noticed.
     const remembering = (list) => rememberChannels(stateDir(), options.port, list);
     for (const one of rememberedChannels(stateDir(), options.port)) {
-        console.log(`  Putting "${one.id}" (${one.name}) back on the air.`);
-        void pullChannel(channels, tools.ffprobe, one.id, one.name, one.source).then((channel) => {
+        const where = one.position && !one.live ? `, from ${Math.floor(one.position / 60)}m${Math.floor(one.position % 60)}s` : "";
+        console.log(`  Putting "${one.id}" (${one.name}) back on the air${where}.`);
+        // With what was written down about it: what it holds, so the source is
+        // not asked again, and where it had got to, so a film carries on.
+        void pullChannel(channels, tools.ffprobe, one.id, one.name, one.source, [], "", {
+            ...(one.kind ? { kind: one.kind } : {}),
+            ...(one.codecs ? { codecs: one.codecs } : {}),
+            ...(one.position !== undefined ? { position: one.position } : {}),
+            ...(one.live !== undefined ? { live: one.live } : {}),
+        }).then((channel) => {
             if (!channel)
                 console.log(`  "${one.id}" is already on.`);
         });
     }
+    // Where each film has got to, written down every so often, so a restart
+    // picks it up from about there rather than from the start. Only when it
+    // has changed: a server carrying nothing but live television writes
+    // nothing.
+    let lastRemembered = "";
+    setInterval(() => {
+        const now = rememberedNow(channels);
+        if (!now.some((one) => one.position !== undefined))
+            return;
+        const text = JSON.stringify(now);
+        if (text === lastRemembered)
+            return;
+        lastRemembered = text;
+        remembering(now);
+    }, REMEMBER_EVERY_MS).unref();
     // The m3u catalogs kept here: read from disk now, and any that were never
     // read are fetched in the background so browsing does not wait on a provider.
     const catalogs = new Catalogs(stateDir(), options.port);

package/package.json

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

package/src/audio.ts

@@ -391,6 +391,12 @@ export interface Codecs {
    * is a track no browser will play.
    */
   container: string;
+  /**
+   * How long it is, in seconds; 0 when it has no end, which is what tells a
+   * live channel from a film. A film has a place to go back to after a
+   * restart; a live channel is wherever it is now.
+   */
+  duration?: number;
 }
 
 /**
@@ -412,7 +418,7 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
         ...rest,
         "-v", "quiet",
         "-print_format", "json",
-        "-show_entries", "format=format_name:stream=codec_type,codec_name",
+        "-show_entries", "format=format_name,duration:stream=codec_type,codec_name",
         // Headers the source's site expects, for a link resolved by yt-dlp.
         ...input,
         path,
@@ -428,13 +434,17 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
       try {
         const parsed = JSON.parse(out) as {
           streams?: { codec_type?: string; codec_name?: string }[];
-          format?: { format_name?: string };
+          format?: { format_name?: string; duration?: string };
         };
         const streams = parsed.streams ?? [];
+        // 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);
         return done({
           video: streams.find((s) => s.codec_type === "video")?.codec_name ?? "",
           audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
           container: parsed.format?.format_name ?? "",
+          duration: Number.isFinite(seconds) && seconds > 0 ? seconds : 0,
         });
       } catch {
         return done(empty);

package/src/channels.ts

@@ -50,8 +50,33 @@ export interface ChannelInfo {
   error?: string;
   /** How many times the source has been dialled again since it started. */
   redials?: number;
+  /**
+   * For a pulled film: how far into it we are, in seconds, read off ffmpeg
+   * as it goes. This is what a restart and a redial go back to. A live
+   * source has no such place, and says so with `live`.
+   */
+  position?: number;
+  live?: boolean;
+  /** What the source turned out to hold, so a restart need not ask again. */
+  codecs?: { video: string; audio: string; container: string; duration?: number };
+}
+
+/** Where a pulled source is picked up from, and whether it can be at all. */
+export interface PullResume {
+  /** A live source is joined where it is now; a film is joined where it was. */
+  live: boolean;
+  /** Seconds into a film to start from. */
+  position: number;
 }
 
+/**
+ * How far back of the saved place a film is picked up from, in seconds. The
+ * place is written down every so often and a restart lands between two
+ * writes; a few seconds repeated is a hiccup, a few seconds missed is a
+ * line of dialogue.
+ */
+export const REWIND = 3;
+
 /** How long to wait before dialling a dropped source again. */
 export const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
@@ -219,30 +244,56 @@ export class Channel {
    * because you looked away, and a room where the picture depends on who is
    * in it is not a room anybody can be invited to.
    */
-  pull(source: string, encode: string[], paced = true, stall = STALL, input: string[] = []): void {
+  pull(
+    source: string,
+    encode: string[],
+    paced = true,
+    stall = STALL,
+    input: string[] = [],
+    audio = "",
+    resume: PullResume = { live: true, position: 0 },
+  ): void {
     this.stall = stall;
     if (this.info.kind === "video") this.fragments = new Fragments();
     const [command, ...prefix] = this.options.ffmpeg as [string, ...string[]];
     const remote = /^https?:\/\//i.test(source);
+    this.info.live = resume.live;
+    if (!resume.live) this.info.position = Math.max(0, resume.position);
+    // What every remote input is told: dial again when the CDN drops it, and
+    // give up on a socket that has gone quiet. Input options apply to the
+    // input that follows them, so a second input is told again.
+    const remoteArgs = remote
+      ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5", "-rw_timeout", String(stall * 1000)]
+      : [];
 
     const dial = (): void => {
       if (this.closing) return;
       this.stderr = "";
+      // Where to pick a film up from: a little before where it was, since
+      // the place was written down a moment ago and a moment of it twice is
+      // better than a moment of it missing. A live source is joined as is,
+      // and a film that has barely started is started.
+      const from = resume.live ? 0 : Math.max(0, Math.floor((this.info.position ?? 0) - REWIND));
+      const seek = from > 0 ? ["-ss", String(from)] : [];
       const child = spawn(
         command,
         [
           ...prefix,
           "-hide_banner",
           "-loglevel", "error",
+          // How far it has got, once a second, on a pipe of its own: this is
+          // what is written down for a restart and what a redial goes back
+          // to. Not stderr, which is for what went wrong.
+          "-progress", "pipe:3",
+          "-stats_period", "1",
           // A dropped source is normal over hours, and a channel that dies
           // the first time a CDN hiccups is not a channel anybody can rely
           // on. ffmpeg redials on its own before we have to.
-          ...(remote ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
           // A connection that stops answering is an error after this long,
-          // and an error is a thing the reconnect above knows what to do
-          // with. Without it a silent socket is waited on for ever. In
+          // and an error is a thing the reconnect knows what to do with.
+          // Without it a silent socket is waited on for ever. In
           // microseconds, as ffmpeg wants it.
-          ...(remote ? ["-rw_timeout", String(stall * 1000)] : []),
+          ...remoteArgs,
           // Real time, always. A file read as fast as the disk allows is an
           // hour of film in ninety seconds and a room that cannot be in it
           // together; a live source is already paced and loses nothing.
@@ -251,16 +302,36 @@ export class Channel {
           // 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", source,
+          // 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] : []),
           ...encode,
           "pipe:1",
         ],
-        { stdio: ["ignore", "pipe", "pipe"] },
+        { stdio: ["ignore", "pipe", "pipe", "pipe"] },
       );
 
       let sent = false;
       this.child = child;
       this.rearm(child);
+      // ffmpeg's progress: key=value lines, out_time_us being how much it
+      // has written, from where it was told to start. Read whole lines,
+      // since a chunk can end mid-number. Drained whatever it says, for
+      // the same reason stderr is.
+      let progress = "";
+      (child.stdio[3] as Readable | null)?.on("data", (chunk: Buffer) => {
+        progress = (progress + chunk.toString("utf8")).slice(-4000);
+        if (this.child !== child || resume.live) return;
+        const lines = progress.split("\n");
+        progress = lines.pop() ?? "";
+        for (const line of lines) {
+          const match = /^out_time_us=(\d+)/.exec(line.trim());
+          if (match) this.info.position = from + Number(match[1]) / 1e6;
+        }
+      });
+      (child.stdio[3] as Readable | null)?.on("error", () => undefined);
       child.stdout?.on("data", (chunk: Buffer) => {
         // An ffmpeg that was replaced can still have a chunk in the pipe.
         if (this.child !== child) return;
@@ -617,6 +688,8 @@ export class Channels {
     paced = true,
     stall = STALL,
     input: string[] = [],
+    audio = "",
+    resume: PullResume = { live: true, position: 0 },
   ): Channel | null {
     if (this.open.has(id)) return null;
     const channel = new Channel(
@@ -635,7 +708,7 @@ export class Channels {
       (gone) => this.open.delete(gone),
     );
     this.open.set(id, channel);
-    channel.pull(source, encode, paced, stall, input);
+    channel.pull(source, encode, paced, stall, input, audio, resume);
     return channel;
   }
 
@@ -749,6 +822,19 @@ export interface RememberedChannel {
   id: string;
   name: string;
   source: string;
+  /**
+   * What it was, so a restart need not ask the source again. Asking is not
+   * free: a film on an IPTV panel allows one connection, and while the old
+   * ffmpeg's is still being counted a probe of it gets an error page and no
+   * streams -- which read as "no picture", and two films came back on the
+   * air as sound alone.
+   */
+  kind?: "audio" | "video";
+  codecs?: { video: string; audio: string; container: string; duration?: number };
+  /** Where a film had got to, in seconds, so it picks up there. */
+  position?: number;
+  /** A live source has nowhere to pick up from. */
+  live?: boolean;
 }
 
 const REMEMBERED = "channels.json";
@@ -758,18 +844,53 @@ export function rememberedChannels(dir: string, port: number): RememberedChannel
     const all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8")) as Record<string, unknown>;
     const list = all[String(port)];
     if (!Array.isArray(list)) return [];
-    return list.filter(
-      (one): one is RememberedChannel =>
-        typeof one === "object" && one !== null &&
-        typeof (one as RememberedChannel).id === "string" &&
-        typeof (one as RememberedChannel).name === "string" &&
-        typeof (one as RememberedChannel).source === "string",
-    );
+    return list
+      .filter(
+        (one): one is Record<string, unknown> =>
+          typeof one === "object" && one !== null &&
+          typeof (one as RememberedChannel).id === "string" &&
+          typeof (one as RememberedChannel).name === "string" &&
+          typeof (one as RememberedChannel).source === "string",
+      )
+      .map((one) => {
+        const kept: RememberedChannel = { id: one["id"] as string, name: one["name"] as string, source: one["source"] as string };
+        if (one["kind"] === "audio" || one["kind"] === "video") kept.kind = one["kind"];
+        const codecs = one["codecs"];
+        if (codecs && typeof codecs === "object") {
+          const c = codecs as Record<string, unknown>;
+          if (typeof c["video"] === "string" && typeof c["audio"] === "string" && typeof c["container"] === "string") {
+            kept.codecs = { video: c["video"], audio: c["audio"], container: c["container"] };
+            if (typeof c["duration"] === "number" && Number.isFinite(c["duration"])) kept.codecs.duration = c["duration"];
+          }
+        }
+        if (typeof one["position"] === "number" && Number.isFinite(one["position"]) && one["position"] > 0) kept.position = one["position"];
+        if (typeof one["live"] === "boolean") kept.live = one["live"];
+        return kept;
+      });
   } catch {
     return [];
   }
 }
 
+/**
+ * What to write down about the channels a server is carrying: the pulled,
+ * kept ones, with what they turned out to be and where they have got to.
+ * The same answer everywhere one is added, kept, or taken off, so that no
+ * path forgets the position.
+ */
+export function rememberedNow(channels: Channels): RememberedChannel[] {
+  return channels.list()
+    .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id))
+    .map((one) => {
+      const kept: RememberedChannel = { id: one.id, name: one.name, source: one.source as string };
+      if (one.kind) kept.kind = one.kind;
+      if (one.codecs) kept.codecs = one.codecs;
+      if (typeof one.live === "boolean") kept.live = one.live;
+      if (!one.live && typeof one.position === "number" && one.position > 0) kept.position = Math.floor(one.position);
+      return kept;
+    });
+}
+
 export function rememberChannels(dir: string, port: number, list: RememberedChannel[]): void {
   let all: Record<string, unknown> = {};
   try {

package/src/server.ts

@@ -27,7 +27,7 @@ import {
 } from "./broadcast.ts";
 import { Ingest, normaliseFormat } from "./ingest.ts";
 import {
-  Channels, cleanId, generatedId, rememberChannels, rememberedChannels,
+  Channels, cleanId, generatedId, rememberChannels, rememberedChannels, rememberedNow,
   type Channel, type RememberedChannel,
 } from "./channels.ts";
 import { RtmpListeners } from "./rtmp-in.ts";
@@ -54,7 +54,8 @@ import { PartyLine, telnyxSms } from "./partyline.ts";
 import { HlsPackagers, withKey } from "./hls.ts";
 import { DEFAULT_SITE as NICHEDB, Enricher, type EnrichKind, FIXTURE_TTL_MS } from "./enrich.ts";
 import {
-  contentTypeFor, downloadArgs, fileNameFor, inputArgsFor, linkChannelId, playableLink, resolveLink, saveFormat,
+  contentTypeFor, downloadArgs, fileNameFor, inputArgsFor, linkChannelId, mergeDownloadArgs, playableLink, resolveLink,
+  saveFormat,
   type ResolvedLink,
 } from "./links.ts";
 import { CALL_IN_NUMBER, OPT_IN_PATH, optInPage } from "./optin.ts";
@@ -80,7 +81,7 @@ import {
   paywallFromEnv,
 } from "./paywall.ts";
 import { isRemote, playsInBrowser, sourceLabel } from "./sources.ts";
-import { codecsOf, probeAsync, videoArgs } from "./audio.ts";
+import { codecsOf, probeAsync, videoArgs, type Codecs } from "./audio.ts";
 import {
   allowedForListening,
   elevate,
@@ -971,6 +972,12 @@ export async function answerWith(response: ServerResponse, refused: Response): P
  */
 export const MAX_ON_DEMAND = 4;
 
+/**
+ * How often where each film has got to is written down. A restart lands
+ * somewhere inside this, and REWIND covers the gap.
+ */
+export const REMEMBER_EVERY_MS = 15_000;
+
 /**
  * Probe a source and start carrying it as a channel of its own.
  *
@@ -978,6 +985,18 @@ export const MAX_ON_DEMAND = 4;
  * ones back, so that both agree on what a source is encoded as. Null when
  * that channel id is already on.
  */
+/** What is already known about a source, so it need not be asked, or asked twice. */
+export interface KnownSource {
+  kind?: "audio" | "video";
+  codecs?: Codecs;
+  position?: number;
+  live?: boolean;
+}
+
+/** How many times a source that answers nothing is asked, and how far apart. */
+export const PROBE_TRIES = 3;
+export const PROBE_RETRY_MS = 1500;
+
 export async function pullChannel(
   channels: Channels,
   ffprobe: string[],
@@ -985,15 +1004,60 @@ export async function pullChannel(
   name: string,
   source: string,
   input: string[] = [],
+  audio = "",
+  known: KnownSource = {},
 ): Promise<Channel | null> {
-  const codecs = await codecsOf({ ffmpeg: [], ffprobe, play: null }, source, input);
-  const kind = codecs.video === "" ? "audio" : "video";
+  const tools = { ffmpeg: [], ffprobe, play: null };
+  const empty = (c: Codecs): boolean => c.video === "" && c.audio === "";
+  // A pair is probed as a pair: the picture's file has no sound in it, and
+  // asked alone it would read as a silent film. The sound's codec comes from
+  // the sound's file; the picture's, and the container, from the picture's.
+  const probe = async (): Promise<Codecs> => {
+    const [picture, sound] = await Promise.all([
+      codecsOf(tools, source, input),
+      audio ? codecsOf(tools, audio, input) : Promise.resolve(null),
+    ]);
+    return sound ? { ...picture, audio: sound.audio } : picture;
+  };
+  // Known already: a restart puts back what it wrote down and asks nobody.
+  // Otherwise ask, and ask again when the answer is nothing: a film on an
+  // IPTV panel allows one connection, and while the last ffmpeg's is still
+  // being counted a probe gets an error page and no streams. Nothing, read
+  // as "no picture", is how two films came back on the air as sound alone.
+  let codecs: Codecs = known.codecs && !empty(known.codecs) ? known.codecs : { video: "", audio: "", container: "" };
+  let assumed = false;
+  if (empty(codecs)) {
+    for (let attempt = 0; attempt < PROBE_TRIES; attempt++) {
+      if (attempt > 0) await new Promise((r) => setTimeout(r, PROBE_RETRY_MS));
+      codecs = await probe();
+      if (!empty(codecs)) break;
+    }
+    assumed = empty(codecs);
+  }
+  // A source that would not say is carried as what it was last time, or as
+  // video: a picture-less MP4 still plays, whereas a film as MP3 is a film
+  // with no picture until somebody notices.
+  const kind = codecs.video !== "" ? "video" : codecs.audio !== "" ? "audio" : (known.kind ?? "video");
+  if (assumed) console.log(`  "${id}": the source would not say what it holds; carrying it as ${kind}.`);
+  // A film has a length and a place to go back to; a live source has neither.
+  const live = known.live ?? !((codecs.duration ?? 0) > 0);
   const encode = kind === "video"
-    ? videoArgs(codecs)
+    ? [
+        // Which streams from which input, when there are two: the picture
+        // from the first, the sound from the second. With one input ffmpeg
+        // picks for itself, as it always did.
+        ...(audio ? ["-map", "0:v:0", "-map", "1:a:0"] : []),
+        ...videoArgs(codecs),
+      ]
     // No picture in it, so none is invented: MP3 is the thing every browser
     // plays and the thing a listener can join halfway through.
     : ["-vn", "-c:a", "libmp3lame", "-b:a", "192k", "-f", "mp3"];
-  return channels.pull(id, name, source, encode, kind, true, undefined, input);
+  const channel = channels.pull(
+    id, name, source, encode, kind, true, undefined, input, kind === "video" ? audio : "",
+    { live, position: known.position ?? 0 },
+  );
+  if (channel && !assumed) channel.info.codecs = codecs;
+  return channel;
 }
 
 /** What a link resolves to, kept so a download can be named without asking twice. */
@@ -2754,13 +2818,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           }
         }
         options.channels.keep(channelId);
-        if (options.rememberChannels) {
-          options.rememberChannels(
-            options.channels.list()
-              .filter((one) => one.via === "pull" && one.source && !options.channels?.isEphemeral(one.id))
-              .map((one) => ({ id: one.id, name: one.name, source: one.source as string })),
-          );
-        }
+        options.rememberChannels?.(rememberedNow(options.channels));
         void options.live?.announce?.();
         json(response, 200, { channel: channelId, name: entry.title, kind: entry.live ? "live" : "vod" });
         return;
@@ -2863,7 +2921,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       if (!options.channels.has(channelId)) {
         const started = await pullChannel(
           options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media,
-          inputArgsFor(resolved.headers),
+          inputArgsFor(resolved.headers), resolved.audio,
         );
         if (!started) {
           json(response, 409, { error: "that link is already starting" });
@@ -2908,11 +2966,18 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       // as the plain MP3 the site also offers, and ".m4a" on an MP3 is a
       // file nothing will open.
       const saved = await resolveLink(options.ytdlp, link, { cookies: options.cookies ?? "", format: saveFormat(audioOnly) });
-      const fileName = fileNameFor("error" in saved ? resolved : { ...resolved, ext: saved.ext || resolved.ext }, audioOnly);
-      const [command, ...prefix] = options.ytdlp as [string, ...string[]];
-      const child = spawn(command, [...prefix, ...downloadArgs(link, audioOnly, options.cookies ?? "")], {
-        stdio: ["ignore", "pipe", "pipe"],
-      });
+      const chosen = "error" in saved ? resolved : { ...resolved, ext: saved.ext || resolved.ext, media: saved.media, audio: saved.audio, headers: saved.headers };
+      const fileName = fileNameFor(chosen, audioOnly);
+      // A picture and a sound kept apart by the site are put together here
+      // by ffmpeg, as they go: yt-dlp only merges into a file it can seek
+      // in, which a pipe is not. Anything else yt-dlp hands over whole.
+      const paired = !audioOnly && chosen.audio !== "";
+      const [command, ...prefix] = (paired ? (options.ffmpeg ?? ["ffmpeg"]) : options.ytdlp) as [string, ...string[]];
+      const child = spawn(
+        command,
+        [...prefix, ...(paired ? mergeDownloadArgs(chosen) : downloadArgs(link, audioOnly, options.cookies ?? ""))],
+        { stdio: ["ignore", "pipe", "pipe"] },
+      );
       response.writeHead(200, {
         "content-type": contentTypeFor(fileName),
         "content-disposition": `attachment; filename="${fileName.replace(/["\\]/g, "")}"; filename*=UTF-8''${encodeURIComponent(fileName)}`,
@@ -3043,13 +3108,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         const stopped = channels.stop(id);
         // Taken off on purpose is forgotten on purpose: it must not come back
         // at the next restart.
-        if (stopped && options.rememberChannels) {
-          options.rememberChannels(
-            channels.list()
-              .filter((one) => one.via === "pull" && one.source)
-              .map((one) => ({ id: one.id, name: one.name, source: one.source as string })),
-          );
-        }
+        if (stopped) options.rememberChannels?.(rememberedNow(channels));
         json(response, stopped ? 200 : 404, { ok: stopped });
         return;
       }
@@ -3093,13 +3152,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           return;
         }
         channels.keep(id);
-        if (options.rememberChannels) {
-          options.rememberChannels(
-            channels.list()
-              .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id))
-              .map((one) => ({ id: one.id, name: one.name, source: one.source as string })),
-          );
-        }
+        options.rememberChannels?.(rememberedNow(channels));
         void options.live?.announce?.();
         json(response, 200, { ok: true });
         return;
@@ -3155,14 +3208,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           return;
         }
         // Written down, so a restart puts it back on the air.
-        if (options.rememberChannels) {
-          options.rememberChannels([
-            ...channels.list()
-              .filter((one) => one.via === "pull" && one.source && one.id !== wanted)
-              .map((one) => ({ id: one.id, name: one.name, source: one.source as string })),
-            { id: wanted, name: called, source },
-          ]);
-        }
+        options.rememberChannels?.(rememberedNow(channels));
         json(response, 200, { ok: true, channel: channel.info });
         return;
       }
@@ -4125,11 +4171,32 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   // every restart used to take CNN off the air until somebody noticed.
   const remembering = (list: RememberedChannel[]): void => rememberChannels(stateDir(), options.port, list);
   for (const one of rememberedChannels(stateDir(), options.port)) {
-    console.log(`  Putting "${one.id}" (${one.name}) back on the air.`);
-    void pullChannel(channels, tools.ffprobe, one.id, one.name, one.source).then((channel) => {
+    const where = one.position && !one.live ? `, from ${Math.floor(one.position / 60)}m${Math.floor(one.position % 60)}s` : "";
+    console.log(`  Putting "${one.id}" (${one.name}) back on the air${where}.`);
+    // With what was written down about it: what it holds, so the source is
+    // not asked again, and where it had got to, so a film carries on.
+    void pullChannel(channels, tools.ffprobe, one.id, one.name, one.source, [], "", {
+      ...(one.kind ? { kind: one.kind } : {}),
+      ...(one.codecs ? { codecs: one.codecs } : {}),
+      ...(one.position !== undefined ? { position: one.position } : {}),
+      ...(one.live !== undefined ? { live: one.live } : {}),
+    }).then((channel) => {
       if (!channel) console.log(`  "${one.id}" is already on.`);
     });
   }
+  // Where each film has got to, written down every so often, so a restart
+  // picks it up from about there rather than from the start. Only when it
+  // has changed: a server carrying nothing but live television writes
+  // nothing.
+  let lastRemembered = "";
+  setInterval(() => {
+    const now = rememberedNow(channels);
+    if (!now.some((one) => one.position !== undefined)) return;
+    const text = JSON.stringify(now);
+    if (text === lastRemembered) return;
+    lastRemembered = text;
+    remembering(now);
+  }, REMEMBER_EVERY_MS).unref();
 
   // The m3u catalogs kept here: read from disk now, and any that were never
   // read are fetched in the background so browsing does not wait on a provider.

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1789114815909";
+const CACHE = "nixamp-1789118956283";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",