nixamp 0.23.6 → 0.24.0

package/src/captions.ts

@@ -20,10 +20,21 @@
  * A quiet window -- the gap between songs, a picture with no talking -- is
  * never sent. Most of a music channel is that, and hearing it costs the
  * same as hearing speech.
+ *
+ * What is heard is kept (see transcripts.ts): every line goes to nixamp.com
+ * under the identity of what the channel is playing, as seconds into it.
+ * When a captioner starts it asks for what is already known, and a window
+ * whose moment the store has been through is read out of it instead of
+ * heard. A film captioned once is captioned by nobody again; a live is
+ * kept as the broadcast it was. And a viewer may ask for the lines in
+ * another language: each heard line is translated once, on nixamp.com,
+ * handed to whoever wanted that language, and kept beside the original.
  */
 import { spawn } from "node:child_process";
 import type { Listener } from "./channels.ts";
 import { RATE } from "./speech.ts";
+import { fetchTranscript, keepLines, translateTexts } from "./transcript-client.ts";
+import { covered, lineAt, transcriptIdOf, type TranscriptLine } from "./transcripts.ts";
 
 export interface CaptionLine {
   /** The channel's id. */
@@ -32,6 +43,10 @@ export interface CaptionLine {
   at: number;
   until: number;
   text: string;
+  /** The language of the words, as heard or as translated into; absent when nobody said. */
+  language?: string;
+  /** What was heard, when this line is a translation of it. */
+  original?: string;
 }
 
 /** What turns a channel's bytes into 16 kHz mono 16-bit PCM. ffmpeg, or a test's stand-in. */
@@ -40,6 +55,22 @@ export interface Decoder {
   end(): void;
 }
 
+/**
+ * What a channel is playing, for the store: its identity, and how the
+ * sound a new listener gets maps onto seconds of it.
+ */
+export interface ChannelMedia {
+  /** The media identity, as transcripts.ts spells one. */
+  media: string;
+  title: string;
+  /** Seconds into the media at this moment, for a film; absent for anything live. */
+  position?: number;
+  /** When the channel began, wall clock, ms. A live's seconds count from here. */
+  startedAt: number;
+  /** How many seconds behind the live edge a new listener's sound starts. */
+  backlog: number;
+}
+
 export interface CaptionsOptions {
   /** A listener on a channel, or null when there is no such channel. */
   listen: (id: string, listener: Listener) => (() => void) | null;
@@ -49,10 +80,14 @@ export interface CaptionsOptions {
   fetcher?: typeof fetch;
   /** How bytes become PCM. The default spawns ffmpeg; the tests hand in something quieter. */
   decoder?: (onPcm: (pcm: Buffer) => void, onEnd: () => void) => Decoder;
+  /** What a channel is playing, for the store. Null, or absent, means the lines are not kept. */
+  mediaOf?: (id: string) => ChannelMedia | null;
   now?: () => number;
   onEvent?: (message: string) => void;
   windowMs?: number;
   idleMs?: number;
+  /** How often heard lines go to the store. */
+  flushMs?: number;
 }
 
 export const WINDOW_MS = 5000;
@@ -63,6 +98,10 @@ export const IDLE_MS = 60_000;
 export const QUIET = 0.004;
 /** Windows waiting on the ear at once. Past this the sound is dropped, not queued: late words are worse than none. */
 export const IN_FLIGHT = 2;
+/** Heard lines wait this long, at most, before they are kept. */
+export const FLUSH_MS = 20_000;
+/** Or this many. */
+export const FLUSH_LINES = 12;
 
 /**
  * The ffmpeg arguments: whatever arrives on stdin, as PCM on stdout, with
@@ -148,13 +187,52 @@ export function wavAround(pcm: Buffer, rate = RATE): Buffer {
   return Buffer.concat([header, pcm]);
 }
 
+/**
+ * Seconds into the media that a window covers. A film is paced in real
+ * time from a known position, so a new listener's first byte is that
+ * position less the backlog it was handed, and every window after it is
+ * one window further on. Anything live counts from when the channel
+ * began, in wall-clock time.
+ */
+export function mediaSpan(media: ChannelMedia, windowIndex: number, windowSeconds: number, at: number, until: number): { start: number; end: number } {
+  if (typeof media.position === "number") {
+    const join = Math.max(0, media.position - media.backlog);
+    return { start: round(join + windowIndex * windowSeconds), end: round(join + (windowIndex + 1) * windowSeconds) };
+  }
+  return { start: round(Math.max(0, (at - media.startedAt) / 1000)), end: round(Math.max(0, (until - media.startedAt) / 1000)) };
+}
+
+function round(seconds: number): number {
+  return Math.round(seconds * 1000) / 1000;
+}
+
+export { lineAt };
+
 type Subscriber = (line: CaptionLine) => void;
 
+export interface CaptionStatus {
+  on: boolean;
+  lines: number;
+  error: string;
+  /** The language heard, when known. */
+  language: string;
+  /** How many lines the store already had for this media when the captioner began. */
+  known: number;
+  /** The languages lines are being given in besides the original. */
+  languages: string[];
+}
+
 class Captioner {
+  /** The lines as heard, oldest first. */
   readonly lines: CaptionLine[] = [];
-  readonly subscribers = new Set<Subscriber>();
+  /** The lines in each other language somebody asked for. */
+  readonly linesBy = new Map<string, CaptionLine[]>();
+  readonly subscribers = new Map<Subscriber, string>();
   /** The last thing that went wrong, for whoever asks why there are no lines. */
   error = "";
+  /** What the ear says the sound is in, or the store said it was; "" until one of them has. */
+  language = "";
+  private model = "";
   private decoder: Decoder | null = null;
   private detach: (() => void) | null = null;
   private idle: ReturnType<typeof setTimeout> | null = null;
@@ -163,17 +241,41 @@ class Captioner {
   private inFlight = 0;
   private stopped = false;
   private complainedAt = 0;
+  private windows = 0;
+  /** What the channel is playing, when the store is to be told. */
+  private readonly media: ChannelMedia | null;
+  private readonly transcriptId: string | null;
+  /** What the store had, by language ("" for the original), and which stored moments have been read out. */
+  private readonly known = new Map<string, TranscriptLine[]>();
+  private readonly readOut = new Set<number>();
+  private readonly asked = new Set<string>();
+  /** Lines heard or translated here and not yet kept, by language. */
+  private readonly unsaved = new Map<string, TranscriptLine[]>();
+  private flush: ReturnType<typeof setTimeout> | null = null;
+  /** Translations in order, per language: a slow one must not overtake the next. */
+  private readonly chains = new Map<string, Promise<void>>();
 
   constructor(
     readonly id: string,
     private readonly options: CaptionsOptions,
     private readonly onStop: () => void,
-  ) {}
+  ) {
+    this.media = options.mediaOf?.(id) ?? null;
+    this.transcriptId = this.media ? transcriptIdOf(this.media.media) : null;
+  }
 
   private get windowBytes(): number {
     return Math.round(((this.options.windowMs ?? WINDOW_MS) / 1000) * RATE) * 2;
   }
 
+  private get windowSeconds(): number {
+    return (this.options.windowMs ?? WINDOW_MS) / 1000;
+  }
+
+  private now(): number {
+    return (this.options.now ?? Date.now)();
+  }
+
   start(): boolean {
     const make = this.options.decoder ?? ((onPcm, onEnd) => ffmpegDecoder(this.options.ffmpeg, onPcm, onEnd));
     this.decoder = make((pcm) => this.onPcm(pcm), () => this.stop());
@@ -185,9 +287,29 @@ class Captioner {
       this.stop();
       return false;
     }
+    void this.consult("");
     return true;
   }
 
+  /** Ask the store what it already knows of this media in a language, once. */
+  private async consult(language: string): Promise<void> {
+    if (!this.transcriptId || this.asked.has(language)) return;
+    this.asked.add(language);
+    const session = this.options.session();
+    if (session === null) return;
+    const got = await fetchTranscript(session, this.transcriptId, language, this.options.fetcher ?? fetch);
+    if (this.stopped) return;
+    if (!got.ok) {
+      if (got.status !== 404) this.complain(`the store did not answer: ${got.error}`);
+      return;
+    }
+    this.known.set(language, got.body.lines);
+    if (language === "" && this.language === "" && got.body.language) this.language = got.body.language;
+    if (got.body.lines.length > 0) {
+      this.options.onEvent?.(`captions for "${this.id}": the store knows ${got.body.lines.length} lines of this${language ? ` in ${language}` : ""}`);
+    }
+  }
+
   private onPcm(pcm: Buffer): void {
     if (this.stopped) return;
     this.pending.push(pcm);
@@ -199,13 +321,29 @@ class Captioner {
       const rest = all.subarray(size);
       this.pending = rest.length > 0 ? [Buffer.from(rest)] : [];
       this.pendingBytes = rest.length;
-      const until = (this.options.now ?? Date.now)();
-      void this.hear(Buffer.from(window), until - (this.options.windowMs ?? WINDOW_MS), until);
+      const until = this.now();
+      const index = this.windows;
+      this.windows += 1;
+      void this.hear(Buffer.from(window), until - (this.options.windowMs ?? WINDOW_MS), until, index);
     }
   }
 
-  private async hear(pcm: Buffer, at: number, until: number): Promise<void> {
+  private async hear(pcm: Buffer, at: number, until: number, index: number): Promise<void> {
     if (isQuiet(pcm)) return;
+    const span = this.media ? mediaSpan(this.media, index, this.windowSeconds, at, until) : null;
+    if (span) {
+      const stored = covered(this.known.get("") ?? [], span.start, span.end);
+      if (stored.length > 0) {
+        // The store has been through this moment: read it out, and let the ear rest.
+        for (const line of stored) {
+          if (this.readOut.has(line.start)) continue;
+          this.readOut.add(line.start);
+          const lineAt = at + (line.start - span.start) * 1000;
+          this.emit({ channel: this.id, at: lineAt, until: lineAt + (line.end - line.start) * 1000, text: line.text, ...(this.language ? { language: this.language } : {}) }, line.start);
+        }
+        return;
+      }
+    }
     if (this.inFlight >= IN_FLIGHT) return;
     const session = this.options.session();
     if (session === null) {
@@ -215,12 +353,14 @@ class Captioner {
     this.inFlight += 1;
     try {
       const wav = wavAround(pcm);
-      const response = await (this.options.fetcher ?? fetch)(`${session.site.replace(/\/+$/, "")}/api/v1/speech/transcribe`, {
+      const url = new URL(`${session.site.replace(/\/+$/, "")}/api/v1/speech/transcribe`);
+      if (this.language) url.searchParams.set("language", this.language);
+      const response = await (this.options.fetcher ?? fetch)(url.toString(), {
         method: "POST",
         headers: { authorization: `Bearer ${session.token}`, "content-type": "audio/wav" },
         body: new Blob([wav.buffer.slice(wav.byteOffset, wav.byteOffset + wav.byteLength) as ArrayBuffer]),
       });
-      const body = (await response.json().catch(() => ({}))) as { text?: string; error?: string };
+      const body = (await response.json().catch(() => ({}))) as { text?: string; language?: string; model?: string; error?: string };
       if (!response.ok) {
         this.complain(body.error ?? `nixamp.com answered ${response.status}`);
         return;
@@ -228,16 +368,11 @@ class Captioner {
       const text = (body.text ?? "").trim();
       if (text === "" || this.stopped) return;
       this.error = "";
-      const line: CaptionLine = { channel: this.id, at, until, text };
-      this.lines.push(line);
-      while (this.lines.length > KEEP) this.lines.shift();
-      for (const subscriber of this.subscribers) {
-        try {
-          subscriber(line);
-        } catch {
-          // A listener that throws is not this channel's problem.
-        }
-      }
+      if (body.language && this.language === "") this.language = body.language;
+      if (body.model) this.model = body.model;
+      const line: CaptionLine = { channel: this.id, at, until, text, ...(this.language ? { language: this.language } : {}) };
+      this.emit(line, span?.start ?? null);
+      if (span) this.keep("", { start: span.start, end: span.end, text });
     } catch (error) {
       this.complain(`could not reach the ear: ${(error as Error).message}`);
     } finally {
@@ -245,17 +380,112 @@ class Captioner {
     }
   }
 
+  /** A line as heard, to whoever wants the original, and translated to whoever wants another language. */
+  private emit(line: CaptionLine, mediaStart: number | null): void {
+    this.lines.push(line);
+    while (this.lines.length > KEEP) this.lines.shift();
+    for (const [subscriber, language] of this.subscribers) {
+      if (language === "" || language === this.language) this.tell(subscriber, line);
+    }
+    for (const language of this.wanted()) this.translated(language, line, mediaStart);
+  }
+
+  private tell(subscriber: Subscriber, line: CaptionLine): void {
+    try {
+      subscriber(line);
+    } catch {
+      // A listener that throws is not this channel's problem.
+    }
+  }
+
+  /** The languages somebody wants besides the one being heard. */
+  private wanted(): Set<string> {
+    const languages = new Set<string>();
+    for (const language of this.subscribers.values()) if (language !== "" && language !== this.language) languages.add(language);
+    return languages;
+  }
+
+  /** The line in another language: from the store when it has been through this moment, from nixamp.com otherwise. */
+  private translated(language: string, line: CaptionLine, mediaStart: number | null): void {
+    const chain = (this.chains.get(language) ?? Promise.resolve()).then(async () => {
+      if (this.stopped) return;
+      let text = "";
+      const stored = mediaStart === null ? null : lineAt(this.known.get(language) ?? [], mediaStart);
+      if (stored) {
+        text = stored.text;
+      } else {
+        const session = this.options.session();
+        if (session === null) return;
+        const got = await translateTexts(session, [line.text], this.language, language, this.options.fetcher ?? fetch);
+        if (!got.ok) {
+          this.complain(`could not translate to ${language}: ${got.error}`);
+          return;
+        }
+        text = (got.body.texts[0] ?? "").trim();
+        if (text === "") return;
+        if (mediaStart !== null) this.keep(language, { start: mediaStart, end: round(mediaStart + (line.until - line.at) / 1000), text });
+      }
+      if (this.stopped) return;
+      const said: CaptionLine = { ...line, text, language, original: line.text };
+      const lines = this.linesBy.get(language) ?? [];
+      lines.push(said);
+      while (lines.length > KEEP) lines.shift();
+      this.linesBy.set(language, lines);
+      for (const [subscriber, wanted] of this.subscribers) if (wanted === language) this.tell(subscriber, said);
+    });
+    this.chains.set(language, chain.catch(() => undefined));
+  }
+
+  /** A line for the store, kept with the others of its language until the next flush. */
+  private keep(language: string, line: TranscriptLine): void {
+    if (!this.media) return;
+    const lines = this.unsaved.get(language) ?? [];
+    lines.push(line);
+    this.unsaved.set(language, lines);
+    if (lines.length >= FLUSH_LINES) {
+      void this.flushNow();
+      return;
+    }
+    if (this.flush === null) {
+      this.flush = setTimeout(() => void this.flushNow(), this.options.flushMs ?? FLUSH_MS);
+      this.flush.unref?.();
+    }
+  }
+
+  /** Everything not yet kept, to the store. Never throws; a store that is away costs nothing but the keeping. */
+  private async flushNow(): Promise<void> {
+    if (this.flush) clearTimeout(this.flush);
+    this.flush = null;
+    if (!this.media || !this.transcriptId) return;
+    const session = this.options.session();
+    if (session === null) return;
+    const batches = [...this.unsaved.entries()].filter(([, lines]) => lines.length > 0);
+    this.unsaved.clear();
+    for (const [language, lines] of batches) {
+      const got = await keepLines(session, this.transcriptId, {
+        media: this.media.media,
+        title: this.media.title,
+        language: language === "" ? this.language : language,
+        ...(language === "" ? {} : { translatedFrom: this.language }),
+        ...(this.model ? { model: this.model } : {}),
+        lines,
+      }, this.options.fetcher ?? fetch);
+      if (!got.ok) this.complain(`the store did not keep ${lines.length} lines: ${got.error}`);
+    }
+  }
+
   /** Said once a minute at most: a broken ear would otherwise say so twelve times a minute. */
   private complain(message: string): void {
     this.error = message;
-    const now = (this.options.now ?? Date.now)();
+    const now = this.now();
     if (now - this.complainedAt < 60_000) return;
     this.complainedAt = now;
     this.options.onEvent?.(`captions for "${this.id}": ${message}`);
   }
 
-  subscribe(subscriber: Subscriber): () => void {
-    this.subscribers.add(subscriber);
+  subscribe(subscriber: Subscriber, language = ""): () => void {
+    this.subscribers.set(subscriber, language);
+    if (language !== "") void this.consult(language);
     if (this.idle) clearTimeout(this.idle);
     this.idle = null;
     return () => {
@@ -269,6 +499,22 @@ class Captioner {
     };
   }
 
+  recent(after: number, language = ""): CaptionLine[] {
+    const lines = language === "" || language === this.language ? this.lines : (this.linesBy.get(language) ?? []);
+    return after > 0 ? lines.filter((line) => line.at > after) : [...lines];
+  }
+
+  status(): CaptionStatus {
+    return {
+      on: true,
+      lines: this.lines.length,
+      error: this.error,
+      language: this.language,
+      known: this.known.get("")?.length ?? 0,
+      languages: [...this.linesBy.keys()],
+    };
+  }
+
   stop(): void {
     if (this.stopped) return;
     this.stopped = true;
@@ -281,6 +527,7 @@ class Captioner {
     this.pending = [];
     this.pendingBytes = 0;
     this.subscribers.clear();
+    void this.flushNow();
     this.onStop();
   }
 }
@@ -299,9 +546,10 @@ export class Captions {
    * Lines for a channel as they are heard, starting the captioner if it is
    * not running. Null when there is no such channel. The returned function
    * is how to stop listening; the captioner itself stops a minute after the
-   * last listener does.
+   * last listener does. A language asks for the lines translated into it;
+   * "" is the original.
    */
-  subscribe(id: string, subscriber: Subscriber): (() => void) | null {
+  subscribe(id: string, subscriber: Subscriber, language = ""): (() => void) | null {
     let captioner = this.running.get(id);
     if (!captioner) {
       const made = new Captioner(id, this.options, () => {
@@ -312,20 +560,19 @@ export class Captions {
       this.options.onEvent?.(`captions for "${id}": started`);
       captioner = made;
     }
-    return captioner.subscribe(subscriber);
+    return captioner.subscribe(subscriber, language);
   }
 
-  /** The recent lines of a channel, oldest first, after a moment when given. Empty when nobody has asked for them. */
-  recent(id: string, after = 0): CaptionLine[] {
+  /** The recent lines of a channel, oldest first, after a moment when given, in a language when asked. Empty when nobody has asked for them. */
+  recent(id: string, after = 0, language = ""): CaptionLine[] {
     const captioner = this.running.get(id);
-    if (!captioner) return [];
-    return after > 0 ? captioner.lines.filter((line) => line.at > after) : [...captioner.lines];
+    return captioner ? captioner.recent(after, language) : [];
   }
 
   /** Whether a channel is being captioned, and what last went wrong if the lines are not coming. */
-  status(id: string): { on: boolean; lines: number; error: string } {
+  status(id: string): CaptionStatus {
     const captioner = this.running.get(id);
-    return captioner ? { on: true, lines: captioner.lines.length, error: captioner.error } : { on: false, lines: 0, error: "" };
+    return captioner ? captioner.status() : { on: false, lines: 0, error: "", language: "", known: 0, languages: [] };
   }
 
   stopAll(): void {

package/src/channels.ts

@@ -95,6 +95,12 @@ export interface ChannelInfo {
    * plain URL is read this way, and only when a policy asks for it.
    */
   teed?: boolean;
+  /**
+   * When its show ended, wall clock, while the outro plays. A channel with
+   * this set is still on the air -- the picture says the stream has ended
+   * -- and closes on its own an hour later. Absent while the show is on.
+   */
+  ended?: number;
   /**
    * A picture of it from somewhere else: the thumbnail the site offered
    * for a pasted link, the logo a catalog gave a channel. A channel with
@@ -156,6 +162,13 @@ export const GIVE_UP = 5;
 export const STALL = 30_000;
 /** How long an on-demand channel stays up with nobody watching. */
 export const IDLE = 60_000;
+/** How long a channel plays its outro after the show, before it closes. */
+export const OUTRO_MS = 60 * 60 * 1000;
+/** The encode the outro is copied through: what a channel sends on the wire. */
+const OUTRO_ENCODE: Record<"audio" | "video", string[]> = {
+  video: ["-c", "copy", "-f", "mp4", "-movflags", "frag_keyframe+empty_moov+default_base_moof"],
+  audio: ["-c", "copy", "-f", "mp3"],
+};
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
 /**
@@ -241,6 +254,16 @@ export interface ChannelOptions {
   ffmpeg: string[];
   onStart?: (info: ChannelInfo) => void;
   onEnd?: (info: ChannelInfo) => void;
+  /**
+   * The outro: the clip a channel plays once its show is over, by kind,
+   * encoded as the wire wants it (see outro.ts). Null, or absent, means a
+   * show that ends closes its channel as it always did.
+   */
+  outro?: (kind: "audio" | "video") => Promise<string | null>;
+  /** How long the outro plays before the channel closes. An hour. */
+  outroMs?: number;
+  /** Said once, when a show ends and the outro begins. */
+  onOutro?: (info: ChannelInfo) => void;
   /** How long an on-demand channel outlives its last viewer. Tests shorten it. */
   idleMs?: number;
   /** Unsent bytes a listener may hold before it is dropped. Tests shrink it. */
@@ -272,6 +295,11 @@ export class Channel {
   /** Fires when a pulled source has said nothing for STALL. */
   private watchdog: ReturnType<typeof setTimeout> | null = null;
   private stall = STALL;
+  /** Whether the outro is what is playing now: the show is over. */
+  private outroOn = false;
+  private outroTimer: ReturnType<typeof setTimeout> | null = null;
+  /** How the show was dialled, so a restart after the outro is the show again. */
+  private dialed: { source: string; encode: string[]; paced: boolean; stall: number; input: string[]; audio: string; resume: PullResume } | null = null;
   private stderr = "";
   /**
    * The last few seconds, for whoever joins next.
@@ -368,6 +396,7 @@ export class Channel {
     resume: PullResume = { live: true, position: 0 },
   ): void {
     this.stall = stall;
+    if (!this.outroOn) this.dialed = { source, encode, paced, stall, input: [...input], audio, resume };
     if (this.info.kind === "video") this.fragments = new Fragments();
     const [command, ...prefix] = this.options.ffmpeg as [string, ...string[]];
     this.info.live = resume.live;
@@ -382,9 +411,12 @@ export class Channel {
       this.info.playlistAt = at;
     }
     let current = list ? (list[at] as string) : source;
+    // The last entry is the end of the show, not a way back to the first:
+    // a list that played through is over, and says so with the outro.
     this.advance = list && list.length > 1
       ? () => {
-          at = (at + 1) % list.length;
+          if (at + 1 >= list.length) return false;
+          at += 1;
           this.info.playlistAt = at;
           current = list[at] as string;
           return true;
@@ -414,7 +446,8 @@ export class Channel {
       // policy set after the channel started applies at its next restart.
       this.throughAbort?.abort();
       this.throughAbort = null;
-      const through = this.options.through?.(this.info, from, input, audio) ?? null;
+      // The outro is a file read by ffmpeg itself: a pipe cannot loop.
+      const through = this.outroOn ? null : this.options.through?.(this.info, from, input, audio) ?? null;
       this.info.teed = through !== null;
       const child = spawn(
         command,
@@ -509,7 +542,43 @@ export class Channel {
 
     this.redial = dial;
     dial();
-    this.options.onStart?.(this.info);
+    if (!this.outroOn) this.options.onStart?.(this.info);
+  }
+
+  /**
+   * The show is over: the outro, then the end. A publisher's channel is
+   * told this when the publisher goes, so whoever joins in the next hour
+   * is shown that the stream has ended rather than nothing at all. Without
+   * an outro to play it is the same as close().
+   */
+  finish(): void {
+    if (this.closing || this.outroOn) return;
+    void this.endShow();
+  }
+
+  private async endShow(): Promise<void> {
+    const kind = this.info.kind ?? "audio";
+    const old = this.child;
+    this.child = null;
+    if (this.watchdog) clearTimeout(this.watchdog);
+    this.watchdog = null;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    old?.kill("SIGKILL");
+    const clip = this.options.outro ? await this.options.outro(kind).catch(() => null) : null;
+    if (this.closing) return;
+    if (!clip) {
+      this.close();
+      return;
+    }
+    this.outroOn = true;
+    this.info.ended = Date.now();
+    this.info.error = undefined;
+    this.startOver();
+    this.options.onOutro?.(this.info);
+    this.pull(clip, OUTRO_ENCODE[kind], true, this.stall, ["-stream_loop", "-1"], "", { live: true, position: 0 });
+    this.outroTimer = setTimeout(() => this.close(), this.options.outroMs ?? OUTRO_MS);
+    this.outroTimer.unref?.();
   }
 
   /**
@@ -522,8 +591,26 @@ export class Channel {
    * strikes a dead CDN ran up an hour ago.
    */
   restart(): boolean {
+    if (this.closing) return false;
+    // Started over from the outro: the show itself, from its beginning.
+    if (this.outroOn && this.dialed) {
+      this.outroOn = false;
+      delete this.info.ended;
+      if (this.outroTimer) clearTimeout(this.outroTimer);
+      this.outroTimer = null;
+      const old = this.child;
+      this.child = null;
+      old?.kill("SIGKILL");
+      this.failures = 0;
+      this.info.error = undefined;
+      this.info.playlistAt = 0;
+      this.startOver();
+      const show = this.dialed;
+      this.pull(show.source, show.encode, show.paced, show.stall, show.input, show.audio, { ...show.resume, position: 0 });
+      return true;
+    }
     const dial = this.redial;
-    if (!dial || this.closing) return false;
+    if (!dial) return false;
     if (this.timer) clearTimeout(this.timer);
     this.timer = null;
     if (this.watchdog) clearTimeout(this.watchdog);
@@ -613,6 +700,11 @@ export class Channel {
    */
   private dropped(sent: boolean): void {
     if (this.closing || !this.redial) return;
+    // An outro that stopped is over; there is nothing after it.
+    if (this.outroOn) {
+      this.close();
+      return;
+    }
     this.child = null;
     if (this.watchdog) clearTimeout(this.watchdog);
     this.watchdog = null;
@@ -628,6 +720,15 @@ export class Channel {
     // gave nothing is skipped the same way, counted as the failure it was,
     // so a list of dead links gives up rather than cycling for ever.
     const moved = this.advance?.() ?? false;
+    // A show that ended: a film or a podcast that played to its end, a
+    // list whose last entry did. That is not a source that dropped, and it
+    // is not dialled again from the top; it is over, and the outro says
+    // so. A live feed that stopped is a feed that dropped, and is redialled.
+    const list = (this.info.playlist?.length ?? 0) > 0;
+    if (sent && !moved && (this.info.live === false || list)) {
+      void this.endShow();
+      return;
+    }
     const ended = moved && sent;
     if (ended) this.info.error = undefined;
     else this.info.redials = (this.info.redials ?? 0) + 1;
@@ -914,6 +1015,8 @@ export class Channel {
     this.watchdog = null;
     if (this.idle) clearTimeout(this.idle);
     this.idle = null;
+    if (this.outroTimer) clearTimeout(this.outroTimer);
+    this.outroTimer = null;
     const said = lastLine(this.stderr);
     if (said && !this.info.error) this.info.error = said;
     const child = this.child;