nixamp 0.10.2 → 0.11.0

package/dist/audio.js

@@ -408,7 +408,11 @@ export function videoArgs(codecs, capKbps = 0) {
     const keepAudio = !transportStream && (codecs.audio === "aac" || codecs.audio === "mp3");
     return [
         "-c:v", keepVideo ? "copy" : "libx264",
-        ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),
+        // A keyframe every two seconds when encoding. A fragment starts on a
+        // keyframe, so this is how soon a joiner sees a picture -- and an HLS
+        // segment, which is cut on keyframes too, was ten seconds long on
+        // x264's default and made a phone wait thirty before it played.
+        ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p", "-g", "48", "-keyint_min", "48", "-sc_threshold", "0"]),
         "-c:a", keepAudio ? "copy" : "aac",
         ...(keepAudio ? [] : ["-b:a", "160k", "-ac", "2"]),
         "-f", "mp4",

package/dist/enrich.d.ts

@@ -0,0 +1,108 @@
+/** Where the answers come from, unless a deployment says otherwise. */
+export declare const DEFAULT_SITE = "https://nichedb.dev";
+/** How long a hit is believed. Titles and channels change on the order of months. */
+export declare const HIT_TTL_MS: number;
+/** How long a miss is believed: nichedb's catalogue is still filling in. */
+export declare const MISS_TTL_MS: number;
+/** A fixture's score is stale in a minute. */
+export declare const FIXTURE_TTL_MS: number;
+/**
+ * Below this the best match is a guess, and a wrong poster is worse than none.
+ * Measured: "Severance" against a channel called "Sever" scored 0.45, and
+ * "Lakers at Celtics" against "Rangers at Celtic" 0.44. Half is above both.
+ */
+export declare const MIN_SCORE = 0.5;
+/** A weaker score is still taken when one name plainly begins with the other. */
+export declare const PREFIX_SCORE = 0.42;
+/** How many answers the cache keeps before the oldest go. */
+export declare const MAX_ENTRIES = 5000;
+export type EnrichKind = "auto" | "title" | "channel" | "fixture";
+export interface Enriched {
+    /** What nichedb says it is. */
+    kind: "title" | "channel" | "fixture";
+    title: string;
+    /** For a title, its year; for a fixture, when it starts. */
+    year: number | null;
+    /** A poster, a logo, or nothing. */
+    image: string | null;
+    summary: string | null;
+    /** nichedb's page for it, for a link. */
+    page: string;
+    score: number;
+    /** The rest, as the collection shapes it: rating, genres, country, scores… */
+    data: Record<string, unknown>;
+    tags: string[];
+}
+interface Cached {
+    at: number;
+    hit: Enriched | null;
+}
+/** nichedb's answer to /api/v1/match, as much of it as is read here. */
+interface MatchAnswer {
+    parsed?: {
+        name?: string;
+        year?: number | null;
+        kind?: string;
+        season?: number | null;
+        episode?: number | null;
+    };
+    items?: {
+        kind?: string;
+        title?: string;
+        summary?: string | null;
+        image_url?: string | null;
+        published_at?: string | null;
+        page?: string;
+        score?: number;
+        data?: Record<string, unknown>;
+        tags?: string[];
+    }[];
+}
+/** The collection and kind a name is asked about, from what the caller knows. */
+export declare function whereToAsk(kind: EnrichKind, parsedKind?: string): {
+    collection: string;
+    kind: string;
+} | null;
+/** The key one name is remembered under: case and spacing do not make it a different name. */
+export declare function cacheKey(name: string, kind: EnrichKind, year: number | null): string;
+/** Whether a stored answer is still worth believing. */
+export declare function fresh(entry: Cached, now: number): boolean;
+/** The best of nichedb's answers, or nothing when the best is a guess. */
+export declare function pickBest(answer: MatchAnswer, asked: string): Enriched | null;
+export interface EnricherOptions {
+    site?: string;
+    fetch?: typeof globalThis.fetch;
+    /** Where answers are kept between runs; none means memory only. */
+    cacheFile?: string;
+    now?: () => number;
+    onEvent?: (message: string) => void;
+}
+export declare class Enricher {
+    private readonly options;
+    private readonly site;
+    private readonly fetcher;
+    private readonly now;
+    private readonly cache;
+    private readonly inflight;
+    private saveTimer;
+    private dirty;
+    constructor(options?: EnricherOptions);
+    /** How many names are remembered. */
+    get size(): number;
+    /**
+     * What a name is, from the cache or from nichedb.
+     *
+     * `kind` narrows the question when the caller knows: a live channel is a
+     * channel however its name reads. `auto` lets nichedb's parser decide from
+     * the name itself, which is right for a file.
+     */
+    lookup(name: string, kind?: EnrichKind, year?: number | null): Promise<Enriched | null>;
+    private ask;
+    private get;
+    private remember;
+    private load;
+    private scheduleSave;
+    /** Write the cache now. Called on a timer, and by whoever is shutting down. */
+    save(): void;
+}
+export {};

package/dist/enrich.js

@@ -0,0 +1,249 @@
+/**
+ * What is this, really?
+ *
+ * A file called "Top.Gun.Maverick.2022.1080p.WEB-DL.mkv" is a film with a
+ * poster, a year and a rating; a playlist entry called "US: ESPN2 HD" is a
+ * channel with a logo, a country and a category; "Lakers at Celtics" is a
+ * fixture with a score. nixamp knows none of that on its own -- ffprobe reads
+ * tags, and a torrent's tags are its file name -- so it asks nichedb.dev,
+ * which keeps the titles, channels and fixtures every profullstack site is
+ * built on, and answers a name with the best match and a score.
+ *
+ * Asked once per name and remembered: a library of five thousand files must
+ * not become five thousand requests a day, and a channel that was ESPN2
+ * yesterday is ESPN2 today. Misses are remembered too, for less long, so a
+ * file nichedb has never heard of is not asked about every time it plays.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/** Where the answers come from, unless a deployment says otherwise. */
+export const DEFAULT_SITE = "https://nichedb.dev";
+/** How long a hit is believed. Titles and channels change on the order of months. */
+export const HIT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/** How long a miss is believed: nichedb's catalogue is still filling in. */
+export const MISS_TTL_MS = 6 * 60 * 60 * 1000;
+/** A fixture's score is stale in a minute. */
+export const FIXTURE_TTL_MS = 60 * 1000;
+/**
+ * Below this the best match is a guess, and a wrong poster is worse than none.
+ * Measured: "Severance" against a channel called "Sever" scored 0.45, and
+ * "Lakers at Celtics" against "Rangers at Celtic" 0.44. Half is above both.
+ */
+export const MIN_SCORE = 0.5;
+/** A weaker score is still taken when one name plainly begins with the other. */
+export const PREFIX_SCORE = 0.42;
+/** How many answers the cache keeps before the oldest go. */
+export const MAX_ENTRIES = 5000;
+/** The collection and kind a name is asked about, from what the caller knows. */
+export function whereToAsk(kind, parsedKind) {
+    const k = kind === "auto" ? parsedKind ?? "" : kind;
+    switch (k) {
+        case "channel":
+            return { collection: "channels", kind: "channel" };
+        case "fixture":
+            return { collection: "sports", kind: "fixture" };
+        case "title":
+        case "movie":
+        case "series":
+            return { collection: "screen", kind: "title" };
+        default:
+            // Music and the rest: nichedb has no answer worth a poster yet.
+            return null;
+    }
+}
+/** The key one name is remembered under: case and spacing do not make it a different name. */
+export function cacheKey(name, kind, year) {
+    return `${kind}|${year ?? ""}|${name.trim().toLowerCase().replace(/\s+/g, " ")}`;
+}
+/** Whether a stored answer is still worth believing. */
+export function fresh(entry, now) {
+    const ttl = entry.hit === null ? MISS_TTL_MS : entry.hit.kind === "fixture" ? FIXTURE_TTL_MS : HIT_TTL_MS;
+    return now - entry.at < ttl;
+}
+/** The best of nichedb's answers, or nothing when the best is a guess. */
+export function pickBest(answer, asked) {
+    const items = answer.items ?? [];
+    const wanted = asked.trim().toLowerCase();
+    let best;
+    const isExact = (item) => item !== undefined && String(item.title ?? "").toLowerCase() === wanted;
+    const plain = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+    const askedPlain = plain(wanted);
+    for (const item of items) {
+        const exact = isExact(item);
+        const score = Number(item.score ?? 0);
+        const titlePlain = plain(String(item.title ?? ""));
+        // Whole words: "Top Gun Maverick Extended" begins with "Top Gun Maverick",
+        // but "Severance" does not begin with a channel called "Sever".
+        const prefix = titlePlain.length >= 4 &&
+            askedPlain.length >= 4 &&
+            (askedPlain.startsWith(`${titlePlain} `) || titlePlain.startsWith(`${askedPlain} `));
+        if (!exact && score < (prefix ? PREFIX_SCORE : MIN_SCORE))
+            continue;
+        // An exact title beats any score; among the rest, the score decides.
+        if (!best)
+            best = item;
+        else if (exact && !isExact(best))
+            best = item;
+        else if (!isExact(best) && score > Number(best.score ?? 0))
+            best = item;
+    }
+    if (!best)
+        return null;
+    const kind = best.kind === "channel" || best.kind === "fixture" ? best.kind : "title";
+    const year = typeof best.data?.["year"] === "number"
+        ? best.data["year"]
+        : best.published_at
+            ? new Date(best.published_at).getUTCFullYear() || null
+            : null;
+    return {
+        kind,
+        title: String(best.title ?? ""),
+        year: Number.isFinite(year) ? year : null,
+        image: best.image_url ?? null,
+        summary: best.summary ?? null,
+        page: String(best.page ?? ""),
+        score: Number(best.score ?? 0),
+        data: best.data ?? {},
+        tags: best.tags ?? [],
+    };
+}
+export class Enricher {
+    options;
+    site;
+    fetcher;
+    now;
+    cache = new Map();
+    inflight = new Map();
+    saveTimer = null;
+    dirty = false;
+    constructor(options = {}) {
+        this.options = options;
+        this.site = (options.site ?? DEFAULT_SITE).replace(/\/+$/, "");
+        this.fetcher = options.fetch ?? globalThis.fetch;
+        this.now = options.now ?? Date.now;
+        this.load();
+    }
+    /** How many names are remembered. */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * What a name is, from the cache or from nichedb.
+     *
+     * `kind` narrows the question when the caller knows: a live channel is a
+     * channel however its name reads. `auto` lets nichedb's parser decide from
+     * the name itself, which is right for a file.
+     */
+    async lookup(name, kind = "auto", year = null) {
+        const asked = String(name ?? "").trim();
+        if (asked === "")
+            return null;
+        const key = cacheKey(asked, kind, year);
+        const had = this.cache.get(key);
+        if (had && fresh(had, this.now()))
+            return had.hit;
+        const running = this.inflight.get(key);
+        if (running)
+            return running;
+        const work = this.ask(asked, kind, year)
+            .then((hit) => {
+            this.remember(key, hit);
+            return hit;
+        })
+            .catch((error) => {
+            this.options.onEvent?.(`  nichedb did not answer for "${asked}": ${error.message}`);
+            // Not remembered: a network fault is not a miss.
+            return had?.hit ?? null;
+        })
+            .finally(() => this.inflight.delete(key));
+        this.inflight.set(key, work);
+        return work;
+    }
+    async ask(name, kind, year) {
+        // Two round trips at most: nichedb parses the name; when the caller did
+        // not say what it is, the first answer's reading says where to look.
+        const first = new URLSearchParams({ q: name, limit: "3" });
+        if (year !== null)
+            first.set("year", String(year));
+        const where = whereToAsk(kind);
+        if (where) {
+            first.set("collection", where.collection);
+            first.set("kind", where.kind);
+        }
+        const answer = await this.get(`/api/v1/match?${first}`);
+        if (where)
+            return pickBest(answer, answer.parsed?.name ?? name);
+        const guessed = whereToAsk("auto", answer.parsed?.kind);
+        if (!guessed)
+            return null;
+        const second = new URLSearchParams(first);
+        second.set("collection", guessed.collection);
+        second.set("kind", guessed.kind);
+        // The year the name carried narrows the second question.
+        if (year === null && answer.parsed?.year)
+            second.set("year", String(answer.parsed.year));
+        return pickBest(await this.get(`/api/v1/match?${second}`), answer.parsed?.name ?? name);
+    }
+    async get(path) {
+        const response = await this.fetcher(`${this.site}${path}`, {
+            headers: { accept: "application/json", "user-agent": "nixamp (+https://nixamp.com)" },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok)
+            throw new Error(`nichedb answered ${response.status}`);
+        return (await response.json());
+    }
+    remember(key, hit) {
+        this.cache.set(key, { at: this.now(), hit });
+        if (this.cache.size > MAX_ENTRIES) {
+            // Oldest first: a Map remembers insertion order.
+            const drop = this.cache.size - MAX_ENTRIES;
+            let n = 0;
+            for (const k of this.cache.keys()) {
+                if (n++ >= drop)
+                    break;
+                this.cache.delete(k);
+            }
+        }
+        this.dirty = true;
+        this.scheduleSave();
+    }
+    load() {
+        if (!this.options.cacheFile)
+            return;
+        try {
+            const parsed = JSON.parse(readFileSync(this.options.cacheFile, "utf8"));
+            for (const [k, v] of Object.entries(parsed)) {
+                if (v && typeof v.at === "number")
+                    this.cache.set(k, v);
+            }
+        }
+        catch {
+            // No cache yet, or one that is not JSON: start empty.
+        }
+    }
+    scheduleSave() {
+        if (!this.options.cacheFile || this.saveTimer)
+            return;
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            this.save();
+        }, 2000);
+        this.saveTimer.unref?.();
+    }
+    /** Write the cache now. Called on a timer, and by whoever is shutting down. */
+    save() {
+        if (!this.options.cacheFile || !this.dirty)
+            return;
+        try {
+            mkdirSync(dirname(this.options.cacheFile), { recursive: true });
+            const tmp = `${this.options.cacheFile}.tmp`;
+            writeFileSync(tmp, JSON.stringify(Object.fromEntries(this.cache)));
+            renameSync(tmp, this.options.cacheFile);
+            this.dirty = false;
+        }
+        catch (error) {
+            this.options.onEvent?.(`  could not save the enrichment cache: ${error.message}`);
+        }
+    }
+}

package/dist/hls.d.ts

@@ -0,0 +1,55 @@
+/** Seconds of video per segment. Short, so joining is quick; long enough that a playlist is not churn. */
+export declare const SEGMENT_SECONDS = 2;
+/** How many segments the playlist offers. About twelve seconds of catch-up. */
+export declare const PLAYLIST_SEGMENTS = 6;
+/** How long a packager runs with nobody asking for its playlist. */
+export declare const IDLE_MS = 60000;
+/** How long the first playlist may take to appear before it is a failure. */
+export declare const FIRST_PLAYLIST_MS = 20000;
+/** A segment file name, or "" for anything that is not one. Never a path. */
+export declare function segmentName(requested: string): string;
+/**
+ * The playlist with the key on every segment.
+ *
+ * A browser resolves segment names against the playlist's URL and drops its
+ * query, so the key that opened the playlist never reaches the segments and
+ * each one answers 401. The key travels on every line instead.
+ */
+export declare function withKey(playlist: string, key: string): string;
+/** The ffmpeg arguments: copy what arrives on stdin into a rolling playlist. */
+export declare function packagerArgs(dir: string): string[];
+export interface Packaged {
+    /** Feed it the channel's bytes: the header first, then every fragment. */
+    write(chunk: Buffer): boolean;
+    /** The channel ended; finish and stop. */
+    end(): void;
+}
+/**
+ * The packagers, one per channel that somebody is watching this way.
+ *
+ * `listen` is how a packager becomes a listener on its channel: it is handed
+ * the header and then every fragment, exactly as a browser would be.
+ */
+export declare class HlsPackagers {
+    private readonly options;
+    private readonly running;
+    constructor(options: {
+        ffmpeg: string[];
+        listen: (id: string, listener: Packaged) => (() => void) | null;
+        onEvent?: (message: string) => void;
+        /** Injected for tests: how long to wait for the first playlist. */
+        firstPlaylistMs?: number;
+    });
+    /**
+     * The playlist for a channel, starting the packager if it is not running,
+     * and waiting for the first segments to exist. Null when the channel is not
+     * there or nothing could be packaged.
+     */
+    playlist(id: string): Promise<string | null>;
+    /** A segment's path, or "" when there is no such segment. */
+    segment(id: string, name: string): string;
+    /** The channel went: stop packaging it. */
+    stop(id: string): void;
+    stopAll(): void;
+    get count(): number;
+}

package/dist/hls.js

@@ -0,0 +1,254 @@
+/**
+ * A channel as HLS, for the browsers that will not take it any other way.
+ *
+ * A channel is sent as one endless fragmented MP4 down a chunked response,
+ * which Chrome and Firefox play as they would a file. Safari on an iPhone
+ * will not: it asks for a byte range, gets a stream with no length, and gives
+ * up before the first picture -- a spinner that flashes and a player that
+ * never starts. What Safari plays live is HLS, a playlist of short files.
+ *
+ * So this packages the same bytes into HLS on demand: one ffmpeg per channel,
+ * copying (never re-encoding) the fragments it is fed into two-second
+ * MPEG-TS segments in a temporary directory, started when the first playlist
+ * is asked for and stopped a minute after the last. The channel itself is
+ * untouched; this is one more listener on it.
+ */
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Seconds of video per segment. Short, so joining is quick; long enough that a playlist is not churn. */
+export const SEGMENT_SECONDS = 2;
+/** How many segments the playlist offers. About twelve seconds of catch-up. */
+export const PLAYLIST_SEGMENTS = 6;
+/** How long a packager runs with nobody asking for its playlist. */
+export const IDLE_MS = 60_000;
+/** How long the first playlist may take to appear before it is a failure. */
+export const FIRST_PLAYLIST_MS = 20_000;
+const SEGMENT = /^seg\d{5}\.ts$/;
+/** A segment file name, or "" for anything that is not one. Never a path. */
+export function segmentName(requested) {
+    return SEGMENT.test(requested) ? requested : "";
+}
+/**
+ * The playlist with the key on every segment.
+ *
+ * A browser resolves segment names against the playlist's URL and drops its
+ * query, so the key that opened the playlist never reaches the segments and
+ * each one answers 401. The key travels on every line instead.
+ */
+export function withKey(playlist, key) {
+    if (key === "")
+        return playlist;
+    return playlist
+        .split("\n")
+        .map((line) => (line !== "" && !line.startsWith("#") ? `${line}?k=${encodeURIComponent(key)}` : line))
+        .join("\n");
+}
+/** The ffmpeg arguments: copy what arrives on stdin into a rolling playlist. */
+export function packagerArgs(dir) {
+    return [
+        "-hide_banner",
+        "-loglevel", "error",
+        "-i", "pipe:0",
+        "-c", "copy",
+        "-f", "hls",
+        "-hls_time", String(SEGMENT_SECONDS),
+        "-hls_list_size", String(PLAYLIST_SEGMENTS),
+        // Old segments go; the playlist never ends; each segment starts on a
+        // keyframe so a joiner can begin anywhere; written whole then renamed so
+        // a request never reads half a file.
+        "-hls_flags", "delete_segments+omit_endlist+independent_segments+temp_file",
+        "-hls_segment_type", "mpegts",
+        "-hls_segment_filename", join(dir, "seg%05d.ts"),
+        join(dir, "index.m3u8"),
+    ];
+}
+/** One channel's packager. */
+class Packager {
+    id;
+    ffmpeg;
+    onStop;
+    onEvent;
+    dir;
+    child = null;
+    idle = null;
+    stopped = false;
+    detach = null;
+    constructor(id, ffmpeg, onStop, onEvent) {
+        this.id = id;
+        this.ffmpeg = ffmpeg;
+        this.onStop = onStop;
+        this.onEvent = onEvent;
+        this.dir = mkdtempSync(join(tmpdir(), `nixamp-hls-${id}-`));
+    }
+    start(listen) {
+        const [command, ...prefix] = this.ffmpeg;
+        try {
+            this.child = spawn(command, [...prefix, ...packagerArgs(this.dir)], { stdio: ["pipe", "ignore", "pipe"] });
+        }
+        catch (error) {
+            this.onEvent(`  HLS for "${this.id}" could not start: ${error.message}`);
+            this.stop();
+            return false;
+        }
+        let complaint = "";
+        this.child.stderr?.on("data", (chunk) => {
+            if (complaint.length < 4000)
+                complaint += chunk.toString("utf8");
+        });
+        this.child.stdin?.on("error", () => undefined);
+        this.child.on("error", (error) => {
+            this.onEvent(`  HLS for "${this.id}" failed: ${error.message}`);
+            this.stop();
+        });
+        this.child.on("close", (code) => {
+            if (!this.stopped && code !== 0) {
+                this.onEvent(`  HLS for "${this.id}" stopped: ${complaint.trim().split("\n").pop() ?? code}`);
+            }
+            this.stop();
+        });
+        this.detach = listen(this);
+        if (this.detach === null) {
+            this.stop();
+            return false;
+        }
+        this.touch();
+        return true;
+    }
+    write(chunk) {
+        const stdin = this.child?.stdin;
+        if (!stdin || stdin.destroyed)
+            return false;
+        try {
+            stdin.write(chunk);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    end() {
+        try {
+            this.child?.stdin?.end();
+        }
+        catch {
+            // Already gone.
+        }
+        this.stop();
+    }
+    /** Somebody asked for the playlist: it is wanted for another minute. */
+    touch() {
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = setTimeout(() => this.stop(), IDLE_MS);
+        this.idle.unref?.();
+    }
+    /** The playlist as it stands, or "" before the first segment is written. */
+    playlist() {
+        try {
+            const text = readFileSync(join(this.dir, "index.m3u8"), "utf8");
+            return text.includes("#EXTINF") ? text : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    /** A segment's path, or "" when it is not there (any more). */
+    segment(name) {
+        const safe = segmentName(name);
+        if (safe === "")
+            return "";
+        const path = join(this.dir, safe);
+        try {
+            return statSync(path).isFile() ? path : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = null;
+        this.detach?.();
+        this.detach = null;
+        const child = this.child;
+        this.child = null;
+        if (child && child.exitCode === null) {
+            try {
+                child.stdin?.end();
+                child.kill("SIGKILL");
+            }
+            catch {
+                // Already gone.
+            }
+        }
+        try {
+            rmSync(this.dir, { recursive: true, force: true });
+        }
+        catch {
+            // A directory that is already gone is fine.
+        }
+        this.onStop(this.id);
+    }
+}
+/**
+ * The packagers, one per channel that somebody is watching this way.
+ *
+ * `listen` is how a packager becomes a listener on its channel: it is handed
+ * the header and then every fragment, exactly as a browser would be.
+ */
+export class HlsPackagers {
+    options;
+    running = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * The playlist for a channel, starting the packager if it is not running,
+     * and waiting for the first segments to exist. Null when the channel is not
+     * there or nothing could be packaged.
+     */
+    async playlist(id) {
+        let packager = this.running.get(id);
+        if (!packager) {
+            packager = new Packager(id, this.options.ffmpeg, (gone) => this.running.delete(gone), this.options.onEvent ?? (() => undefined));
+            this.running.set(id, packager);
+            if (!packager.start((listener) => this.options.listen(id, listener)))
+                return null;
+        }
+        packager.touch();
+        const deadline = Date.now() + (this.options.firstPlaylistMs ?? FIRST_PLAYLIST_MS);
+        for (;;) {
+            const text = packager.playlist();
+            if (text !== "")
+                return text;
+            if (Date.now() > deadline || !this.running.has(id))
+                return null;
+            await new Promise((done) => setTimeout(done, 250));
+        }
+    }
+    /** A segment's path, or "" when there is no such segment. */
+    segment(id, name) {
+        const packager = this.running.get(id);
+        if (!packager)
+            return "";
+        packager.touch();
+        return packager.segment(name);
+    }
+    /** The channel went: stop packaging it. */
+    stop(id) {
+        this.running.get(id)?.stop();
+    }
+    stopAll() {
+        for (const packager of [...this.running.values()])
+            packager.stop();
+    }
+    get count() {
+        return this.running.size;
+    }
+}