nixamp 0.7.36 → 0.7.38

package/dist/channels.d.ts

@@ -40,6 +40,13 @@ export declare const GIVE_UP = 5;
  * channel that is quiet for half a minute is not being quiet, it is dead.
  */
 export declare const STALL = 30000;
+/**
+ * How much of the recent stream a newcomer is handed. About six seconds of
+ * 720p television, and a couple of seconds of 192k MP3: enough to play
+ * through a hiccup, not enough to put a viewer noticeably behind the room.
+ */
+export declare const BACKLOG_VIDEO: number;
+export declare const BACKLOG_AUDIO: number;
 /** A name that can sit in a URL and be read back in a list. */
 export declare function cleanId(value: unknown, fallback?: string): string;
 export interface ChannelOptions {
@@ -70,6 +77,19 @@ export declare class Channel {
     private watchdog;
     private stall;
     private stderr;
+    /**
+     * The last few seconds, for whoever joins next.
+     *
+     * A listener handed only what comes after they arrive starts exactly on the
+     * live edge, with nothing buffered ahead: every hiccup in the source or the
+     * network is a stall, and CNN in a browser was play, wait, play, wait, for
+     * ever. A few seconds of recent fragments, written before the live bytes,
+     * is the cushion every other live player has. For a picture the backlog
+     * starts at a fragment boundary, because a fragment is the unit a decoder
+     * can begin at; for MP3 any point will do, a frame announces itself.
+     */
+    private recent;
+    private recentBytes;
     constructor(info: ChannelInfo, options: ChannelOptions, onGone: (id: string) => void);
     start(format: string): void;
     /**
@@ -128,6 +148,8 @@ export declare class Channel {
      * make sense.
      */
     private emit;
+    /** Keep this for the next arrival, and let the oldest go once it is too much. */
+    private remember;
     /** Feed the source. */
     write(chunk: Buffer): boolean;
     pump(body: Readable): Promise<void>;
@@ -198,5 +220,24 @@ export declare class Channels {
     stop(id: string): boolean;
     stopAll(): void;
 }
+/**
+ * The channels a server pulls itself, remembered across a restart.
+ *
+ * A server is restarted to pick up a new version, which is to say often, and
+ * every restart used to take CNN off the air until somebody noticed and put
+ * it back by hand. A publisher's stream cannot be remembered -- it restarts at
+ * the publisher's end -- but a pulled one is a name and a URL, and a name and
+ * a URL can be written down.
+ *
+ * Keyed by port, like the keys, because two servers on one machine are two
+ * different line-ups.
+ */
+export interface RememberedChannel {
+    id: string;
+    name: string;
+    source: string;
+}
+export declare function rememberedChannels(dir: string, port: number): 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

@@ -16,7 +16,9 @@
  */
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { Fragments } from "./fragments.js";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Fragments, isOpening } from "./fragments.js";
 /** 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. */
@@ -31,6 +33,17 @@ export const GIVE_UP = 5;
 export const STALL = 30_000;
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
+/**
+ * How much of the recent stream a newcomer is handed. About six seconds of
+ * 720p television, and a couple of seconds of 192k MP3: enough to play
+ * through a hiccup, not enough to put a viewer noticeably behind the room.
+ */
+export const BACKLOG_VIDEO = 4 * 1024 * 1024;
+export const BACKLOG_AUDIO = 64 * 1024;
+/** The four-letter name in a box header, or "" for something too short. */
+function boxType(box) {
+    return box.length >= 8 ? box.toString("latin1", 4, 8) : "";
+}
 /**
  * Read everything a child says on stderr, keeping only the end of it.
  *
@@ -85,6 +98,19 @@ export class Channel {
     watchdog = null;
     stall = STALL;
     stderr = "";
+    /**
+     * The last few seconds, for whoever joins next.
+     *
+     * A listener handed only what comes after they arrive starts exactly on the
+     * live edge, with nothing buffered ahead: every hiccup in the source or the
+     * network is a stall, and CNN in a browser was play, wait, play, wait, for
+     * ever. A few seconds of recent fragments, written before the live bytes,
+     * is the cushion every other live player has. For a picture the backlog
+     * starts at a fragment boundary, because a fragment is the unit a decoder
+     * can begin at; for MP3 any point will do, a frame announces itself.
+     */
+    recent = [];
+    recentBytes = 0;
     constructor(info, options, onGone) {
         this.info = info;
         this.options = options;
@@ -232,6 +258,8 @@ export class Channel {
     startOver() {
         if (this.info.kind === "video")
             this.fragments = new Fragments();
+        this.recent = [];
+        this.recentBytes = 0;
         this.hangUp();
     }
     /** Expect output within STALL, or treat the source as gone and dial again. */
@@ -302,11 +330,32 @@ export class Channel {
      */
     emit(chunk) {
         if (!this.fragments) {
+            this.remember(chunk, BACKLOG_AUDIO, false);
             this.send(chunk);
             return;
         }
-        for (const box of this.fragments.push(chunk))
+        for (const box of this.fragments.push(chunk)) {
+            if (!isOpening(boxType(box)))
+                this.remember(box, BACKLOG_VIDEO, true);
             this.send(box);
+        }
+    }
+    /** Keep this for the next arrival, and let the oldest go once it is too much. */
+    remember(piece, cap, aligned) {
+        this.recent.push(piece);
+        this.recentBytes += piece.byteLength;
+        while (this.recent.length > 0 && this.recentBytes > cap) {
+            const gone = this.recent.shift();
+            this.recentBytes -= gone.byteLength;
+        }
+        // A picture's backlog must begin at a `moof`: an `mdat` on its own is
+        // samples nobody has been told the layout of.
+        if (aligned) {
+            while (this.recent.length > 0 && boxType(this.recent[0]) !== "moof") {
+                const gone = this.recent.shift();
+                this.recentBytes -= gone.byteLength;
+            }
+        }
     }
     /** Feed the source. */
     write(chunk) {
@@ -355,6 +404,18 @@ export class Channel {
                 // Gone before it began; the detach below still tidies up.
             }
         }
+        // Then the last few seconds, so there is something to play while the
+        // live bytes catch up, rather than a picture that stalls on every hiccup.
+        if (!this.fragments || this.fragments.ready) {
+            for (const piece of this.recent) {
+                try {
+                    listener.write(piece);
+                }
+                catch {
+                    break;
+                }
+            }
+        }
         this.listeners.add(listener);
         this.info.listeners = this.listeners.size;
         return () => {
@@ -529,6 +590,39 @@ export class Channels {
             channel.close();
     }
 }
+const REMEMBERED = "channels.json";
+export function rememberedChannels(dir, port) {
+    try {
+        const all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8"));
+        const list = all[String(port)];
+        if (!Array.isArray(list))
+            return [];
+        return list.filter((one) => typeof one === "object" && one !== null &&
+            typeof one.id === "string" &&
+            typeof one.name === "string" &&
+            typeof one.source === "string");
+    }
+    catch {
+        return [];
+    }
+}
+export function rememberChannels(dir, port, list) {
+    let all = {};
+    try {
+        all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8"));
+    }
+    catch {
+        // First time, or unreadable: start again rather than refuse to remember.
+    }
+    all[String(port)] = list;
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, REMEMBERED), JSON.stringify(all, null, 2));
+    }
+    catch {
+        // A state directory that cannot be written costs a memory, not a stream.
+    }
+}
 /** A channel id nobody chose, for a publisher that did not name one. */
 export function generatedId() {
     return `s${randomBytes(3).toString("hex")}`;

package/dist/server.d.ts

@@ -2,7 +2,7 @@ import { type IncomingMessage, type Server, type ServerResponse } from "node:htt
 import { Connections } from "./connections.ts";
 import { Broadcaster, type Destination, type EncoderSettings } from "./broadcast.ts";
 import { Ingest } from "./ingest.ts";
-import { Channels } from "./channels.ts";
+import { Channels, type Channel, type RememberedChannel } from "./channels.ts";
 import { Accounts } from "./accounts.ts";
 import { Handles } from "./handles.ts";
 import { OpenDirs } from "./opendirs.ts";
@@ -336,6 +336,14 @@ export declare class PlayerEngine implements Engine {
  * looking at what is on wants "that album from the web", not every track in
  * it. An entry names where to start, so clicking it plays.
  */
+/**
+ * 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.
+ */
+export declare function pullChannel(channels: Channels, ffprobe: string[], id: string, name: string, source: string): Promise<Channel | null>;
 export declare function liveOnes(engine: Engine): {
     name: string;
     at: number;
@@ -403,6 +411,8 @@ export interface HandlerOptions {
     ingest?: Ingest;
     /** Several live streams at once, each with its own audience. */
     channels?: Channels;
+    /** Write down the channels this server pulls, so a restart puts them back. */
+    rememberChannels?: (list: RememberedChannel[]) => void;
     /** Live audio going out to RTMP. */
     broadcaster?: Broadcaster;
     /** Where a broadcast should send, and what it should look like. */

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 } from "./channels.js";
+import { Channels, cleanId, generatedId, rememberChannels, rememberedChannels, } from "./channels.js";
 import { RtmpListeners } from "./rtmp-in.js";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.js";
 import { anonymousHandle, Handles } from "./handles.js";
@@ -707,6 +707,23 @@ export class PlayerEngine {
  * looking at what is on wants "that album from the web", not every track in
  * it. An entry names where to start, so clicking it plays.
  */
+/**
+ * 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.
+ */
+export async function pullChannel(channels, ffprobe, id, name, source) {
+    const codecs = await codecsOf({ ffmpeg: [], ffprobe, play: null }, source);
+    const kind = codecs.video === "" ? "audio" : "video";
+    const encode = kind === "video"
+        ? 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);
+}
 export function liveOnes(engine) {
     const tracks = engine.snapshot().tracks ?? [];
     const found = new Map();
@@ -1857,6 +1874,13 @@ export function createHandler(engine, options) {
                 // Asked once: the second call would answer false, having just stopped
                 // the thing it was asking about.
                 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 })));
+                }
                 json(response, stopped ? 200 : 404, { ok: stopped });
                 return;
             }
@@ -1927,19 +1951,20 @@ export function createHandler(engine, options) {
                     json(response, 409, { error: "that channel is already on" });
                     return;
                 }
-                const probe = options.ffprobe ?? ["ffprobe"];
-                const codecs = await codecsOf({ ffmpeg: [], ffprobe: probe, play: null }, source);
-                const kind = codecs.video === "" ? "audio" : "video";
-                const encode = kind === "video"
-                    ? 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"];
-                const channel = channels.pull(wanted, called, source, encode, kind);
+                const channel = await pullChannel(channels, options.ffprobe ?? ["ffprobe"], wanted, called, source);
                 if (!channel) {
                     json(response, 409, { error: "that channel is already on" });
                     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 },
+                    ]);
+                }
                 json(response, 200, { ok: true, channel: channel.info });
                 return;
             }
@@ -2810,6 +2835,17 @@ export async function serve(argv, version = "0.1.0") {
         onStart: (info) => console.log(`  ${info.name} is publishing to "${info.id}" (${info.format} over ${info.via}).`),
         onEnd: (info) => console.log(`  "${info.id}" stopped.`),
     });
+    // The channels this server was carrying when it was last stopped, put back
+    // on. A server is restarted to pick up a new version, which is often, and
+    // 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) => {
+            if (!channel)
+                console.log(`  "${one.id}" is already on.`);
+        });
+    }
     const destinations = parseDestinations(options.rtmp);
     const broadcaster = new Broadcaster(tools.ffmpeg);
     const ingest = options.ingest
@@ -2994,6 +3030,7 @@ export async function serve(argv, version = "0.1.0") {
         media: options.media,
         owner,
         channels,
+        rememberChannels: remembering,
         publishUrls: () => publishUrls,
         serverName: options.name || hostname(),
         homeSource: root,

package/package.json

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

package/src/channels.ts

@@ -16,8 +16,10 @@
  */
 import { spawn, type ChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import type { Readable } from "node:stream";
-import { Fragments } from "./fragments.ts";
+import { Fragments, isOpening } from "./fragments.ts";
 
 /** Somewhere for a channel's audio to go. A response, in practice. */
 export interface Listener {
@@ -64,6 +66,18 @@ export const GIVE_UP = 5;
 export const STALL = 30_000;
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
+/**
+ * How much of the recent stream a newcomer is handed. About six seconds of
+ * 720p television, and a couple of seconds of 192k MP3: enough to play
+ * through a hiccup, not enough to put a viewer noticeably behind the room.
+ */
+export const BACKLOG_VIDEO = 4 * 1024 * 1024;
+export const BACKLOG_AUDIO = 64 * 1024;
+
+/** The four-letter name in a box header, or "" for something too short. */
+function boxType(box: Buffer): string {
+  return box.length >= 8 ? box.toString("latin1", 4, 8) : "";
+}
 
 /**
  * Read everything a child says on stderr, keeping only the end of it.
@@ -124,6 +138,19 @@ export class Channel {
   private watchdog: ReturnType<typeof setTimeout> | null = null;
   private stall = STALL;
   private stderr = "";
+  /**
+   * The last few seconds, for whoever joins next.
+   *
+   * A listener handed only what comes after they arrive starts exactly on the
+   * live edge, with nothing buffered ahead: every hiccup in the source or the
+   * network is a stall, and CNN in a browser was play, wait, play, wait, for
+   * ever. A few seconds of recent fragments, written before the live bytes,
+   * is the cushion every other live player has. For a picture the backlog
+   * starts at a fragment boundary, because a fragment is the unit a decoder
+   * can begin at; for MP3 any point will do, a frame announces itself.
+   */
+  private recent: Buffer[] = [];
+  private recentBytes = 0;
 
   constructor(
     readonly info: ChannelInfo,
@@ -280,6 +307,8 @@ export class Channel {
    */
   private startOver(): void {
     if (this.info.kind === "video") this.fragments = new Fragments();
+    this.recent = [];
+    this.recentBytes = 0;
     this.hangUp();
   }
 
@@ -348,10 +377,32 @@ export class Channel {
    */
   private emit(chunk: Buffer): void {
     if (!this.fragments) {
+      this.remember(chunk, BACKLOG_AUDIO, false);
       this.send(chunk);
       return;
     }
-    for (const box of this.fragments.push(chunk)) this.send(box);
+    for (const box of this.fragments.push(chunk)) {
+      if (!isOpening(boxType(box))) this.remember(box, BACKLOG_VIDEO, true);
+      this.send(box);
+    }
+  }
+
+  /** Keep this for the next arrival, and let the oldest go once it is too much. */
+  private remember(piece: Buffer, cap: number, aligned: boolean): void {
+    this.recent.push(piece);
+    this.recentBytes += piece.byteLength;
+    while (this.recent.length > 0 && this.recentBytes > cap) {
+      const gone = this.recent.shift() as Buffer;
+      this.recentBytes -= gone.byteLength;
+    }
+    // A picture's backlog must begin at a `moof`: an `mdat` on its own is
+    // samples nobody has been told the layout of.
+    if (aligned) {
+      while (this.recent.length > 0 && boxType(this.recent[0] as Buffer) !== "moof") {
+        const gone = this.recent.shift() as Buffer;
+        this.recentBytes -= gone.byteLength;
+      }
+    }
   }
 
   /** Feed the source. */
@@ -402,6 +453,17 @@ export class Channel {
         // Gone before it began; the detach below still tidies up.
       }
     }
+    // Then the last few seconds, so there is something to play while the
+    // live bytes catch up, rather than a picture that stalls on every hiccup.
+    if (!this.fragments || this.fragments.ready) {
+      for (const piece of this.recent) {
+        try {
+          listener.write(piece);
+        } catch {
+          break;
+        }
+      }
+    }
     this.listeners.add(listener);
     this.info.listeners = this.listeners.size;
     return () => {
@@ -599,6 +661,59 @@ export class Channels {
   }
 }
 
+/**
+ * The channels a server pulls itself, remembered across a restart.
+ *
+ * A server is restarted to pick up a new version, which is to say often, and
+ * every restart used to take CNN off the air until somebody noticed and put
+ * it back by hand. A publisher's stream cannot be remembered -- it restarts at
+ * the publisher's end -- but a pulled one is a name and a URL, and a name and
+ * a URL can be written down.
+ *
+ * Keyed by port, like the keys, because two servers on one machine are two
+ * different line-ups.
+ */
+export interface RememberedChannel {
+  id: string;
+  name: string;
+  source: string;
+}
+
+const REMEMBERED = "channels.json";
+
+export function rememberedChannels(dir: string, port: number): RememberedChannel[] {
+  try {
+    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",
+    );
+  } catch {
+    return [];
+  }
+}
+
+export function rememberChannels(dir: string, port: number, list: RememberedChannel[]): void {
+  let all: Record<string, unknown> = {};
+  try {
+    all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8")) as Record<string, unknown>;
+  } catch {
+    // First time, or unreadable: start again rather than refuse to remember.
+  }
+  all[String(port)] = list;
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, REMEMBERED), JSON.stringify(all, null, 2));
+  } catch {
+    // A state directory that cannot be written costs a memory, not a stream.
+  }
+}
+
 /** A channel id nobody chose, for a publisher that did not name one. */
 export function generatedId(): string {
   return `s${randomBytes(3).toString("hex")}`;

package/src/server.ts

@@ -26,7 +26,10 @@ import {
   redact,
 } from "./broadcast.ts";
 import { Ingest, normaliseFormat } from "./ingest.ts";
-import { Channels, cleanId, generatedId } from "./channels.ts";
+import {
+  Channels, cleanId, generatedId, rememberChannels, rememberedChannels,
+  type Channel, type RememberedChannel,
+} from "./channels.ts";
 import { RtmpListeners } from "./rtmp-in.ts";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.ts";
 import { anonymousHandle, Handles } from "./handles.ts";
@@ -908,6 +911,30 @@ export class PlayerEngine implements Engine {
  * looking at what is on wants "that album from the web", not every track in
  * it. An entry names where to start, so clicking it plays.
  */
+/**
+ * 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.
+ */
+export async function pullChannel(
+  channels: Channels,
+  ffprobe: string[],
+  id: string,
+  name: string,
+  source: string,
+): Promise<Channel | null> {
+  const codecs = await codecsOf({ ffmpeg: [], ffprobe, play: null }, source);
+  const kind = codecs.video === "" ? "audio" : "video";
+  const encode = kind === "video"
+    ? 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);
+}
+
 export function liveOnes(engine: Engine): { name: string; at: number; tracks: number }[] {
   const tracks = engine.snapshot().tracks ?? [];
   const found = new Map<string, { name: string; at: number; tracks: number }>();
@@ -1065,6 +1092,8 @@ export interface HandlerOptions {
   ingest?: Ingest;
   /** Several live streams at once, each with its own audience. */
   channels?: Channels;
+  /** Write down the channels this server pulls, so a restart puts them back. */
+  rememberChannels?: (list: RememberedChannel[]) => void;
   /** Live audio going out to RTMP. */
   broadcaster?: Broadcaster;
   /** Where a broadcast should send, and what it should look like. */
@@ -2260,6 +2289,15 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         // Asked once: the second call would answer false, having just stopped
         // the thing it was asking about.
         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 })),
+          );
+        }
         json(response, stopped ? 200 : 404, { ok: stopped });
         return;
       }
@@ -2335,20 +2373,20 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           return;
         }
 
-        const probe = options.ffprobe ?? ["ffprobe"];
-        const codecs = await codecsOf({ ffmpeg: [], ffprobe: probe, play: null }, source);
-        const kind = codecs.video === "" ? "audio" : "video";
-        const encode = kind === "video"
-          ? 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"];
-
-        const channel = channels.pull(wanted, called, source, encode, kind);
+        const channel = await pullChannel(channels, options.ffprobe ?? ["ffprobe"], wanted, called, source);
         if (!channel) {
           json(response, 409, { error: "that channel is already on" });
           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 },
+          ]);
+        }
         json(response, 200, { ok: true, channel: channel.info });
         return;
       }
@@ -3279,6 +3317,17 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     onEnd: (info) => console.log(`  "${info.id}" stopped.`),
   });
 
+  // The channels this server was carrying when it was last stopped, put back
+  // on. A server is restarted to pick up a new version, which is often, and
+  // 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) => {
+      if (!channel) console.log(`  "${one.id}" is already on.`);
+    });
+  }
+
   const destinations = parseDestinations(options.rtmp);
   const broadcaster = new Broadcaster(tools.ffmpeg);
   const ingest = options.ingest
@@ -3479,6 +3528,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     media: options.media,
     owner,
     channels,
+    rememberChannels: remembering,
     publishUrls: () => publishUrls,
     serverName: options.name || hostname(),
     homeSource: root,

package/web/dist/install.sh

@@ -98,6 +98,22 @@ BASE="${NIXAMP_RELEASE_BASE:-https://github.com/$REPO/releases/download/v$VERSIO
 SHARE="$PREFIX/share/nixamp"
 BIN="$PREFIX/bin"
 
+# --- a daemon already running here --------------------------------------------
+#
+# Noticed now, restarted at the end. An update used to leave the old version
+# running until somebody remembered to restart it, and restarting it by hand
+# from the wrong directory started a server of your home folder over plain
+# http. `nixamp daemon restart` replays the flags the daemon was started with,
+# so the installer runs that rather than guessing at any.
+STATE_DIR="${XDG_STATE_HOME:-$HOME/.local/state}/nixamp"
+DAEMON_PID=""
+if [ -r "$STATE_DIR/daemon.json" ]; then
+  DAEMON_PID=$(sed -n 's/^[[:space:]]*"pid":[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$STATE_DIR/daemon.json" | head -n 1)
+  if [ -n "$DAEMON_PID" ] && ! kill -0 "$DAEMON_PID" 2>/dev/null; then
+    DAEMON_PID=""
+  fi
+fi
+
 say "nixamp $VERSION"
 say "  platform:  $OS-$ARCH"
 say "  desktop:   $WANT_DESKTOP"
@@ -219,7 +235,7 @@ else
   RUNTIME=""
 
   command -v node >/dev/null 2>&1 ||
-    say "  note: no desktop app was installed, so the CLI needs Node 24 or newer. It was not found."
+    say "  note: no desktop app was installed, so the CLI needs Node 22.6 or newer, and none is on PATH."
 fi
 
 # The shim. Written here rather than shipped, because only the installer knows
@@ -236,7 +252,7 @@ else
 #!/bin/sh
 # nixamp. Written by the installer; \`nixamp uninstall\` removes it.
 command -v node >/dev/null 2>&1 || {
-  echo "nixamp: node 24 or newer is required for a CLI-only install." >&2
+  echo "nixamp: node is not on PATH. This install runs on your own Node (22.6 or newer)." >&2
   exit 69
 }
 NIXAMP_HOME="$SHARE" exec node "$CLI_DIR/bin/nixamp.mjs" "\$@"
@@ -362,6 +378,17 @@ elif [ "$FW_RESULT" = manual ]; then
   say "  Open it with:  $(firewall_command)"
 fi
 
+if [ -n "$DAEMON_PID" ]; then
+  say ""
+  say "A nixamp daemon was running (pid $DAEMON_PID). Restarting it on $VERSION,"
+  say "with the flags it was started with..."
+  if "$BIN/nixamp" daemon restart; then
+    say "  Restarted. The channels it was carrying come back on their own."
+  else
+    say "  Could not restart it. Run:  nixamp daemon restart"
+  fi
+fi
+
 case ":$PATH:" in
   *":$BIN:"*)
     say ""

package/web/dist/sw.js

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