nixamp 0.13.1 → 0.14.1

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[], audio?: 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[], audio?: 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,12 +175,15 @@ 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 = [], audio = "") {
+    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.
@@ -184,10 +194,21 @@ export class Channel {
             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.
@@ -204,16 +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, "-i", audio] : []),
+                ...(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)
@@ -568,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 = [], audio = "") {
+    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({
@@ -583,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, audio);
+        channel.pull(source, encode, paced, stall, input, audio, resume);
         return channel;
     }
     /**
@@ -679,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/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[], audio?: 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";
@@ -763,23 +763,51 @@ 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 = [], audio = "") {
+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 [picture, sound] = await Promise.all([
-        codecsOf(tools, source, input),
-        audio ? codecsOf(tools, audio, input) : Promise.resolve(null),
-    ]);
-    const codecs = sound ? { ...picture, audio: sound.audio } : picture;
-    const kind = codecs.video === "" ? "audio" : "video";
+    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"
         ? [
             // Which streams from which input, when there are two: the picture
@@ -791,7 +819,10 @@ export async function pullChannel(channels, ffprobe, id, name, source, input = [
         // 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, kind === "video" ? audio : "");
+    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();
@@ -2298,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;
@@ -2580,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;
             }
@@ -2625,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;
@@ -2682,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;
             }
@@ -3590,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.1",
+  "version": "0.14.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

@@ -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);