nixamp 0.23.7 → 0.24.0

package/src/translate-cli.ts

@@ -0,0 +1,111 @@
+/**
+ * `nixamp translate` -- a line in another language, from the terminal.
+ *
+ * The models are nixamp.com's (see translate.ts); this sends the text and
+ * prints what comes back, signed in as whoever this machine is signed in
+ * as. Text on the command line, or on stdin when there is none there, one
+ * line at a time so a file of lines comes back as a file of lines.
+ */
+import { readSession, type Session } from "./session.ts";
+import { translateTexts, type Signed } from "./transcript-client.ts";
+import { languageCode } from "./transcripts.ts";
+
+const HELP = `nixamp translate — say it in another language.
+
+  nixamp translate --to sv "Hello there"      Swedish, from English
+  nixamp translate --from de --to en "Guten Tag"
+  cat lines.txt | nixamp translate --to de    each line, in order
+  nixamp translate --languages                what nixamp.com can translate between
+
+The models are open-source (OPUS-MT) and run on nixamp.com's own CPU; a pair
+with no model of its own goes through English. Needs a sign-in
+(\`nixamp login\`).
+`;
+
+function flag(argv: string[], name: string): string | undefined {
+  const at = argv.indexOf(name);
+  return at === -1 ? undefined : argv[at + 1];
+}
+
+export interface TranslateDeps {
+  fetcher?: typeof fetch;
+  session?: Pick<Session, "site" | "token"> | null;
+  /** What stdin says, when no text is on the command line; the tests hand it in. */
+  stdin?: () => Promise<string>;
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+interface LanguageRow {
+  code: string;
+  name: string;
+  native: string;
+  targets: string[];
+}
+
+export async function translate(argv: string[], deps: TranslateDeps = {}): Promise<number> {
+  if (argv.includes("--help") || argv.includes("-h") || argv[0] === "help") {
+    console.log(HELP);
+    return 0;
+  }
+  const session = deps.session === undefined ? readSession() : deps.session;
+  if (session === null) {
+    console.error("nixamp: not signed in. Try `nixamp login`.");
+    return 1;
+  }
+  const fetcher = deps.fetcher ?? fetch;
+  const signed: Signed = { site: session.site, token: session.token };
+  if (argv.includes("--languages")) {
+    let response: Response;
+    try {
+      response = await fetcher(`${signed.site.replace(/\/+$/, "")}/api/v1/translate`);
+    } catch (error) {
+      console.error(`nixamp: could not reach ${signed.site}: ${(error as Error).message}`);
+      return 1;
+    }
+    const body = (await response.json().catch(() => ({}))) as { available?: boolean; languages?: LanguageRow[]; error?: string };
+    if (!response.ok) {
+      console.error(`nixamp: ${body.error ?? `nixamp.com answered ${response.status}`}`);
+      return 1;
+    }
+    if (argv.includes("--json")) {
+      console.log(JSON.stringify(body, null, 2));
+      return 0;
+    }
+    if (body.available === false) console.error("nixamp: that nixamp has no translation models; nixamp.com does.");
+    for (const language of body.languages ?? []) {
+      console.log(`${language.code}  ${language.name.padEnd(11)} ${language.native.padEnd(17)} -> ${language.targets.join(" ")}`);
+    }
+    return 0;
+  }
+  const to = languageCode(flag(argv, "--to"));
+  const from = languageCode(flag(argv, "--from") ?? "en");
+  if (!to || from === null || from === "") {
+    console.error("nixamp: --to (and --from, English by default) are two-letter language codes, such as sv.");
+    return 64;
+  }
+  const withValue = new Set(["--to", "--from"]);
+  const given = argv.filter((one, at) => !one.startsWith("-") && !(at > 0 && withValue.has(argv[at - 1] as string)));
+  const text = given.length > 0 ? given.join(" ") : await (deps.stdin ?? readStdin)();
+  const lines = text.split(/\r?\n/).map((line) => line.trimEnd());
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  if (lines.length === 0) {
+    console.error("nixamp: translate what? Pass the text, or pipe it in.");
+    return 64;
+  }
+  const got = await translateTexts(signed, lines, from, to, fetcher);
+  if (!got.ok) {
+    console.error(`nixamp: ${got.error}`);
+    return 1;
+  }
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(got.body, null, 2));
+    return 0;
+  }
+  console.log(got.body.texts.join("\n"));
+  return 0;
+}

package/src/translate-jobs.ts

@@ -0,0 +1,132 @@
+/**
+ * A stored transcript, translated: the job that does it, and its progress.
+ *
+ * A film's transcript is more than a thousand lines, and a thousand lines
+ * through a Marian model is minutes of CPU. No request waits that long.
+ * The first ask for a language starts the job and answers 202 with what
+ * there is; the job keeps the store up as it goes, so a second ask sees
+ * more, and a process that dies mid-way leaves behind what it had done
+ * for the next one to carry on from -- only the lines the store has no
+ * translation of yet are sent to the model. When the translation is as
+ * far along as the original, the ask is answered 200 with it.
+ *
+ * One job per transcript and language at a time; asking again joins the
+ * job that is running rather than starting another.
+ */
+import { SpeechError } from "./speech.ts";
+import { BATCH, type Translator } from "./translate.ts";
+import { lineAt, type Transcript, type TranscriptLine, type Transcripts } from "./transcripts.ts";
+
+export interface Progress {
+  done: number;
+  total: number;
+}
+
+interface Job {
+  progress: Progress;
+  finished: Promise<void>;
+  error: string;
+}
+
+/** What a request should answer: the status and the body's extra fields. */
+export type Answer =
+  | { status: 200; transcript: Transcript }
+  | { status: 202; transcript: Transcript | null; translating: Progress }
+  | { status: 404 | 409 | 503; error: string };
+
+export class StoredTranslations {
+  private readonly jobs = new Map<string, Job>();
+
+  constructor(
+    private readonly store: Transcripts,
+    private readonly translator: Translator | undefined,
+    private readonly onEvent: (message: string) => void = () => {},
+  ) {}
+
+  /** The lines of the original that the translation does not yet have. */
+  static missing(original: Transcript, translation: Transcript | null): TranscriptLine[] {
+    if (!translation) return original.lines;
+    return original.lines.filter((line) => lineAt(translation.lines, line.start) === null);
+  }
+
+  /**
+   * The transcript in a language, or the job making it. The original when
+   * the language is the one it was heard in.
+   */
+  async get(id: string, language: string, by: string): Promise<Answer> {
+    const original = await this.store.get(id);
+    if (!original) return { status: 404, error: "nothing has been written down for that" };
+    if (language === "" || language === original.language) return { status: 200, transcript: original };
+    const translation = await this.store.get(id, language);
+    const missing = StoredTranslations.missing(original, translation);
+    if (translation && missing.length === 0) return { status: 200, transcript: translation };
+    if (original.language === "") return { status: 409, error: "the language this was heard in is not known, so it cannot be translated" };
+    if (!this.translator) return { status: 503, error: "this nixamp cannot translate: no model here. nixamp.com can." };
+    if (!this.translator.can(original.language, language)) {
+      return { status: 409, error: `there is no model here from ${original.language} to ${language}` };
+    }
+    const key = `${id}|${language}`;
+    let job = this.jobs.get(key);
+    if (job?.error) {
+      this.jobs.delete(key);
+      return { status: 503, error: job.error };
+    }
+    if (!job) {
+      job = this.start(key, original, translation, missing, language, by);
+      // A short one is done before the ask is answered.
+      if (missing.length <= BATCH) {
+        await job.finished;
+        if (job.error) {
+          this.jobs.delete(key);
+          return { status: 503, error: job.error };
+        }
+        const made = await this.store.get(id, language);
+        if (made) return { status: 200, transcript: made };
+      }
+    }
+    return { status: 202, transcript: translation, translating: { ...job.progress } };
+  }
+
+  private start(key: string, original: Transcript, translation: Transcript | null, missing: TranscriptLine[], language: string, by: string): Job {
+    const job: Job = { progress: { done: original.lines.length - missing.length, total: original.lines.length }, finished: Promise.resolve(), error: "" };
+    job.finished = this.run(original, translation, missing, language, by, job)
+      .catch((error: unknown) => {
+        job.error = error instanceof SpeechError ? error.message : `translating failed: ${(error as Error).message}`;
+        this.onEvent(`  translating ${original.title || original.media} to ${language}: ${job.error}`);
+      })
+      .finally(() => {
+        if (!job.error) this.jobs.delete(key);
+      });
+    this.jobs.set(key, job);
+    return job;
+  }
+
+  private async run(original: Transcript, translation: Transcript | null, missing: TranscriptLine[], language: string, by: string, job: Job): Promise<void> {
+    const translator = this.translator as Translator;
+    const made: TranscriptLine[] = translation ? [...translation.lines] : [];
+    let model = "";
+    for (let at = 0; at < missing.length; at += BATCH) {
+      const batch = missing.slice(at, at + BATCH);
+      const done = await translator.translate(batch.map((line) => line.text), original.language, language);
+      model = done.model;
+      const lines = batch.map((line, i) => ({ start: line.start, end: line.end, text: done.texts[i] ?? "" })).filter((line) => line.text !== "");
+      made.push(...lines);
+      await this.store.save({
+        media: original.media, language, translatedFrom: original.language, model, title: original.title, by, lines,
+      });
+      job.progress.done += batch.length;
+    }
+    if (original.complete) {
+      // Whole, like the original: the pieces are replaced by the lot, and nothing partial touches it again.
+      await this.store.save({
+        media: original.media, language, translatedFrom: original.language, model, title: original.title, by, lines: made, complete: true,
+      });
+    }
+    if (missing.length > 0) this.onEvent(`  translated ${missing.length} lines of ${original.title || original.media} to ${language}`);
+  }
+
+  /** What is being translated right now. */
+  running(): { key: string; progress: Progress }[] {
+    return [...this.jobs.entries()].filter(([, job]) => !job.error).map(([key, job]) => ({ key, progress: { ...job.progress } }));
+  }
+}

package/src/translate.ts

@@ -0,0 +1,276 @@
+/**
+ * Translation: a line in one language, said in another, on this CPU.
+ *
+ * The models are the Helsinki-NLP OPUS-MT pairs, one small Marian model
+ * per direction, run through Transformers.js like the ear (speech.ts):
+ * open weights, nothing sent anywhere, nothing billed. A pair is about a
+ * hundred megabytes and a sentence takes about a second; the many-language
+ * models that could do any pair in one model were measured and were not
+ * worth it -- NLLB-200 wants two gigabytes of memory and ten to twenty
+ * seconds a sentence here, and the multi-target Marian models echo their
+ * target prefix back and translate nothing. So a pair that has no model of
+ * its own goes through English: Swedish to German is Swedish to English,
+ * then English to German, twice the wait and the cost of the pivot in
+ * meaning, and still the honest choice.
+ *
+ * Pairs are loaded when first asked for and the least recently used is
+ * let go when there are more than a few, because each loaded pair holds a
+ * few hundred megabytes and a deployment has a ceiling. Batches are kept
+ * to a handful of lines with a cap on how much they may say: a Marian
+ * model handed twenty lines at once ran one of them into a wall of full
+ * stops until it hit the limit.
+ */
+import { join } from "node:path";
+import { stateDir } from "./daemon.ts";
+import { SpeechError, loadTransformers } from "./speech.ts";
+
+/** Where the pair models come from: this prefix and `<from>-<to>`. */
+export const MODEL_PREFIX = "Xenova/opus-mt-";
+/** How many pairs stay loaded at once. Each holds three to five hundred megabytes beside the ear's four. */
+export const KEEP_LOADED = 3;
+/** How many lines a model is handed at a time. Past eight one of them may run away. */
+export const BATCH = 8;
+/** How much one account may have translated in a minute, in characters. Twelve captions a minute is under a thousand. */
+export const CHARS_PER_MINUTE = 20_000;
+/** How many may wait on the CPU at once. */
+export const QUEUE_LIMIT = 16;
+/** A translation is never longer than this many tokens: the runaway guard. */
+export const MAX_NEW_TOKENS = 160;
+
+/**
+ * The directions a pair model exists for, as of the models that were
+ * measured. Anything else goes through English, and what English cannot
+ * reach is refused with a sentence rather than guessed at.
+ */
+export const PAIRS: ReadonlySet<string> = new Set([
+  // Each of these answered 200 from the hub on 2026-09-13; de-sv, sv-de, de-it, de-nl and the Greek pairs did not.
+  "en-de", "en-sv", "en-es", "en-fr", "en-it", "en-nl", "en-ru", "en-zh", "en-ar", "en-fi", "en-da", "en-hu", "en-cs", "en-uk", "en-vi", "en-id", "en-hi",
+  "de-en", "sv-en", "es-en", "fr-en", "it-en", "nl-en", "pl-en", "ru-en", "ja-en", "zh-en", "ko-en", "ar-en", "tr-en", "fi-en", "da-en", "hu-en", "cs-en", "uk-en", "vi-en", "id-en", "hi-en",
+  "de-fr", "fr-de", "de-es", "es-de", "fr-es", "es-fr",
+]);
+
+/** What the page and the CLI call a language. */
+export const LANGUAGES: Record<string, { name: string; native: string }> = {
+  en: { name: "English", native: "English" },
+  de: { name: "German", native: "Deutsch" },
+  sv: { name: "Swedish", native: "Svenska" },
+  es: { name: "Spanish", native: "Español" },
+  fr: { name: "French", native: "Français" },
+  it: { name: "Italian", native: "Italiano" },
+  nl: { name: "Dutch", native: "Nederlands" },
+  pl: { name: "Polish", native: "Polski" },
+  ru: { name: "Russian", native: "Русский" },
+  ja: { name: "Japanese", native: "日本語" },
+  zh: { name: "Chinese", native: "中文" },
+  ko: { name: "Korean", native: "한국어" },
+  ar: { name: "Arabic", native: "العربية" },
+  tr: { name: "Turkish", native: "Türkçe" },
+  fi: { name: "Finnish", native: "Suomi" },
+  da: { name: "Danish", native: "Dansk" },
+  hu: { name: "Hungarian", native: "Magyar" },
+  cs: { name: "Czech", native: "Čeština" },
+  uk: { name: "Ukrainian", native: "Українська" },
+  vi: { name: "Vietnamese", native: "Tiếng Việt" },
+  id: { name: "Indonesian", native: "Bahasa Indonesia" },
+  hi: { name: "Hindi", native: "हिन्दी" },
+};
+
+/** The models a translation from one language to another goes through, or null when there is no way. */
+export function route(from: string, to: string, pairs: ReadonlySet<string> = PAIRS): [string, string][] | null {
+  if (from === to) return [];
+  if (pairs.has(`${from}-${to}`)) return [[from, to]];
+  if (from !== "en" && to !== "en" && pairs.has(`${from}-en`) && pairs.has(`en-${to}`)) return [[from, "en"], ["en", to]];
+  return null;
+}
+
+export function modelFor(from: string, to: string): string {
+  return `${MODEL_PREFIX}${from}-${to}`;
+}
+
+/** Lines in, lines out, one model. What a loaded pair is, to this file. */
+export type Pair = {
+  translate: (texts: string[]) => Promise<string[]>;
+  dispose?: () => Promise<void> | void;
+};
+
+export interface TranslatorOptions {
+  cacheDir?: string;
+  /** How a pair is loaded. The tests hand in a fake; nothing else does. */
+  load?: (model: string, cacheDir: string) => Promise<Pair>;
+  now?: () => number;
+  keep?: number;
+  pairs?: ReadonlySet<string>;
+}
+
+export interface Translated {
+  texts: string[];
+  from: string;
+  to: string;
+  /** The model, or the two, that did it. */
+  model: string;
+}
+
+interface TranslationPipeline {
+  (texts: string[], options: Record<string, unknown>): Promise<{ translation_text: string }[]>;
+  dispose?: () => Promise<void>;
+}
+
+interface Transformers {
+  env: { cacheDir?: string };
+  pipeline(task: "translation", model: string, options: { dtype: string }): Promise<TranslationPipeline>;
+}
+
+async function loadMarian(model: string, cacheDir: string): Promise<Pair> {
+  const transformers = await loadTransformers<Transformers>();
+  transformers.env.cacheDir = cacheDir;
+  const pipeline = await transformers.pipeline("translation", model, { dtype: "q8" });
+  return {
+    translate: async (texts) => {
+      const out: string[] = [];
+      for (let i = 0; i < texts.length; i += BATCH) {
+        const batch = texts.slice(i, i + BATCH);
+        // Twice the input and a little: a translation is about as long as
+        // what it translates, and a model that keeps going has gone wrong.
+        const longest = Math.max(...batch.map((text) => text.length));
+        const answers = await pipeline(batch, { max_new_tokens: Math.min(MAX_NEW_TOKENS, Math.ceil(longest / 2) + 16) });
+        out.push(...answers.map((answer) => answer.translation_text));
+      }
+      return out;
+    },
+    dispose: () => pipeline.dispose?.(),
+  };
+}
+
+export class Translator {
+  private readonly cacheDir: string;
+  private readonly load: (model: string, cacheDir: string) => Promise<Pair>;
+  private readonly now: () => number;
+  private readonly keep: number;
+  private readonly pairs: ReadonlySet<string>;
+  private readonly loaded = new Map<string, { pair: Promise<Pair>; usedAt: number }>();
+  private tail: Promise<unknown> = Promise.resolve();
+  private waiting = 0;
+  private readonly asked = new Map<string, { minute: number; chars: number }>();
+  lastFailure = "";
+
+  constructor(options: TranslatorOptions = {}) {
+    this.cacheDir = options.cacheDir ?? process.env["NIXAMP_STT_CACHE"] ?? join(stateDir(), "models");
+    this.load = options.load ?? loadMarian;
+    this.now = options.now ?? (() => Date.now());
+    this.keep = options.keep ?? KEEP_LOADED;
+    this.pairs = options.pairs ?? PAIRS;
+  }
+
+  /** Whether one language can be said in another here, at all. */
+  can(from: string, to: string): boolean {
+    return route(from, to, this.pairs) !== null;
+  }
+
+  /** The languages something in `from` can be translated into. */
+  targets(from: string): string[] {
+    return Object.keys(LANGUAGES).filter((to) => to !== from && this.can(from, to));
+  }
+
+  private pair(from: string, to: string): Promise<Pair> {
+    const model = modelFor(from, to);
+    const held = this.loaded.get(model);
+    if (held) {
+      held.usedAt = this.now();
+      return held.pair;
+    }
+    const pair = this.load(model, this.cacheDir).catch((error: unknown) => {
+      // A failed load is tried again next time, not remembered forever.
+      this.loaded.delete(model);
+      throw error;
+    });
+    this.loaded.set(model, { pair, usedAt: this.now() });
+    if (this.loaded.size > this.keep) {
+      let oldest: [string, { pair: Promise<Pair>; usedAt: number }] | null = null;
+      for (const entry of this.loaded) if (entry[0] !== model && (oldest === null || entry[1].usedAt < oldest[1].usedAt)) oldest = entry;
+      if (oldest) {
+        this.loaded.delete(oldest[0]);
+        void oldest[1].pair.then((old) => old.dispose?.()).catch(() => undefined);
+      }
+    }
+    return pair;
+  }
+
+  /** Load pairs now, so the first line is not the one that waits. Says whether every one of them could; never throws. */
+  async warm(pairs: string[]): Promise<boolean> {
+    let all = true;
+    for (const name of pairs) {
+      const [from, to] = name.split("-");
+      if (!from || !to) continue;
+      try {
+        await this.pair(from, to);
+      } catch (error) {
+        this.lastFailure = (error as Error).message;
+        all = false;
+      }
+    }
+    return all;
+  }
+
+  /** The pairs loaded right now, by model name. */
+  loadedModels(): string[] {
+    return [...this.loaded.keys()];
+  }
+
+  /** Whether this account may have this much translated now, and the bookkeeping if so. */
+  allow(accountId: string, chars: number): void {
+    const minute = Math.floor(this.now() / 60_000);
+    const record = this.asked.get(accountId) ?? { minute, chars: 0 };
+    if (record.minute !== minute) {
+      record.minute = minute;
+      record.chars = 0;
+    }
+    if (record.chars + chars > CHARS_PER_MINUTE) {
+      throw new SpeechError(`${CHARS_PER_MINUTE} characters a minute is plenty; try again in a moment`, 429);
+    }
+    record.chars += chars;
+    this.asked.set(accountId, record);
+    if (this.asked.size > 5000) {
+      for (const [id, one] of this.asked) if (one.minute !== minute) this.asked.delete(id);
+    }
+  }
+
+  /**
+   * Texts in another language. Refuses a pair nobody can do, too much for
+   * one account, or too many waiting, each with a status. Empty texts come
+   * back empty and cost nothing.
+   */
+  async translate(texts: string[], from: string, to: string, options: { by?: string } = {}): Promise<Translated> {
+    const hops = route(from, to, this.pairs);
+    if (hops === null) {
+      const known = Object.keys(LANGUAGES).includes(from) && Object.keys(LANGUAGES).includes(to);
+      throw new SpeechError(known ? `there is no model here from ${from} to ${to}` : `translation is between two-letter language codes, such as en and de`, 400);
+    }
+    const chars = texts.reduce((sum, text) => sum + text.length, 0);
+    if (options.by) this.allow(options.by, chars);
+    const model = hops.map(([a, b]) => modelFor(a, b)).join(" then ");
+    if (hops.length === 0 || chars === 0) return { texts: [...texts], from, to, model };
+    if (this.waiting >= QUEUE_LIMIT) throw new SpeechError("too much is being translated at once; try again in a moment", 503);
+    this.waiting += 1;
+    const turn = this.tail.then(async () => {
+      // Only the lines with something in them go to the model; the rest keep their place.
+      const spoken = texts.map((text) => text.trim());
+      const which = spoken.map((text, i) => (text === "" ? -1 : i)).filter((i) => i >= 0);
+      let current = which.map((i) => spoken[i] as string);
+      for (const [a, b] of hops) {
+        const pair = await this.pair(a, b);
+        current = await pair.translate(current);
+      }
+      const out = [...spoken];
+      which.forEach((i, at) => {
+        out[i] = (current[at] ?? "").trim();
+      });
+      return out;
+    });
+    this.tail = turn.catch(() => undefined);
+    try {
+      return { texts: await turn, from, to, model };
+    } finally {
+      this.waiting -= 1;
+    }
+  }
+}

package/src/warm.ts

@@ -0,0 +1,43 @@
+/**
+ * `bun dist/warm.js` -- fetch the models now, so the image carries them.
+ *
+ * Run at build time by the Dockerfile. nixamp.com's filesystem is thrown
+ * away with every deploy, so without this the ear (80 MB) and every
+ * translation pair (about 100 MB each) were downloaded again at the first
+ * ask after each one, and the first person to speak waited for it. The
+ * models land in NIXAMP_STT_CACHE and the image keeps them.
+ *
+ * NIXAMP_MT_WARM names the pairs (en-de,en-sv,de-en,sv-en by default):
+ * German and Swedish both ways, which are the two that were asked for.
+ * Exits non-zero when anything could not be fetched, so a build does not
+ * quietly ship without its ear.
+ */
+import { Speech } from "./speech.ts";
+import { Translator } from "./translate.ts";
+
+const DEFAULT_PAIRS = "en-de,en-sv,de-en,sv-en";
+
+async function main(): Promise<number> {
+  const speech = new Speech();
+  console.error(`warming ${speech.model}...`);
+  if (!(await speech.warm())) {
+    console.error(`could not load the ear: ${speech.lastFailure}`);
+    return 1;
+  }
+  const pairs = (process.env["NIXAMP_MT_WARM"] ?? DEFAULT_PAIRS).split(",").map((one) => one.trim()).filter(Boolean);
+  const translator = new Translator({ keep: pairs.length });
+  console.error(`warming ${pairs.join(", ")}...`);
+  if (!(await translator.warm(pairs))) {
+    console.error(`could not load a translation pair: ${translator.lastFailure}`);
+    return 1;
+  }
+  console.error(`ready: ${speech.model} and ${translator.loadedModels().join(", ")}`);
+  return 0;
+}
+
+main().then((code) => {
+  process.exit(code);
+}, (error: unknown) => {
+  console.error((error as Error).message);
+  process.exit(1);
+});

package/web/dist/assets/{hls-3VKVEQE3-CI1U7kbP.js → hls-3VKVEQE3-Dtl-3mpW.js}

@@ -1 +1 @@
-import{t as e}from"./index-5H3sUGHu.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-B0h4Nexr.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};