nixamp 0.7.4 → 0.7.6

package/README.md

@@ -354,8 +354,14 @@ anywhere else with `--url` and `--key`.
 ╰───────────────────────────────────────────────────────────────────────╯
 ```
 
-Press `r` to re-stream: hand the running server a different URL or path and the
-listeners stay connected while what they are hearing changes under them.
+Press `a` to add: hand the running server a folder, an album URL or a file and
+it joins the playlist under its own heading, with the library still there and
+the listeners still connected. Press `r` to replace instead, which is the
+bigger thing — this server now serves that, and the library it had is gone
+until you restart it.
+
+An added block can be taken back out from the playlist itself: its heading
+carries an `×`.
 
 ## How it works
 

package/dist/admin.d.ts

@@ -68,6 +68,8 @@ export interface View {
     error: string;
     typing: boolean;
     restreaming: string;
+    /** Whether what is being typed replaces the playlist rather than joining it. */
+    replacing?: boolean;
     /** Labelled addresses, and the key that makes them work. */
     links: {
         label: string;

package/dist/admin.js

@@ -110,6 +110,9 @@ export async function admin(argv) {
     let snapshot = null;
     let error = "";
     let restreaming = "";
+    // Which of the two things typing a source means. Adding is the ordinary one
+    // and has its own key; replacing throws the library away, so it has another.
+    let replacing = false;
     let typing = false;
     const app = await createApp({ theme: themes.matrix, title: "nixamp admin", quitKeys: ["ctrl+c"] });
     const refresh = async () => {
@@ -129,13 +132,16 @@ export async function admin(argv) {
             if (key === "escape") {
                 typing = false;
                 restreaming = "";
+                replacing = false;
             }
             else if (key === "enter") {
                 const url = restreaming.trim();
+                const asReplacement = replacing;
                 typing = false;
                 restreaming = "";
+                replacing = false;
                 if (url)
-                    void restream(target, headers, url).then(() => refresh());
+                    void restream(target, headers, url, asReplacement).then(() => refresh());
             }
             else if (key === "backspace")
                 restreaming = restreaming.slice(0, -1);
@@ -148,26 +154,38 @@ export async function admin(argv) {
             app.quit();
             return;
         }
+        if (key === "a") {
+            typing = true;
+            replacing = false;
+            app.invalidate();
+        }
         if (key === "r") {
             typing = true;
+            replacing = true;
             app.invalidate();
         }
     });
     app.on("exit", () => clearInterval(timer));
     app.render(({ ui, theme }) => draw(ui, theme, {
-        url: target.url, report, snapshot, error, typing, restreaming,
+        url: target.url, report, snapshot, error, typing, restreaming, replacing,
         links: target.links, key: target.key, source: target.source,
     }));
     await app.start();
     clearInterval(timer);
 }
-/** Ask the server to play something else, which is what re-streaming is. */
-async function restream(target, headers, url) {
+/**
+ * Hand the server something else to play.
+ *
+ * Two different asks down one route: adding puts an album on the end of the
+ * playlist, replacing points the server somewhere else entirely. The server
+ * adds unless told otherwise, so only the second one says anything.
+ */
+async function restream(target, headers, url, replacing = false) {
     try {
         await fetch(`${target.url}/api/source`, {
             method: "POST",
             headers: { ...headers, "content-type": "application/json" },
-            body: JSON.stringify({ source: url }),
+            body: JSON.stringify({ source: url, ...(replacing ? { replace: true } : {}) }),
         });
     }
     catch {
@@ -249,14 +267,20 @@ export function draw(ui, theme, view) {
         });
     });
     if (view.typing) {
-        ui.panel({ title: "Re-stream a URL or a path", size: 4 }, (p) => {
+        ui.panel({
+            title: view.replacing ? "Replace the playlist with a URL or a path" : "Add a URL or a path",
+            size: 4,
+        }, (p) => {
             p.text(`${view.restreaming}_`, { fg: theme.accent });
-            p.label("Enter plays it here. Escape forgets it.");
+            p.label(view.replacing
+                ? "Enter drops this library and serves that instead. Escape forgets it."
+                : "Enter adds it to the playlist. Escape forgets it.");
         });
     }
     ui.statusBar({
         items: [
-            { key: "r", label: "Re-stream" },
+            { key: "a", label: "Add" },
+            { key: "r", label: "Replace" },
             { key: "q", label: "Quit" },
         ],
         right: [{ key: "", label: report ? `${report.connections.length} seen` : "connecting" }],

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/protocol.d.ts

@@ -20,6 +20,14 @@ export interface RemoteTrack {
      * a browser could show played its soundtrack over a blank panel.
      */
     video?: boolean;
+    /**
+     * The source this track came in with, when it was not part of the library.
+     *
+     * Absent means it belongs to whatever this server was started on. Present
+     * means somebody added a folder or an album afterwards, and the name is what
+     * a client puts at the top of that block so the two are not one soup.
+     */
+    group?: string;
 }
 /** Everything a remote needs to draw the player. */
 export interface Snapshot {

package/dist/server.d.ts

@@ -124,6 +124,27 @@ export declare function parseRange(header: string | undefined, size: number): By
  * `..` in a request path is the oldest bug in static file serving.
  */
 export declare function safeJoin(rootDir: string, urlPath: string): string | null;
+/**
+ * A track and the source it arrived with.
+ *
+ * The library a server was started on has no group: it is simply what this
+ * machine has. Anything added afterwards carries the name of the folder or
+ * album it came from, which is what lets a client draw the two apart instead
+ * of running them together.
+ */
+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 {
     /** `withTracks` false leaves the library out, for a frame that is only motion. */
@@ -133,11 +154,29 @@ export interface Engine {
     /** Absolute path of a track, or undefined when the index is not one. */
     trackPath(index: number): string | undefined;
     /**
-     * Play something else instead. Re-streaming is the whole reason the admin
-     * view exists: point a running server at a URL without restarting it and
-     * dropping every listener.
+     * Play something else instead of everything here.
+     *
+     * The big hammer, and no longer what adding a folder does: this is "point
+     * this server somewhere else", which throws the library away on purpose.
      */
     replace(tracks: Track[], root: string): void;
+    /**
+     * Play something as well as everything here.
+     *
+     * What somebody means by putting a folder in a box: the album shows up at
+     * the bottom of the playlist under its own name, and the music that was
+     * already there is still there. Answers how many tracks were new.
+     */
+    add(tracks: Track[], from: string): number;
+    /**
+     * Take an added source back out again, by the name `add` gave it.
+     *
+     * Nothing that came with the library can be dropped this way; the library is
+     * what the server is, and there is a command line for changing that.
+     */
+    drop(group: string): number;
+    /** Every added source, in the order they were added. */
+    groups(): string[];
     /**
      * The same tracks, now with their tags.
      *
@@ -150,8 +189,16 @@ export interface Engine {
     retag(tracks: Track[], root: string): void;
     stop(): void;
 }
-export declare function toRemoteTracks(tracks: Track[]): RemoteTrack[];
+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
@@ -172,7 +219,7 @@ export declare class PlayerEngine implements Engine {
     private timer;
     private dirty;
     private state;
-    constructor(tracks: Track[], root: string, tools: Tools, 
+    constructor(tracks: Loaded[], root: string, tools: Tools, 
     /** Frames a second pushed to remotes. */
     fps?: number);
     private readonly silent;
@@ -199,6 +246,30 @@ export declare class PlayerEngine implements Engine {
     private push;
     stop(): void;
     replace(tracks: Track[], root: string): void;
+    /**
+     * Load something as well as what is already here.
+     *
+     * Adding a folder used to be `replace`, so pointing a server at an album on
+     * the web threw away the music on its disk: the playlist you were looking at
+     * turned into somebody else's twenty-eight tracks, and clicking your own
+     * files played theirs. Nothing about playback changes here -- whatever was
+     * playing keeps playing, at the same index, because the new tracks go on the
+     * end.
+     *
+     * Paths already loaded are skipped, so adding the same album twice is not
+     * two copies of it.
+     */
+    add(tracks: Track[], from: string): number;
+    /**
+     * Take an added source back out.
+     *
+     * The track that is playing is followed rather than an index: removing an
+     * album from above the current track would otherwise slide the playlist out
+     * from under a listener mid-song. If the playing track is itself in what is
+     * being removed, playback stops -- there is nothing to keep playing.
+     */
+    drop(group: string): number;
+    groups(): string[];
     retag(tracks: Track[], root: string): void;
 }
 /** An engine with no library behind it, for the hosted PWA. */
@@ -210,6 +281,9 @@ export declare class EmptyEngine implements Engine {
     subscribe(listener: (snapshot: Snapshot) => void): () => void;
     trackPath(): undefined;
     replace(): void;
+    add(): number;
+    drop(): number;
+    groups(): string[];
     retag(): void;
     stop(): void;
 }