nixamp 0.28.44 → 0.29.1

package/dist/playlist-input.js

@@ -1,5 +1,12 @@
 import { spawn } from "node:child_process";
+import { protocolArgs } from "./decoder-policy.js";
 import { codecsOf } from "./audio.js";
+/**
+ * How many entries in a row may fail before the list is given up on. A
+ * corrupt file is skipped; a list where nothing plays is an error, said once,
+ * not a loop.
+ */
+export const MAX_FAILURES_IN_A_ROW = 5;
 /** Decode each file independently; feed one persistent muxer a fixed stream
  * profile and continuous timestamps. A concat demuxer cannot decode a list
  * whose input codecs differ. Only one entry is encoded at a time, with pipe
@@ -12,11 +19,26 @@ export class PlaylistInputStream {
     constructor(options) {
         this.options = options;
     }
+    /** Every entry that has started, in the order it started, with where it sits in the stream. */
+    get history() {
+        return this.entries;
+    }
     place(seconds) {
         const entry = this.entries.findLast(one => seconds >= one.start) ?? this.entries[0];
         return entry ? { at: entry.at, position: Math.max(0, seconds - entry.start + entry.position) }
             : { at: this.options.at, position: this.options.position };
     }
+    /** The decoder for the entry that is on, so skip() can end it early. */
+    stopCurrent = null;
+    skipping = false;
+    /** End the entry that is on and go to the next. False when nothing is on. */
+    skip() {
+        if (!this.stopCurrent)
+            return false;
+        this.skipping = true;
+        this.stopCurrent();
+        return true;
+    }
     async *open(signal) {
         const o = this.options;
         const [command, ...prefix] = o.ffmpeg;
@@ -24,66 +46,148 @@ export class PlaylistInputStream {
         const width = Math.max(2, Math.floor((o.width || 1280) * ratio / 2) * 2);
         const height = Math.max(2, Math.floor((o.height || 720) * ratio / 2) * 2);
         let offset = 0;
+        let failuresInARow = 0;
+        let first = true;
         try {
-            for (let at = o.at; at < o.files.length && !signal.aborted; at++) {
-                const file = o.files[at];
-                const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
+            const orderFor = (list) => o.order ? o.order(list.length).filter((one) => one >= 0 && one < list.length) : list.map((_, index) => index);
+            let files = o.current?.() ?? o.files;
+            if (files.length === 0)
+                throw new Error("The playlist is empty");
+            let order = orderFor(files);
+            let step = Math.min(o.at, order.length);
+            let played = 0;
+            let last = "";
+            for (;;) {
                 if (signal.aborted)
-                    return;
-                if (!codecs.audio && !codecs.video)
-                    throw new Error(`Cannot decode playlist entry ${at + 1}`);
-                const position = at === o.at ? o.position : 0;
-                const duration = (codecs.duration ?? 0) - position;
-                if (duration <= 0)
-                    throw new Error(`No playable duration for playlist entry ${at + 1}`);
-                this.entries.push({ at, start: offset, position });
-                const hasVideo = Boolean(codecs.video);
-                const extra = o.video && !hasVideo
-                    ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]
-                    : o.video && !codecs.audio ? ["-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo"] : [];
-                const args = [
-                    ...prefix, "-hide_banner", "-loglevel", "error", "-nostdin", "-filter_threads", "2",
-                    "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), "-i", file,
-                    ...extra, "-t", String(duration),
-                    ...(o.video ? [
-                        "-map", hasVideo ? "0:v:0" : "1:v:0", "-map", codecs.audio ? "0:a:0" : "1:a:0",
-                        "-vf", `fps=30,scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1,setpts=PTS-STARTPTS`,
-                        "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-tune", "zerolatency",
-                        "-crf", "23", "-pix_fmt", "yuv420p", "-g", "60", "-keyint_min", "60", "-sc_threshold", "0",
-                    ] : ["-map", "0:a:0", "-vn"]),
-                    "-af", "aresample=48000,asetpts=PTS-STARTPTS", "-c:a", "aac", "-b:a", "160k", "-ac", "2",
-                    "-mpegts_flags", "+initial_discontinuity", "-output_ts_offset", String(offset), "-mpegts_copyts", "1", "-muxdelay", "0", "-muxpreload", "0",
-                    "-f", "mpegts", "pipe:1",
-                ];
-                const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-                let tail = "";
-                child.stderr.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
-                const closed = new Promise((resolve) => {
-                    child.once("error", error => { tail = error.message; resolve(-1); });
-                    child.once("close", code => resolve(code));
-                });
-                const abort = () => { child.kill("SIGKILL"); };
-                signal.addEventListener("abort", abort, { once: true });
-                try {
-                    for await (const chunk of child.stdout) {
+                    break;
+                // Asked at every boundary, so an edit lands on the next track. The
+                // list goes on after the file that just played, where the new list
+                // has it; a shuffled list draws a new order.
+                if (o.current) {
+                    const fresh = o.current();
+                    if (fresh.length !== files.length || fresh.some((one, index) => one !== files[index])) {
+                        if (fresh.length === 0)
+                            throw new Error("The playlist is empty");
+                        files = fresh;
+                        order = orderFor(files);
+                        const where = last ? files.indexOf(last) : -1;
+                        step = o.order ? 0 : where >= 0 ? where + 1 : Math.min(step, files.length);
+                    }
+                }
+                if (step >= order.length) {
+                    if (!o.repeat)
+                        break;
+                    // A pass where everything was passed over is a list with nothing
+                    // to play, and repeating it would be the loop this exists to avoid.
+                    if (played === 0)
+                        throw new Error("Nothing in this playlist would play");
+                    played = 0;
+                    order = orderFor(files);
+                    step = 0;
+                    continue;
+                }
+                {
+                    const at = order[step];
+                    step += 1;
+                    const file = files[at];
+                    last = file;
+                    if (o.excluded?.(file))
+                        continue;
+                    const position = first && step - 1 === o.at ? o.position : 0;
+                    first = false;
+                    let reached = 0;
+                    try {
+                        const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
                         if (signal.aborted)
                             return;
-                        yield chunk;
+                        if (!codecs.audio && !codecs.video)
+                            throw new Error(`Cannot decode playlist entry ${at + 1}`);
+                        const duration = (codecs.duration ?? 0) - position;
+                        if (duration <= 0)
+                            throw new Error(`No playable duration for playlist entry ${at + 1}`);
+                        this.entries.push({ at, file, start: offset, position });
+                        const hasVideo = Boolean(codecs.video);
+                        const extra = o.video && !hasVideo
+                            ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]
+                            : o.video && !codecs.audio ? ["-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo"] : [];
+                        const args = [
+                            ...prefix, "-hide_banner", "-loglevel", "error", "-nostdin", "-filter_threads", "2",
+                            // How far this entry got, so an entry cut short -- skipped, or
+                            // broken halfway -- moves the clock by what was played and the
+                            // next one starts where this one stopped, not after a gap.
+                            "-progress", "pipe:3", "-stats_period", "0.5",
+                            "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), ...protocolArgs(file), "-i", file,
+                            ...extra, "-t", String(duration),
+                            ...(o.video ? [
+                                "-map", hasVideo ? "0:v:0" : "1:v:0", "-map", codecs.audio ? "0:a:0" : "1:a:0",
+                                "-vf", `fps=30,scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1,setpts=PTS-STARTPTS`,
+                                "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-tune", "zerolatency",
+                                "-crf", "23", "-pix_fmt", "yuv420p", "-g", "60", "-keyint_min", "60", "-sc_threshold", "0",
+                            ] : ["-map", "0:a:0", "-vn"]),
+                            "-af", "aresample=48000,asetpts=PTS-STARTPTS", "-c:a", "aac", "-b:a", "160k", "-ac", "2",
+                            "-mpegts_flags", "+initial_discontinuity", "-output_ts_offset", String(offset), "-mpegts_copyts", "1", "-muxdelay", "0", "-muxpreload", "0",
+                            "-f", "mpegts", "pipe:1",
+                        ];
+                        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe", "pipe"] });
+                        let tail = "";
+                        child.stderr.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
+                        child.stdio[3]?.on("data", (chunk) => {
+                            const found = /out_time_us=(\d+)/g;
+                            let match;
+                            while ((match = found.exec(chunk.toString())) !== null)
+                                reached = Math.max(reached, Number(match[1]) / 1e6);
+                        });
+                        const closed = new Promise((resolve) => {
+                            child.once("error", error => { tail = error.message; resolve(-1); });
+                            child.once("close", code => resolve(code));
+                        });
+                        const abort = () => { child.kill("SIGKILL"); };
+                        signal.addEventListener("abort", abort, { once: true });
+                        this.stopCurrent = abort;
+                        let skipped = false;
+                        try {
+                            for await (const chunk of child.stdout) {
+                                if (signal.aborted)
+                                    return;
+                                yield chunk;
+                            }
+                            const code = await closed;
+                            if (signal.aborted)
+                                return;
+                            skipped = this.skipping;
+                            if (code !== 0 && !skipped)
+                                throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
+                        }
+                        finally {
+                            this.stopCurrent = null;
+                            this.skipping = false;
+                            signal.removeEventListener("abort", abort);
+                            abort();
+                            await closed;
+                        }
+                        failuresInARow = 0;
+                        played += 1;
+                        // Match the frame grid used above so rounding cannot accumulate a
+                        // backwards timestamp over hundreds of short files.
+                        const length = skipped ? Math.min(duration, reached) : duration;
+                        offset += o.video ? Math.ceil(length * 30) / 30 : length;
+                    }
+                    catch (error) {
+                        if (signal.aborted || !o.passOver)
+                            throw error;
+                        // Passed over, not dialled again: the next entry is what a
+                        // listener should hear, and a file that will not decode now will
+                        // not decode in two seconds either.
+                        const reason = error instanceof Error ? error.message : String(error);
+                        o.onFailure?.({ at, file, reason });
+                        if (reached > 0)
+                            offset += o.video ? Math.ceil(reached * 30) / 30 : reached;
+                        failuresInARow += 1;
+                        if (failuresInARow >= Math.min(MAX_FAILURES_IN_A_ROW, Math.max(1, files.length))) {
+                            throw new Error(`Nothing in this playlist would play: ${reason}`);
+                        }
                     }
-                    const code = await closed;
-                    if (signal.aborted)
-                        return;
-                    if (code !== 0)
-                        throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
-                }
-                finally {
-                    signal.removeEventListener("abort", abort);
-                    abort();
-                    await closed;
                 }
-                // Match the frame grid used above so rounding cannot accumulate a
-                // backwards timestamp over hundreds of short files.
-                offset += o.video ? Math.ceil(duration * 30) / 30 : duration;
             }
             this.complete = !signal.aborted;
         }

package/dist/publish-choice.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Whether this server goes in the public directory.
+ *
+ * A listing is a phone code and a link anybody can open, so it is a thing
+ * somebody chose, not a thing that happens because a daemon had no terminal
+ * to ask on. The choice is asked once, or taken from a flag, and written into
+ * config.json beside the library, and every later start reads it back.
+ *
+ * Servers that were listed before the choice was written down keep being
+ * listed: a daemon without a terminal used to publish by itself, and quietly
+ * taking it off the directory on an update would be changing somebody's
+ * choice for them. A server new to this machine is not listed until asked.
+ */
+export type PublishFlag = "ask" | "yes" | "no";
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export declare function publishChoice(flag: PublishFlag, recorded: boolean | undefined, interactive: boolean, established: boolean): "yes" | "no" | "ask";
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export declare function shouldRecord(flag: PublishFlag, recorded: boolean | undefined): boolean;

package/dist/publish-choice.js

@@ -0,0 +1,17 @@
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export function publishChoice(flag, recorded, interactive, established) {
+    if (flag !== "ask")
+        return flag;
+    if (recorded !== undefined)
+        return recorded ? "yes" : "no";
+    if (interactive)
+        return "ask";
+    return established ? "yes" : "no";
+}
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export function shouldRecord(flag, recorded) {
+    return flag === "ask" && recorded === undefined;
+}

package/dist/server.js

@@ -9,7 +9,9 @@
  * a WebSocket because SSE is plain HTTP: no dependency, and it reconnects on
  * its own when the laptop running the remote goes to sleep.
  */
-import { createReadStream, statSync } from "node:fs";
+import { publishChoice, shouldRecord } from "./publish-choice.js";
+import { protocolArgs } from "./decoder-policy.js";
+import { createReadStream, existsSync, statSync } from "node:fs";
 import { createServer as createHttpServer } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
 import { randomBytes } from "node:crypto";
@@ -51,6 +53,7 @@ import { Directory, ENDED_TTL_MS, parseAnnouncement } from "./directory.js";
 import { ArtCache, coverArtOf, stillFrom } from "./art.js";
 import { PartyLine, telnyxSms } from "./partyline.js";
 import { HlsPackagers, segmentType, withKey } from "./hls.js";
+import { refusedDestination } from "./destinations.js";
 import { CompressionService } from "./compression/service.js";
 import { handleChannelCompression, handleCompressionApi, handleStaticRelay } from "./compression/routes.js";
 import { DEFAULT_SITE as NICHEDB, Enricher, FIXTURE_TTL_MS } from "./enrich.js";
@@ -65,7 +68,7 @@ import { Porkbun, isIPv4, isIPv6 } from "./dns.js";
 import { NameError, Names } from "./names.js";
 import { AcmeIssuer, Certs } from "./certs.js";
 import { claimName, fetchCert, humanizeSource, labelFor, readCertFiles, writeCertFiles } from "./naming.js";
-import { forbiddenLibrary, readLibrary } from "./library.js";
+import { forbiddenLibrary, readConfig, readLibrary, writeConfig } from "./library.js";
 import { createThrottle, presentedCredential } from "@profullstack/throttle";
 import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
@@ -1469,7 +1472,7 @@ export function createHandler(engine, options) {
                 json(response, 404, { error: "not found" });
                 return;
             }
-            response.writeHead(302, { ...CORS, "set-cookie": keyCookie(offered), location: "/" });
+            response.writeHead(302, { ...CORS, "set-cookie": keyCookie(offered, request.socket.encrypted === true || (options.secureCookies ?? false)), location: "/" });
             response.end();
             return;
         }
@@ -2061,12 +2064,18 @@ export function createHandler(engine, options) {
         // port is open from another device before wondering whether the link is
         // wrong, and it says nothing about the library.
         const eventChannelRequest = Boolean(channelId && await eventForChannel());
+        // Whether this request holds only the listen key. A listener may browse
+        // and hear the library, but where it lives on this machine is the
+        // owner's business: the absolute path names the user account and the disk.
+        let listening = false;
         if (key !== null &&
             path !== "/api/health" &&
             path !== "/api/directory" &&
             !isSignInPath(path) &&
             !eventChannelRequest) {
             let scope = scopeOf(keyFrom(request, url), key, listenKey);
+            // Kept for the routes below that answer a listener with less.
+            const settle = () => { listening = scope === "listen"; };
             // A key is how somebody who was invited proves it. It is not the only way
             // to be allowed in: the person who owns this server is allowed in whether
             // or not they still have the link, and their nixamp.com session says who
@@ -2093,6 +2102,7 @@ export function createHandler(engine, options) {
                 });
                 return;
             }
+            settle();
             if (scope === "listen" && !allowedForListening(path)) {
                 json(response, 403, { error: "this link can listen, not drive" });
                 return;
@@ -4204,11 +4214,32 @@ export function createHandler(engine, options) {
                 json(response, 429, { error: `this server is already carrying ${MAX_ON_DEMAND} channels on demand; try again in a minute` });
                 return;
             }
-            const resolved = known ?? await resolveLink(options.ytdlp ?? null, link, { cookies: options.cookies ?? "" });
+            // A member's link is fetched from inside the owner's network, so it has
+            // to lead somewhere public: the link, every hop of a playlist, and
+            // whatever yt-dlp says the media is. The owner's is theirs to aim.
+            const guard = liveBy && !known ? (one) => refusedDestination(one) : undefined;
+            if (guard) {
+                const refused = await guard(link);
+                if (refused) {
+                    json(response, 403, { error: refused });
+                    return;
+                }
+            }
+            const resolved = known ?? await resolveLink(options.ytdlp ?? null, link, { cookies: options.cookies ?? "", guard });
             if ("error" in resolved) {
-                json(response, 422, { error: resolved.error });
+                json(response, guard && resolved.error.includes("private network") ? 403 : 422, { error: resolved.error });
                 return;
             }
+            if (guard) {
+                const reached = [resolved.media, resolved.audio, ...(resolved.playlist ?? [])].filter((one) => one && /^(https?|rtmps?):\/\//i.test(one));
+                for (const one of [...new Set(reached)].slice(0, 200)) {
+                    const refused = await guard(one);
+                    if (refused) {
+                        json(response, 403, { error: refused });
+                        return;
+                    }
+                }
+            }
             links.set(link, resolved);
             // A channel already on -- put back by a restart, which forgets where
             // it came from -- learns its picture and its line from the link pasted
@@ -5068,7 +5099,7 @@ export function createHandler(engine, options) {
             return;
         }
         if (path === "/api/state") {
-            json(response, 200, engine.snapshot());
+            json(response, 200, listening ? { ...engine.snapshot(), root: "" } : engine.snapshot());
             return;
         }
         // Everything the admin view draws, in one request: who is connected, and
@@ -5132,7 +5163,7 @@ export function createHandler(engine, options) {
                 "x-accel-buffering": "no",
             });
             const send = (snapshot) => {
-                response.write(`data: ${JSON.stringify(snapshot)}\n\n`);
+                response.write(`data: ${JSON.stringify(listening ? { ...snapshot, root: "" } : snapshot)}\n\n`);
             };
             const unsubscribe = engine.subscribe(send);
             // A comment line keeps proxies from closing an idle stream.
@@ -5577,6 +5608,7 @@ async function liveAudio(request, response, engine, ffmpeg, ffprobe) {
             // A live source has no beginning to seek from.
             ...(from > 1 && !isRemote(source) ? ["-ss", String(from)] : []),
             "-re",
+            ...protocolArgs(source),
             "-i", source,
             ...(asVideo
                 // Copied where it can be, because a room full of viewers is a room
@@ -5681,6 +5713,7 @@ inputArgs = []) {
         // when they are handed to it for a file on disk.
         ...(isRemote(source) ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
         ...inputArgs,
+        ...protocolArgs(source),
         "-i", source,
         ...outputArgs,
         "-",
@@ -5860,6 +5893,15 @@ export async function serve(argv, version = "0.1.0") {
     // still works after a restart -- and a server is restarted to pick up a new
     // version, which is to say often. `--new-key` mints a fresh pair and forgets
     // the old one, which is the way to revoke a link that got out.
+    // Whether this port had keys before this start: a server that has run
+    // here before, whose directory listing (see publishChoice) is kept.
+    const established = existsSync(join(stateDir(), "keys.json")) &&
+        (() => { try {
+            return String(options.port) in JSON.parse(readFileSync(join(stateDir(), "keys.json"), "utf8"));
+        }
+        catch {
+            return false;
+        } })();
     const remembered = options.key ? rememberedKeys(stateDir(), options.port, options.newKey) : null;
     const key = remembered?.key ?? null;
     // Kept whether or not it is published, so `nixamp admin` and the operator
@@ -6959,10 +7001,23 @@ export async function serve(argv, version = "0.1.0") {
         // public at all.
         //
         // Still asked when a person is at the terminal to answer, because that is
-        // somebody who can say no.
-        const wanted = options.publish === "yes" || !process.stdin.isTTY
-            ? true
-            : await confirm(`\n  List this stream at ${DEFAULT_DIRECTORY}/directory so anyone can find it?\n  It publishes ${listen} — listen only, not the controls.`);
+        // somebody who can say no -- and since 0.29 the answer is kept, so a
+        // daemon started later does what the person said, not what it guesses.
+        const recorded = readConfig().publish;
+        const choice = publishChoice(options.publish, recorded, Boolean(process.stdin.isTTY), established);
+        const wanted = choice === "ask"
+            ? await confirm(`\n  List this stream at ${DEFAULT_DIRECTORY}/directory so anyone can find it?\n  It publishes ${listen} — listen only, not the controls.`)
+            : choice === "yes";
+        if (shouldRecord(options.publish, recorded)) {
+            try {
+                writeConfig({ publish: wanted });
+            }
+            catch { /* unwritable state: asked again next time */ }
+        }
+        if (!wanted && options.publish === "ask") {
+            console.log("");
+            console.log(`  Not listed at ${DEFAULT_DIRECTORY}/directory. Start with --publish to list it.`);
+        }
         if (wanted) {
             publisher = makePublisher();
             listing = (await publisher?.start()) ?? null;

package/dist/share.d.ts

@@ -47,7 +47,7 @@ export declare function keysMatch(a: string, b: string): boolean;
 /** Every place a key is accepted from, in the order they are looked for. */
 export declare function keyFrom(request: IncomingMessage, url: URL): string | null;
 /** The Set-Cookie for a browser that just opened the link. */
-export declare function keyCookie(key: string): string;
+export declare function keyCookie(key: string, secure?: boolean): string;
 /** Where an address actually goes, which is not always where you would like. */
 export declare function classify(address: string): "private" | "cgnat" | "public";
 /** Looks like an address, rather than an error page or a rate-limit notice. */

package/dist/share.js

@@ -108,11 +108,12 @@ export function keyFrom(request, url) {
     return null;
 }
 /** The Set-Cookie for a browser that just opened the link. */
-export function keyCookie(key) {
+export function keyCookie(key, secure = false) {
     // HttpOnly because nothing in the page reads it: the browser attaches it to
-    // every same-origin request by itself. No Secure, because the whole point is
-    // a plain-http address on your own network.
-    return `${KEY_COOKIE}=${encodeURIComponent(key)}; Path=/; Max-Age=31536000; SameSite=Lax; HttpOnly`;
+    // every same-origin request by itself. Secure only when the link was opened
+    // over https: a plain-http address on your own network is still a thing,
+    // and a Secure cookie there would never be sent back.
+    return `${KEY_COOKIE}=${encodeURIComponent(key)}; Path=/; Max-Age=31536000; SameSite=Lax; HttpOnly${secure ? "; Secure" : ""}`;
 }
 /**
  * Interfaces that exist for containers and virtual machines. An address on one

package/dist/shared-translation.d.ts

@@ -1,56 +1,9 @@
-import { type Caption } from "./live-interpreter.ts";
-import { LiveVoice } from "./live-voice.ts";
-import type { Translator } from "./translate.ts";
-import type { TranslationMeter } from "./translation-passes.ts";
-export declare function publicStreamAddress(address: string): boolean;
+/** Shared live translation, from @profullstack/live-translate, limited to nixamp channels. */
+import { SharedTranslations as Base, type OpenLiveInput } from "@profullstack/live-translate";
+export { publicStreamAddress, type LiveInput, type OpenLiveInput, type SharedEvent } from "@profullstack/live-translate";
+/** Only a live nixamp channel (`/api/channels/<id>`, optionally `?k=`). */
 export declare function sharedSource(raw: string): URL;
-export interface LiveInput {
-    stop(): void;
-}
-export type OpenLiveInput = (source: URL, pcm: (bytes: Buffer) => void, ended: () => void, signal: AbortSignal) => Promise<LiveInput>;
-/** Resolve once and pin that public address; no redirects or ffmpeg URL fetches. */
 export declare function liveInput(ffmpeg?: string[]): OpenLiveInput;
-export type SharedEvent = {
-    type: "status";
-    listeners: number;
-} | {
-    type: "line";
-    id: string;
-    line: Caption;
-} | {
-    type: "audio";
-    id: string;
-    data: string;
-} | {
-    type: "end";
-    id: string;
-} | {
-    type: "error";
-    error: string;
-    retryable?: boolean;
-};
-type Member = {
-    by: string;
-    send: (event: SharedEvent) => void;
-    close: () => void;
-};
-export declare class SharedTranslations {
-    private readonly options;
-    private readonly feeds;
-    constructor(options: {
-        voice: LiveVoice;
-        translator: Pick<Translator, "translate">;
-        billing?: TranslationMeter;
-        open?: OpenLiveInput;
-    });
-    get size(): number;
-    join(raw: string, language: string, by: string, send: Member["send"], close: () => void): Promise<() => void>;
-    private leave;
-    private checkMembers;
-    private broadcast;
-    private stop;
-    private make;
-    private start;
-    private speak;
+export declare class SharedTranslations extends Base {
+    constructor(options: ConstructorParameters<typeof Base>[0]);
 }
-export {};