nixamp 0.9.11 → 0.10.0

package/src/audio.ts

@@ -28,12 +28,14 @@ export interface Tools {
   ffprobe: string[];
   /** Argv prefix for the player, or null when nothing can make sound here. */
   play: string[] | null;
+  /** yt-dlp, which turns a pasted page into a media address; null when there is none. */
+  ytdlp?: string[] | null;
 }
 
-function works(argv: string[]): boolean {
+function works(argv: string[], flag = "-version"): boolean {
   const [cmd, ...rest] = argv;
   if (!cmd) return false;
-  const r = spawnSync(cmd, [...rest, "-version"], { encoding: "utf8", timeout: 10_000 });
+  const r = spawnSync(cmd, [...rest, flag], { encoding: "utf8", timeout: 10_000 });
   return !r.error && r.status === 0;
 }
 
@@ -92,10 +94,16 @@ export function detectTools(): Tools {
   const ffmpeg = pick("ffmpeg");
   const ffprobe = pick("ffprobe");
   const play = pick("ffplay");
+  // yt-dlp is not an ffmpeg, so mise's ffmpeg tree is not where it lives;
+  // the installer puts it beside nixamp, and pip puts it in ~/.local/bin too.
+  // Asked with its own spelling: ffmpeg answers -version, yt-dlp only --version.
+  const ytdlp = [["yt-dlp"], [join(homedir(), ".local", "bin", "yt-dlp")], ["/usr/local/bin/yt-dlp"], ["/usr/bin/yt-dlp"], ["/opt/homebrew/bin/yt-dlp"]]
+    .find((argv) => works(argv, "--version")) ?? null;
   return {
     ffmpeg: ffmpeg ?? ["ffmpeg"],
     ffprobe: ffprobe ?? ["ffprobe"],
     play,
+    ytdlp,
   };
 }
 
@@ -392,7 +400,7 @@ export interface Codecs {
  * answering other requests, and a synchronous probe per media request is how
  * the whole library came to be tagged with the process wedged solid.
  */
-export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
+export async function codecsOf(tools: Tools, path: string, input: string[] = []): Promise<Codecs> {
   const [cmd, ...rest] = tools.ffprobe;
   const empty: Codecs = { video: "", audio: "", container: "" };
   if (!cmd) return empty;
@@ -405,6 +413,8 @@ export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
         "-v", "quiet",
         "-print_format", "json",
         "-show_entries", "format=format_name:stream=codec_type,codec_name",
+        // Headers the source's site expects, for a link resolved by yt-dlp.
+        ...input,
         path,
       ],
       { stdio: ["ignore", "pipe", "ignore"] },

package/src/channels.ts

@@ -219,7 +219,7 @@ export class Channel {
    * because you looked away, and a room where the picture depends on who is
    * in it is not a room anybody can be invited to.
    */
-  pull(source: string, encode: string[], paced = true, stall = STALL): void {
+  pull(source: string, encode: string[], paced = true, stall = STALL, input: string[] = []): void {
     this.stall = stall;
     if (this.info.kind === "video") this.fragments = new Fragments();
     const [command, ...prefix] = this.options.ffmpeg as [string, ...string[]];
@@ -247,6 +247,10 @@ export class Channel {
           // hour of film in ninety seconds and a room that cannot be in it
           // together; a live source is already paced and loses nothing.
           ...(paced ? ["-re"] : []),
+          // What the source's site expects on the request: a user agent, a
+          // referer, a cookie. A link resolved by yt-dlp comes with these,
+          // and a CDN that got them from yt-dlp and not from us answers 403.
+          ...input,
           "-i", source,
           ...encode,
           "pipe:1",
@@ -612,6 +616,7 @@ export class Channels {
     kind: "audio" | "video",
     paced = true,
     stall = STALL,
+    input: string[] = [],
   ): Channel | null {
     if (this.open.has(id)) return null;
     const channel = new Channel(
@@ -630,7 +635,7 @@ export class Channels {
       (gone) => this.open.delete(gone),
     );
     this.open.set(id, channel);
-    channel.pull(source, encode, paced, stall);
+    channel.pull(source, encode, paced, stall, input);
     return channel;
   }
 

package/src/directory.ts

@@ -73,6 +73,12 @@ export interface Listing {
   playing: boolean;
   /** The live channels on it, by name: what a visitor could actually watch. */
   channels: string[];
+  /**
+   * A phone code for each of those channels, by name: its own room, so the
+   * people calling about one live are not put in with the people calling
+   * about another on the same server.
+   */
+  channelCodes: Record<string, string>;
   /** Set by the directory from the request, never by the publisher. */
   updatedAt: number;
   /** When this stream first announced itself: the "started at" a caller hears. */
@@ -283,6 +289,11 @@ export class Directory {
       // listing always meant, and no channels is the honest empty list.
       playing: announcement.playing ?? true,
       channels: announcement.channels ?? [],
+      channelCodes: this.codesFor(
+        announcement.channels ?? [],
+        existing?.channelCodes ?? (previously && "channelCodes" in previously ? previously.channelCodes : undefined),
+        id,
+      ),
       updatedAt: this.now(),
       // A stream that never stopped keeps its original start. One that did
       // starts again now, because that is what a caller is being told about.
@@ -305,10 +316,55 @@ export class Directory {
     return [...this.items.values()].sort((a, b) => b.updatedAt - a.updatedAt || a.id.localeCompare(b.id));
   }
 
-  /** The live stream on this code, if there is one. */
+  /**
+   * The live stream on this code, if there is one.
+   *
+   * A channel's code answers as the channel: the same listing, named for the
+   * channel and playing nothing else, so the phone line says "the live room
+   * for FIBA World Cup" rather than the server's name and whatever its own
+   * player has on.
+   */
   liveByCode(code: string): Listing | undefined {
     this.sweep();
-    return [...this.items.values()].find((item) => item.code === code);
+    const own = [...this.items.values()].find((item) => item.code === code);
+    if (own !== undefined) return own;
+    for (const item of this.items.values()) {
+      const channel = Object.entries(item.channelCodes).find(([, one]) => one === code)?.[0];
+      if (channel !== undefined) return { ...item, code, name: channel, nowPlaying: "" };
+    }
+    return undefined;
+  }
+
+  /**
+   * A code for each channel, kept while the channel stays on.
+   *
+   * One code per server meant every live on it shared a room: somebody
+   * calling about the basketball landed with the people talking about the
+   * film. Each live is its own room now, and a channel that is still there at
+   * the next heartbeat keeps the code it was given.
+   */
+  private codesFor(channels: string[], had: Record<string, string> | undefined, own = ""): Record<string, string> {
+    const codes: Record<string, string> = {};
+    for (const name of channels) {
+      if (codes[name] !== undefined) continue;
+      const kept = had?.[name];
+      codes[name] = kept !== undefined && !this.taken(kept, codes, own) ? kept : this.freeCode(codes, own);
+    }
+    return codes;
+  }
+
+  /**
+   * Whether a code is somebody's already: a stream's own, a channel's on any
+   * stream, or a recently-ended stream's. A listing renewing itself is not
+   * "somebody else", or its channels would be re-coded every heartbeat.
+   */
+  private taken(code: string, besides: Record<string, string> = {}, own = ""): boolean {
+    if (Object.values(besides).includes(code)) return true;
+    for (const item of this.items.values()) {
+      if (item.code === code) return true;
+      if (item.id !== own && Object.values(item.channelCodes).includes(code)) return true;
+    }
+    return [...this.ended.values()].some((i) => i.code === code);
   }
 
   /**
@@ -372,15 +428,12 @@ export class Directory {
     this.mirror?.save(record);
   }
 
-  /** A code no live and no recently-ended stream is using. */
-  private freeCode(): string {
+  /** A code no live stream, no channel on one, and no recently-ended stream is using. */
+  private freeCode(besides: Record<string, string> = {}, own = ""): string {
     for (let tries = 0; tries < 40; tries += 1) {
       const code = this.randomCode();
       if (code.length !== 6) continue;
-      const taken =
-        [...this.items.values()].some((i) => i.code === code) ||
-        [...this.ended.values()].some((i) => i.code === code);
-      if (!taken) return code;
+      if (!this.taken(code, besides, own)) return code;
     }
     return "";
   }

package/src/owner.ts

@@ -111,7 +111,7 @@ export const ADMIN_PATHS = [
  * `/api/live` itself is the public listen address -- the one the phone line is
  * handed. Gating it by prefix would shut the front door to lock the office.
  */
-const LIVE_CONTROL = ["/api/live/state", "/api/live/start", "/api/live/stop"];
+const LIVE_CONTROL = ["/api/live/start", "/api/live/stop"];
 
 export function needsAdmin(path: string, method = "GET"): boolean {
   if (LIVE_CONTROL.includes(path)) return true;

package/src/publish.ts

@@ -52,6 +52,16 @@ export interface PublishTarget {
   onConfig?: (config: unknown) => void;
   /** Called when the directory refused us for want of an account. */
   onRefused?: () => void;
+  /**
+   * Called with the listing every heartbeat, not only the first.
+   *
+   * The directory forgets everything when it restarts, and the next heartbeat
+   * lists this server again under a new phone code. A server that only kept
+   * the first answer went on showing the old code -- to the Share panel, the
+   * player, and anybody sent the link -- while the phone line knew only the
+   * new one.
+   */
+  onListed?: (listing: Listing) => void;
 }
 
 /**
@@ -128,6 +138,7 @@ export class Publisher {
       const listing = (await response.json()) as Listing & { config?: unknown };
       this.id = listing.id;
       if (listing.config !== undefined) this.target.onConfig?.(listing.config);
+      this.target.onListed?.(listing);
       return listing;
     } catch {
       // The directory being down is not a reason for a player to stop playing.

package/src/server.ts

@@ -51,6 +51,10 @@ import { stateDir } from "./daemon.ts";
 import { readSession } from "./session.ts";
 import { Directory, ENDED_TTL_MS, parseAnnouncement, type Listing } from "./directory.ts";
 import { PartyLine, telnyxSms } from "./partyline.ts";
+import {
+  contentTypeFor, downloadArgs, fileNameFor, inputArgsFor, linkChannelId, playableLink, resolveLink, saveFormat,
+  type ResolvedLink,
+} from "./links.ts";
 import { CALL_IN_NUMBER, OPT_IN_PATH, optInPage } from "./optin.ts";
 import pg from "pg";
 import { Follows, phoneFrom } from "./follows.ts";
@@ -978,15 +982,50 @@ export async function pullChannel(
   id: string,
   name: string,
   source: string,
+  input: string[] = [],
 ): Promise<Channel | null> {
-  const codecs = await codecsOf({ ffmpeg: [], ffprobe, play: null }, source);
+  const codecs = await codecsOf({ ffmpeg: [], ffprobe, play: null }, source, input);
   const kind = codecs.video === "" ? "audio" : "video";
   const encode = kind === "video"
     ? videoArgs(codecs)
     // No picture in it, so none is invented: MP3 is the thing every browser
     // plays and the thing a listener can join halfway through.
     : ["-vn", "-c:a", "libmp3lame", "-b:a", "192k", "-f", "mp3"];
-  return channels.pull(id, name, source, encode, kind);
+  return channels.pull(id, name, source, encode, kind, true, undefined, input);
+}
+
+/** What a link resolves to, kept so a download can be named without asking twice. */
+const links = new Map<string, ResolvedLink>();
+
+/**
+ * A Netscape cookies file beside the state, if the operator has put one there.
+ *
+ * YouTube and Vimeo refuse a datacenter without a signed-in cookie; the
+ * person who runs the server can export one from their browser and drop it
+ * at ~/.local/state/nixamp/cookies.txt, and every link is asked for with it.
+ */
+export function cookiesFile(): string {
+  const path = join(stateDir(), "cookies.txt");
+  try {
+    return statSync(path).isFile() ? path : "";
+  } catch {
+    return "";
+  }
+}
+
+/** What the page is told about a link it asked to play. */
+function shownLink(channelId: string, link: ResolvedLink) {
+  return {
+    kind: "live",
+    channel: channelId,
+    name: link.title,
+    live: link.live,
+    video: link.video,
+    duration: link.duration,
+    extractor: link.extractor,
+    // A live has no whole to keep; a bare file can be fetched by the browser itself.
+    download: !link.live && link.extractor !== "direct",
+  };
 }
 
 export function liveOnes(engine: Engine): { name: string; at: number; tracks: number }[] {
@@ -1122,6 +1161,10 @@ export interface HandlerOptions {
   ffmpeg?: string[];
   /** Where ffprobe is, for asking what is inside a file before re-encoding it. */
   ffprobe?: string[];
+  /** yt-dlp, which turns a pasted page into a media address. Null when there is none. */
+  ytdlp?: string[] | null;
+  /** A Netscape cookies file for sites that want a signed-in browser, when there is one. */
+  cookies?: string;
   /** Who is listening, for the admin view. */
   connections?: Connections;
   /**
@@ -1177,7 +1220,11 @@ export interface HandlerOptions {
    * and starting it. It is an action now, because that is what it is.
    */
   live?: {
-    status: () => { live: boolean; code: string; name: string; url: string; possible: boolean };
+    status: () => {
+      live: boolean; code: string; name: string; url: string; possible: boolean;
+      /** A phone code per live channel, by name, as the directory assigned them. */
+      channelCodes?: Record<string, string>;
+    };
     start: () => Promise<{ live: boolean; code: string; name: string; url: string; error?: string }>;
     stop: () => Promise<void>;
     /**
@@ -2363,6 +2410,11 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         const streams = options.directory.list().map(({ admin, ...stream }) => ({
           ...stream,
           callers: onThePhone ? onThePhone.listenersOn(stream.code) : 0,
+          // And on the phone for each live on it, by name: every live is its
+          // own room, so each has its own count.
+          channelCallers: Object.fromEntries(
+            Object.entries(stream.channelCodes).map(([name, code]) => [name, onThePhone ? onThePhone.listenersOn(code) : 0]),
+          ),
           ...(admin && me !== null && stream.ownerId === me.id ? { admin } : {}),
         }));
         // Recently ended too, because following exists to hear about
@@ -2533,6 +2585,9 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           // Whether it has a picture, so the page puts it in the element
           // that can show one. Never the source: that is the owner's.
           kind: one.kind ?? "audio",
+          // Its own room on the phone line, as the directory assigned it;
+          // empty until the next heartbeat has told the directory it is on.
+          code: state?.channelCodes?.[one.name] ?? "",
           // How it has been going, for whoever may do something about it.
           redials: one.redials ?? 0,
           error: one.error ?? "",
@@ -2721,6 +2776,118 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       return;
     }
 
+    // --- any link, played -------------------------------------------------
+    //
+    // Paste a page -- YouTube, a podcast, SoundCloud, a TikTok live -- and the
+    // server works out where the media is and plays it as a channel of its
+    // own, the way a catalog entry is played: started for whoever asked,
+    // stopped a minute after the last viewer leaves. Open to anyone holding
+    // the link, like picking something from a catalog.
+    if (path === "/api/links/play" && request.method === "POST") {
+      let body: { url?: unknown } = {};
+      try {
+        body = JSON.parse(await readBody(request)) as typeof body;
+      } catch {
+        json(response, 400, { error: "bad JSON" });
+        return;
+      }
+      const link = playableLink(body.url);
+      if (link === "") {
+        json(response, 400, { error: "that is not a link this can play" });
+        return;
+      }
+      if (!options.channels) {
+        json(response, 503, { error: "this server cannot carry channels" });
+        return;
+      }
+      const channelId = linkChannelId(link);
+      const known = links.get(link);
+      if (options.channels.has(channelId) && known) {
+        json(response, 200, shownLink(channelId, known));
+        return;
+      }
+      if (!options.channels.has(channelId) && options.channels.ephemeralCount >= MAX_ON_DEMAND) {
+        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 ?? "" });
+      if ("error" in resolved) {
+        json(response, 422, { error: resolved.error });
+        return;
+      }
+      links.set(link, resolved);
+      if (!options.channels.has(channelId)) {
+        const started = await pullChannel(
+          options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media,
+          inputArgsFor(resolved.headers),
+        );
+        if (!started) {
+          json(response, 409, { error: "that link is already starting" });
+          return;
+        }
+        options.channels.ephemeral(channelId);
+      }
+      json(response, 200, shownLink(channelId, resolved));
+      return;
+    }
+
+    // The whole thing, to keep. The server fetches it through yt-dlp and
+    // hands the bytes straight on as a download, so the person's own machine
+    // ends up with the file and the server keeps nothing. A live stream has
+    // no whole to hand over.
+    if (path === "/api/links/download") {
+      const link = playableLink(url.searchParams.get("url"));
+      if (link === "") {
+        json(response, 400, { error: "that is not a link this can fetch" });
+        return;
+      }
+      if (!options.ytdlp || options.ytdlp.length === 0) {
+        json(response, 503, { error: "this server has no yt-dlp to fetch with" });
+        return;
+      }
+      const resolved = links.get(link) ?? await resolveLink(options.ytdlp, link, { cookies: options.cookies ?? "" });
+      if ("error" in resolved) {
+        json(response, 422, { error: resolved.error });
+        return;
+      }
+      links.set(link, resolved);
+      if (resolved.live) {
+        json(response, 409, { error: "that is live; there is no whole file to download yet" });
+        return;
+      }
+      const audioOnly = url.searchParams.get("audio") === "1" || !resolved.video;
+      // Named for the format the download will actually take, which is not
+      // always the one played: a track played from an HLS playlist is saved
+      // as the plain MP3 the site also offers, and ".m4a" on an MP3 is a
+      // file nothing will open.
+      const saved = await resolveLink(options.ytdlp, link, { cookies: options.cookies ?? "", format: saveFormat(audioOnly) });
+      const fileName = fileNameFor("error" in saved ? resolved : { ...resolved, ext: saved.ext || resolved.ext }, audioOnly);
+      const [command, ...prefix] = options.ytdlp as [string, ...string[]];
+      const child = spawn(command, [...prefix, ...downloadArgs(link, audioOnly, options.cookies ?? "")], {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      response.writeHead(200, {
+        "content-type": contentTypeFor(fileName),
+        "content-disposition": `attachment; filename="${fileName.replace(/["\\]/g, "")}"; filename*=UTF-8''${encodeURIComponent(fileName)}`,
+        "cache-control": "no-store",
+      });
+      child.stdout?.pipe(response);
+      let complaint = "";
+      child.stderr?.on("data", (chunk: Buffer) => {
+        if (complaint.length < 20_000) complaint += chunk.toString("utf8");
+      });
+      child.on("error", () => response.end());
+      child.on("close", (code) => {
+        if (code !== 0) console.log(`  a download of ${link} failed: ${complaint.split("\n").filter((one) => one.startsWith("ERROR")).pop() ?? code}`);
+        response.end();
+      });
+      // The person closed the tab: stop fetching what nobody will keep.
+      response.on("close", () => {
+        if (child.exitCode === null) child.kill("SIGKILL");
+      });
+      return;
+    }
+
     // A channel is one publisher and everybody listening to them. Two or three
     // devices can publish at once, each to their own channel, and a listener
     // picks which to hear.
@@ -4163,6 +4330,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
       status: () => ({
         live: publisher !== null,
         code: listing?.code ?? "",
+        channelCodes: listing?.channelCodes ?? {},
         name: listing?.name ?? (options.name || hostname()),
         url: listing?.url ?? (publishable_ ? shareLink(publishable_.url, listenKey, false) : ""),
         // Whether going live is even possible here. A laptop behind a router
@@ -4210,6 +4378,11 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     paywall,
     ffmpeg: tools.ffmpeg,
     ffprobe: tools.ffprobe,
+    // For a pasted link: where its media is, and the whole of it to keep.
+    // A cookie jar beside the state, when the operator has put one there,
+    // for the sites that will not talk to a datacenter without one.
+    ytdlp: tools.ytdlp ?? null,
+    cookies: cookiesFile(),
     ...(tls ? { tls } : {}),
     // Untagged, so a directory of five thousand files answers at once; the
     // tags follow through `tag` below.
@@ -4557,6 +4730,14 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
           console.log("  nixamp.com would not list this stream: it needs an account.");
           console.log("  Run `nixamp login` (or `nixamp signup`) and start again.");
         },
+        // Every heartbeat, so the code this server shows is the code the
+        // phone line knows, whatever the directory has forgotten meanwhile.
+        onListed: (fresh) => {
+          if (listing && listing.code !== fresh.code) {
+            console.log(`  nixamp.com listed this stream again; the phone code is now ${fresh.code}.`);
+          }
+          listing = fresh;
+        },
         nowPlaying: () => {
           const snapshot = engine.snapshot();
           return snapshot.tracks?.[snapshot.index]?.title ?? "";

package/src/share.ts

@@ -354,8 +354,10 @@ export function allowedForListening(path: string): boolean {
   if (path === "/api/source" || path.startsWith("/api/source/")) return false;
   // Listing this machine in a public directory is not listening to it. The
   // listen address itself, /api/live, stays open: that is the thing a listen
-  // key is for.
-  if (path === "/api/live/state" || path === "/api/live/start" || path === "/api/live/stop") return false;
+  // key is for -- and so is knowing the phone code, which /api/live/state
+  // answers: a joiner is told the number to call and the code to key, and
+  // the code is in the public directory anyway.
+  if (path === "/api/live/start" || path === "/api/live/stop") return false;
   return true;
 }
 

package/web/dist/assets/{hls-3VKVEQE3-Djy-zI1_.js → hls-3VKVEQE3-5T3M0hCY.js}

@@ -1 +1 @@
-import{t as e}from"./index-Dnk9CNfO.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};
+import{t as e}from"./index-Bqujphpd.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};