nixamp 0.7.5 → 0.7.6

package/dist/audio.d.ts

@@ -78,6 +78,17 @@ export interface Codecs {
     video: string;
     /** e.g. "aac", "ac3", "dts". Empty when there is no audio stream. */
     audio: string;
+    /**
+     * What is wrapped around them: "mpegts", "matroska,webm", "mov,mp4,...".
+     *
+     * It matters for one reason. A transport stream -- which is what every IPTV
+     * channel is -- frames its AAC as ADTS, and copying that into MP4 needs a
+     * bitstream filter or ffmpeg refuses the whole muxing and writes nothing.
+     * They also tend to carry several audio tracks, so the one ffmpeg picks can
+     * be AC-3 on the same URL that offered AAC a minute earlier, and AC-3 in MP4
+     * is a track no browser will play.
+     */
+    container: string;
 }
 /**
  * Ask ffprobe what the streams are, without holding the event loop.

package/dist/audio.js

@@ -284,7 +284,7 @@ function readTags(stdout, fallback) {
  */
 export async function codecsOf(tools, path) {
     const [cmd, ...rest] = tools.ffprobe;
-    const empty = { video: "", audio: "" };
+    const empty = { video: "", audio: "", container: "" };
     if (!cmd)
         return empty;
     return new Promise((done) => {
@@ -292,7 +292,7 @@ export async function codecsOf(tools, path) {
             ...rest,
             "-v", "quiet",
             "-print_format", "json",
-            "-show_entries", "stream=codec_type,codec_name",
+            "-show_entries", "format=format_name:stream=codec_type,codec_name",
             path,
         ], { stdio: ["ignore", "pipe", "ignore"] });
         let out = "";
@@ -307,6 +307,7 @@ export async function codecsOf(tools, path) {
                 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 ?? "",
                 });
             }
             catch {
@@ -331,7 +332,13 @@ export function videoArgs(codecs, capKbps = 0) {
         return cappedArgs(capKbps);
     // What a browser can play inside MP4 without help.
     const keepVideo = codecs.video === "h264";
-    const keepAudio = codecs.audio === "aac" || codecs.audio === "mp3";
+    // A transport stream's audio is never copied. Its AAC is ADTS-framed, which
+    // MP4 refuses without a bitstream filter -- ffmpeg writes nothing at all and
+    // says "Malformed AAC bitstream detected" -- and the track ffmpeg picks off
+    // a channel with several of them can be AC-3, which that filter rejects and
+    // no browser plays. Re-encoding audio is cheap; this failing is total.
+    const transportStream = codecs.container.includes("mpegts");
+    const keepAudio = !transportStream && (codecs.audio === "aac" || codecs.audio === "mp3");
     return [
         "-c:v", keepVideo ? "copy" : "libx264",
         ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),

package/dist/daemon.d.ts

@@ -27,6 +27,15 @@ export interface DaemonState {
      * interface, so it names the router and not this port.
      */
     guessedPublic?: boolean;
+    /**
+     * What it was started with, so it can be started that way again.
+     *
+     * A daemon serving TLS on a public name is six flags, and restarting it
+     * meant finding them again -- from shell history, or from `ps`, or not at
+     * all. Absent on a state file written by an older nixamp, which is why
+     * `restart` says so rather than starting something different.
+     */
+    argv?: string[];
 }
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
 export declare function stateDir(): string;
@@ -75,5 +84,16 @@ export declare function daemonLines(state: DaemonState, uptimeMs?: number): stri
  * log file is the thing this is meant to avoid.
  */
 export declare function start(argv: string[], entry: string): Promise<DaemonState>;
+/**
+ * Stop it and start it again, the way it was started.
+ *
+ * The flags are replayed from the state file rather than retyped, because the
+ * interesting daemons are the ones with the most flags: a certificate, a key,
+ * a public URL. Given arguments of its own it uses those instead, which is how
+ * you change one thing without stopping and starting by hand.
+ */
+export declare function restart(argv: string[], entry: string, 
+/** Injected so a test can see which arguments would be replayed. */
+starter?: typeof start): Promise<DaemonState>;
 /** Stop it, and wait for it to actually be gone. */
 export declare function stop(timeoutMs?: number): Promise<boolean>;

package/dist/daemon.js

@@ -178,10 +178,30 @@ export async function start(argv, entry) {
         }
         throw new Error(`nixamp: the daemon did not start. See ${log}`);
     }
-    const state = { ...announced, pid: child.pid, startedAt: Date.now(), log };
+    const state = { ...announced, pid: child.pid, startedAt: Date.now(), log, argv };
     writeState(state);
     return state;
 }
+/**
+ * Stop it and start it again, the way it was started.
+ *
+ * The flags are replayed from the state file rather than retyped, because the
+ * interesting daemons are the ones with the most flags: a certificate, a key,
+ * a public URL. Given arguments of its own it uses those instead, which is how
+ * you change one thing without stopping and starting by hand.
+ */
+export async function restart(argv, entry, 
+/** Injected so a test can see which arguments would be replayed. */
+starter = start) {
+    const { state } = status();
+    const before = state?.argv;
+    if (argv.length === 0 && before === undefined && state !== null) {
+        throw new Error("nixamp: this daemon was started by an older nixamp, which did not record its flags. " +
+            "Stop it and start it again with the flags you want.");
+    }
+    await stop();
+    return starter(argv.length > 0 ? argv : (before ?? []), entry);
+}
 /** Poll the log for the announce line. */
 async function waitForAnnounce(log, timeoutMs) {
     const deadline = Date.now() + timeoutMs;

package/dist/invite.d.ts

@@ -2,9 +2,11 @@
  * Asking somebody to watch, when that somebody is not technical.
  *
  * A share link is a URL with a key in it, which is fine for the person who
- * runs the server and useless as a thing to text your mother. An invite is the
- * three ways in, written as a sentence: a link that opens a player, a phone
- * number, and the code to key once it answers.
+ * runs the server and useless as a thing to text your mother. An invite is two
+ * things written as a sentence: a link that opens a player, and a phone number
+ * with a code, which is the line where everyone watching talks to each other.
+ * The phone is not another way to hear the stream -- it is the 800 number
+ * beside a podcast. The show is on the screen; the call is the company.
  *
  * The sender is signed in, because sending is an action with a cost: a text
  * message is money and somebody's phone. The recipient signs in too, but only
@@ -21,7 +23,7 @@ export interface Invite {
     link: string;
     /** The phone number, when this stream is one the line knows about. */
     phone: string;
-    /** The six digits that reach this stream, when it has been published. */
+    /** The six digits that reach this stream's room, once it has been published. */
     code: string;
 }
 /** Looks like a phone number rather than an address. */

package/dist/invite.js

@@ -2,9 +2,11 @@
  * Asking somebody to watch, when that somebody is not technical.
  *
  * A share link is a URL with a key in it, which is fine for the person who
- * runs the server and useless as a thing to text your mother. An invite is the
- * three ways in, written as a sentence: a link that opens a player, a phone
- * number, and the code to key once it answers.
+ * runs the server and useless as a thing to text your mother. An invite is two
+ * things written as a sentence: a link that opens a player, and a phone number
+ * with a code, which is the line where everyone watching talks to each other.
+ * The phone is not another way to hear the stream -- it is the 800 number
+ * beside a podcast. The show is on the screen; the call is the company.
  *
  * The sender is signed in, because sending is an action with a cost: a text
  * message is money and somebody's phone. The recipient signs in too, but only
@@ -32,7 +34,10 @@ export function isEmail(value) {
 export function inviteText(invite) {
     const lines = [`${invite.name} is streaming.`, "", `Watch: ${invite.link}`];
     if (invite.phone && invite.code) {
-        lines.push("", `Or call ${invite.phone} and key ${invite.code} to listen.`);
+        // "to talk about it", not "to listen": the line is a room full of the
+        // other people watching, and telling somebody they will hear the stream
+        // down the phone is telling them something that is not true.
+        lines.push("", `To talk about it: call ${invite.phone} and key ${invite.code}.`);
     }
     return lines.join("\n");
 }

package/dist/main.js

@@ -45,7 +45,7 @@ const HELP = `nixamp — it really whips the terminal's ass.
 
   nixamp [source]                play it in the terminal
   nixamp serve [source] [options]  play here, and hand out a browser remote
-  nixamp daemon start|stop|status  serve in the background, and let go of it
+  nixamp daemon start|restart|stop|status  serve in the background, and let go of it
   nixamp attach                  put the player back in front of the daemon
   nixamp admin [--url U] [--key K] who is connected, and re-stream to them
   nixamp login [--with github]  sign in to nixamp.com, in a browser or here
@@ -162,9 +162,13 @@ Signing out does not touch it: that is what it is for.
     daemon: `nixamp daemon — a nixamp that outlives the terminal that started it.
 
   nixamp daemon start [source] [serve options]   start it, detached
+  nixamp daemon restart [source] [serve options] stop it and start it again
   nixamp daemon status                           where it is, and how long
   nixamp daemon stop                             stop it
 
+Restart with no arguments replays the ones it was started with, certificate
+and public URL included, so picking up a new version costs one command.
+
 It is \`nixamp serve\` with nobody holding its terminal, so it keeps playing and
 keeps serving its browser remote. One per user.
 
@@ -228,6 +232,18 @@ async function runDaemon(argv) {
         console.log(stopped ? "nixamp daemon stopped" : "nixamp: no daemon was running");
         return 0;
     }
+    if (action === "restart") {
+        try {
+            const state = await d.restart(rest, entry);
+            for (const line of d.daemonLines(state))
+                console.log(line);
+            return 0;
+        }
+        catch (error) {
+            console.error(error.message);
+            return 1;
+        }
+    }
     if (action === "status") {
         const { running, state } = d.status();
         if (!state) {
@@ -253,7 +269,7 @@ async function runDaemon(argv) {
         const { attach } = await import("./attach.js");
         return attach(rest);
     }
-    console.error(`nixamp daemon: unknown action ${action}. Try start, stop, status or attach.`);
+    console.error(`nixamp daemon: unknown action ${action}. Try start, restart, stop, status or attach.`);
     return 64;
 }
 /**

package/dist/partyline.d.ts

@@ -134,15 +134,6 @@ export declare class PartyLine {
         add: (code: string, phone: string) => void;
         take: (code: string) => Promise<string[]>;
     }, waiting?: ReadonlyMap<string, ReadonlySet<string>>): void;
-    /**
-     * Legs listening to a stream, by its code.
-     *
-     * Separate from the rooms because a stream listener is not in a conference:
-     * they are a leg with an MP3 playing into it. Nothing else was counting
-     * them, so the directory had no way to say how many people were on the
-     * phone for a broadcast.
-     */
-    private readonly streamLegs;
     private readonly key;
     private readonly fetch;
     private readonly now;
@@ -199,6 +190,14 @@ export declare class PartyLine {
      * room code still works: this line was a party line before it was a way into
      * a broadcast, and a code that means nothing to the directory should still
      * mean a room.
+     *
+     * Keying a stream's code puts you in a room with the other people watching
+     * it. It does not play the stream at you, which is what it used to do: this
+     * is the phone line beside a broadcast, the way a podcast has an 800 number
+     * -- the show is on your screen and the phone is where you talk about it.
+     * Playing the audio down the phone was both the worse half of the idea and
+     * the one that kept failing, because a share link answers a 302 and a cookie
+     * rather than an MP3.
      */
     private stream;
     /** Whether the caller took the reminder that was offered. */
@@ -220,7 +219,13 @@ export declare class PartyLine {
     /** Put a leg into a room, making the conference if it is the first one there. */
     private join;
     private enter;
-    /** How many people are listening to a stream by phone. */
+    /**
+     * How many people are on the phone for a stream.
+     *
+     * The room's own count, now that a stream's code is a room like any other.
+     * It used to count legs with an MP3 playing into them, which is a thing that
+     * no longer happens.
+     */
     listenersOn(code: string): number;
     /** A leg that hung up or was dropped, wherever it was. */
     private release;

package/dist/partyline.js

@@ -155,15 +155,6 @@ export class PartyLine {
             this.reminders.set(code, set);
         }
     }
-    /**
-     * Legs listening to a stream, by its code.
-     *
-     * Separate from the rooms because a stream listener is not in a conference:
-     * they are a leg with an MP3 playing into it. Nothing else was counting
-     * them, so the directory had no way to say how many people were on the
-     * phone for a broadcast.
-     */
-    streamLegs = new Map();
     key;
     fetch;
     now;
@@ -318,6 +309,14 @@ export class PartyLine {
      * room code still works: this line was a party line before it was a way into
      * a broadcast, and a code that means nothing to the directory should still
      * mean a room.
+     *
+     * Keying a stream's code puts you in a room with the other people watching
+     * it. It does not play the stream at you, which is what it used to do: this
+     * is the phone line beside a broadcast, the way a podcast has an 800 number
+     * -- the show is on your screen and the phone is where you talk about it.
+     * Playing the audio down the phone was both the worse half of the idea and
+     * the one that kept failing, because a share link answers a 302 and a cookie
+     * rather than an MP3.
      */
     async stream(leg, code) {
         const streams = this.options.streams;
@@ -326,39 +325,12 @@ export class PartyLine {
         const live = streams.liveByCode(code);
         if (live !== undefined) {
             const what = live.nowPlaying ? ` of ${live.nowPlaying}` : "";
-            // The share link is not playable. It answers 302 with a cookie and sends
-            // a browser to the player page; Telnyx fetches once with no cookie jar
-            // and gets a 401 in JSON. Playing it means a caller who is told "here it
-            // is" and then hears nothing at all, which is how this was found. Say
-            // what is true instead, and hang up rather than bill for silence.
-            if (!live.audio) {
-                await this.command(leg, "speak", {
-                    payload: `${live.name} is live right now${what}, but this stream cannot be played over the phone. ` +
-                        "You can listen to it at nixamp dot com slash directory. Goodbye.",
-                    voice: this.voice,
-                });
-                await this.command(leg, "hangup", {});
-                this.options.onEvent?.(`  ${code} is live but announced no audio address; nothing to play.`);
-                return true;
-            }
             await this.command(leg, "speak", {
-                payload: `Welcome to ${live.name}'s live stream${what}. It started at ${pacificTime(live.startedAt)}. Here it is.`,
+                payload: `You're on the line for ${live.name}${what}. ` +
+                    "Everyone here is watching it too. Say hello.",
                 voice: this.voice,
             });
-            // A nixamp stream is an MP3 over HTTP and Telnyx will play a URL into a
-            // call, so listening by phone costs no audio handling here at all.
-            const playing = await this.command(leg, "playback_start", {
-                audio_url: live.audio,
-                loop: "infinity",
-            });
-            // Counted only once the audio is actually going. A leg we failed to
-            // start is not somebody listening, and the directory would be saying so.
-            if (playing) {
-                const legs = this.streamLegs.get(code) ?? new Set();
-                legs.add(leg);
-                this.streamLegs.set(code, legs);
-                this.options.onEvent?.(`  a caller is listening to ${code} (${legs.size} on the phone).`);
-            }
+            await this.join(leg, code);
             return true;
         }
         const ended = streams.endedByCode(code);
@@ -490,16 +462,18 @@ export class PartyLine {
         room.callers = room.legs.size;
         this.options.onEvent?.(`  a caller joined a room (${room.callers} on the line).`);
     }
-    /** How many people are listening to a stream by phone. */
+    /**
+     * How many people are on the phone for a stream.
+     *
+     * The room's own count, now that a stream's code is a room like any other.
+     * It used to count legs with an MP3 playing into them, which is a thing that
+     * no longer happens.
+     */
     listenersOn(code) {
-        return this.streamLegs.get(code)?.size ?? 0;
+        return this.rooms.get(code)?.callers ?? 0;
     }
     /** A leg that hung up or was dropped, wherever it was. */
     release(leg) {
-        for (const [code, legs] of this.streamLegs) {
-            if (legs.delete(leg) && legs.size === 0)
-                this.streamLegs.delete(code);
-        }
         const code = this.legRoom.get(leg);
         this.legRoom.delete(leg);
         if (code === undefined)

package/dist/server.d.ts

@@ -134,6 +134,16 @@ export declare function safeJoin(rootDir: string, urlPath: string): string | nul
  */
 export type Loaded = Track & {
     group?: string;
+    /**
+     * Whether this has a picture, when the name could not say.
+     *
+     * A file on disk is named `film.mkv` and that is answer enough. A live
+     * stream is `http://host/tipoffsport/KEY/301`, which says nothing at all --
+     * so it was treated as audio, transcoded with `-vn`, and arrived as a
+     * football match somebody could only listen to. Asked of ffprobe once, when
+     * the source is added, rather than guessed from a URL that has no opinion.
+     */
+    picture?: boolean;
 };
 /** What the HTTP layer needs from a player. Tests hand it a fake. */
 export interface Engine {
@@ -181,6 +191,14 @@ export interface Engine {
 }
 export declare function toRemoteTracks(tracks: Loaded[]): RemoteTrack[];
 export declare function hasPicture(path: string): boolean;
+/**
+ * Whether the name of a source tells us anything about what is inside it.
+ *
+ * A remote address with no extension -- an IPTV channel, a stream key, a
+ * redirect -- is the case where it does not, and the only way to find out is
+ * to look.
+ */
+export declare function nameSaysNothing(path: string): boolean;
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on

package/dist/server.js

@@ -292,7 +292,8 @@ export function toRemoteTracks(tracks) {
         // Said out loud, because a remote cannot see the path and had been sending
         // every track to the audio element -- a film's soundtrack over a blank
         // panel, which is exactly what it looked like.
-        ...(hasPicture(t.path) ? { video: true } : {}),
+        // The name when it says something, what ffprobe found when it does not.
+        ...(t.picture ?? hasPicture(t.path) ? { video: true } : {}),
         // Only for what was added; the library's own tracks say nothing, which is
         // how a client knows they are the library.
         ...(t.group ? { group: t.group } : {}),
@@ -304,6 +305,24 @@ export function hasPicture(path) {
     const dot = path.lastIndexOf(".");
     return dot > 0 && PICTURE.has(path.slice(dot).toLowerCase());
 }
+/**
+ * Whether the name of a source tells us anything about what is inside it.
+ *
+ * A remote address with no extension -- an IPTV channel, a stream key, a
+ * redirect -- is the case where it does not, and the only way to find out is
+ * to look.
+ */
+export function nameSaysNothing(path) {
+    if (!isRemote(path))
+        return false;
+    try {
+        const last = new URL(path).pathname.split("/").pop() ?? "";
+        return !last.includes(".");
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
@@ -632,6 +651,14 @@ const CORS = {
     "access-control-allow-headers": "content-type",
     "access-control-max-age": "86400",
 };
+/**
+ * How many nameless addresses are worth an ffprobe when a source is added.
+ *
+ * One is the ordinary case -- somebody pasting a channel -- and a directory
+ * listing of thousands must not turn into thousands of probes for an answer
+ * that only changes which element a browser uses.
+ */
+const PROBE_BY_HAND = 8;
 /** /api/v1/<provider>/oauth/start and .../callback, the house callback shape. */
 const OAUTH_ROUTE = /^\/api\/v1\/([a-z0-9-]+)\/oauth\/(start|callback)$/;
 /**
@@ -1872,11 +1899,23 @@ export function createHandler(engine, options) {
                 return;
             }
             try {
-                const tracks = await options.load(source);
+                let tracks = await options.load(source);
                 if (tracks.length === 0) {
                     json(response, 422, { error: `nothing to play at ${source}` });
                     return;
                 }
+                // A handful of addresses whose names say nothing get asked what they
+                // are, so a live channel arrives as a picture rather than as its own
+                // soundtrack. Capped, because a playlist of five thousand of them is
+                // five thousand ffprobes and the answer only matters for the few a
+                // person adds by hand.
+                const looked = await Promise.all(tracks.map(async (track, at) => {
+                    if (at >= PROBE_BY_HAND || !nameSaysNothing(track.path))
+                        return track;
+                    const codecs = await codecsOf({ ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null }, track.path);
+                    return codecs.video === "" ? track : { ...track, picture: true };
+                }));
+                tracks = looked;
                 let added = tracks.length;
                 if (replacing) {
                     engine.replace(tracks, source);
@@ -1930,17 +1969,21 @@ export function createHandler(engine, options) {
             const capKbps = Number.isFinite(asked) && asked > 0 ? Math.min(20_000, Math.max(200, asked)) : 0;
             if (playsInBrowser(file) && capKbps === 0) {
                 sendFile(request, response, file);
+                return;
             }
-            else if (hasPicture(file)) {
-                // A film. It used to arrive as MP3 with `-vn`, which is to say as a
-                // soundtrack over a blank panel; what ffprobe finds inside decides how
-                // little work it takes to keep the picture.
+            // A film, or something whose name refuses to say. A live channel at
+            // .../301 used to fall through to the audio branch and arrive as MP3
+            // with `-vn` -- a match you could only listen to.
+            if (hasPicture(file) || nameSaysNothing(file)) {
+                // What ffprobe finds inside decides how little work it takes to keep
+                // the picture, and whether there is a picture to keep at all.
                 const codecs = await codecsOf({ ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null }, file);
-                pipeFfmpeg(request, response, file, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs, capKbps), "video/mp4");
-            }
-            else {
-                transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
+                if (codecs.video !== "") {
+                    pipeFfmpeg(request, response, file, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs, capKbps), "video/mp4");
+                    return;
+                }
             }
+            transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
             return;
         }
         // Whatever the source is, this comes back as MP3 a browser will play:

package/package.json

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

package/src/audio.ts

@@ -314,6 +314,17 @@ export interface Codecs {
   video: string;
   /** e.g. "aac", "ac3", "dts". Empty when there is no audio stream. */
   audio: string;
+  /**
+   * What is wrapped around them: "mpegts", "matroska,webm", "mov,mp4,...".
+   *
+   * It matters for one reason. A transport stream -- which is what every IPTV
+   * channel is -- frames its AAC as ADTS, and copying that into MP4 needs a
+   * bitstream filter or ffmpeg refuses the whole muxing and writes nothing.
+   * They also tend to carry several audio tracks, so the one ffmpeg picks can
+   * be AC-3 on the same URL that offered AAC a minute earlier, and AC-3 in MP4
+   * is a track no browser will play.
+   */
+  container: string;
 }
 
 /**
@@ -325,7 +336,7 @@ export interface Codecs {
  */
 export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
   const [cmd, ...rest] = tools.ffprobe;
-  const empty: Codecs = { video: "", audio: "" };
+  const empty: Codecs = { video: "", audio: "", container: "" };
   if (!cmd) return empty;
 
   return new Promise<Codecs>((done) => {
@@ -335,7 +346,7 @@ export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
         ...rest,
         "-v", "quiet",
         "-print_format", "json",
-        "-show_entries", "stream=codec_type,codec_name",
+        "-show_entries", "format=format_name:stream=codec_type,codec_name",
         path,
       ],
       { stdio: ["ignore", "pipe", "ignore"] },
@@ -347,11 +358,15 @@ export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
     child.on("error", () => done(empty));
     child.on("close", () => {
       try {
-        const parsed = JSON.parse(out) as { streams?: { codec_type?: string; codec_name?: string }[] };
+        const parsed = JSON.parse(out) as {
+          streams?: { codec_type?: string; codec_name?: string }[];
+          format?: { format_name?: string };
+        };
         const streams = parsed.streams ?? [];
         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 ?? "",
         });
       } catch {
         return done(empty);
@@ -376,7 +391,13 @@ export function videoArgs(codecs: Codecs, capKbps = 0): string[] {
 
   // What a browser can play inside MP4 without help.
   const keepVideo = codecs.video === "h264";
-  const keepAudio = codecs.audio === "aac" || codecs.audio === "mp3";
+  // A transport stream's audio is never copied. Its AAC is ADTS-framed, which
+  // MP4 refuses without a bitstream filter -- ffmpeg writes nothing at all and
+  // says "Malformed AAC bitstream detected" -- and the track ffmpeg picks off
+  // a channel with several of them can be AC-3, which that filter rejects and
+  // no browser plays. Re-encoding audio is cheap; this failing is total.
+  const transportStream = codecs.container.includes("mpegts");
+  const keepAudio = !transportStream && (codecs.audio === "aac" || codecs.audio === "mp3");
   return [
     "-c:v", keepVideo ? "copy" : "libx264",
     ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),

package/src/daemon.ts

@@ -38,6 +38,15 @@ export interface DaemonState {
    * interface, so it names the router and not this port.
    */
   guessedPublic?: boolean;
+  /**
+   * What it was started with, so it can be started that way again.
+   *
+   * A daemon serving TLS on a public name is six flags, and restarting it
+   * meant finding them again -- from shell history, or from `ps`, or not at
+   * all. Absent on a state file written by an older nixamp, which is why
+   * `restart` says so rather than starting something different.
+   */
+  argv?: string[];
 }
 
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
@@ -234,11 +243,37 @@ export async function start(argv: string[], entry: string): Promise<DaemonState>
     throw new Error(`nixamp: the daemon did not start. See ${log}`);
   }
 
-  const state: DaemonState = { ...announced, pid: child.pid, startedAt: Date.now(), log };
+  const state: DaemonState = { ...announced, pid: child.pid, startedAt: Date.now(), log, argv };
   writeState(state);
   return state;
 }
 
+/**
+ * Stop it and start it again, the way it was started.
+ *
+ * The flags are replayed from the state file rather than retyped, because the
+ * interesting daemons are the ones with the most flags: a certificate, a key,
+ * a public URL. Given arguments of its own it uses those instead, which is how
+ * you change one thing without stopping and starting by hand.
+ */
+export async function restart(
+  argv: string[],
+  entry: string,
+  /** Injected so a test can see which arguments would be replayed. */
+  starter: typeof start = start,
+): Promise<DaemonState> {
+  const { state } = status();
+  const before = state?.argv;
+  if (argv.length === 0 && before === undefined && state !== null) {
+    throw new Error(
+      "nixamp: this daemon was started by an older nixamp, which did not record its flags. " +
+        "Stop it and start it again with the flags you want.",
+    );
+  }
+  await stop();
+  return starter(argv.length > 0 ? argv : (before ?? []), entry);
+}
+
 /** Poll the log for the announce line. */
 async function waitForAnnounce(
   log: string,