@ngxsp/core 0.0.1-next.1 → 0.1.0

package/index.cjs

@@ -62,6 +62,40 @@ function createDefaultConfig(overrides) {
   };
 }
 
+// src/domain/remote-playback.ts
+var RemotePlaybackError = class extends Error {
+  constructor(code, message, format) {
+    super(message);
+    this.code = code;
+    this.format = format;
+    this.name = "RemotePlaybackError";
+  }
+  code;
+  format;
+};
+function remotePlaybackErrorCode(code) {
+  return `REMOTE_${code.toUpperCase().replace(/-/g, "_")}`;
+}
+function remotePlaybackFailure(error) {
+  if (!error) return null;
+  const details = error.details;
+  if (details?.name === "RemotePlaybackError" && details.code) return { code: details.code, ...details.format ? { format: details.format } : {} };
+  if (error.code === "REMOTE_PLAYBACK") return { code: "load-failed" };
+  return null;
+}
+function formatRemoteClock(seconds) {
+  const total = Math.max(0, Math.floor(seconds));
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const rest = total % 60;
+  return `${hours}:${String(minutes).padStart(2, "0")}:${String(rest).padStart(2, "0")}`;
+}
+function parseRemoteClock(value) {
+  const match = /^(\d+):(\d{1,2}):(\d{1,2})(?:\.(\d+))?$/.exec(value?.trim() ?? "");
+  if (!match) return void 0;
+  return Number(match[1]) * 3600 + Number(match[2]) * 60 + Number(match[3]) + (match[4] ? Number(`0.${match[4]}`) : 0);
+}
+
 // src/engine/engine-factory.ts
 function selectEngine(config, factories, caps) {
   const candidates = (factories ?? []).filter((f) => {
@@ -110,14 +144,21 @@ function mimeFromUrl(url) {
     return "";
   }
 }
+var NO_SOURCE = 3;
+function canPlay(v, type) {
+  return typeof v.canPlayType !== "function" || v.canPlayType(type) !== "";
+}
 var NativeEngine = class {
   id = "native";
   video;
   listeners = [];
+  emit(e) {
+    this.listeners.forEach((l) => l(e));
+  }
   async attach(videoEl) {
     this.video = videoEl;
     const v = videoEl;
-    const emit = (e) => this.listeners.forEach((l) => l(e));
+    const emit = (e) => this.emit(e);
     v.addEventListener("timeupdate", () => emit({ type: "timeupdate", currentTime: v.currentTime, duration: v.duration || 0 }));
     v.addEventListener("playing", () => emit({ type: "state", state: "playing" }));
     v.addEventListener("pause", () => emit({ type: "state", state: "paused" }));
@@ -139,12 +180,25 @@ var NativeEngine = class {
       v.src = URL.createObjectURL(source.file);
     } else {
       if (!source.url) throw new Error("source.url is required");
-      const type = mimeFromUrl(source.url);
+      const declared = mimeFromUrl(source.url);
+      const type = declared && canPlay(v, declared) ? declared : "";
       while (v.firstChild) v.removeChild(v.firstChild);
       if (type) {
         const s = document.createElement("source");
         s.src = source.url;
         s.type = type;
+        s.addEventListener("error", () => {
+          if (v.networkState !== NO_SOURCE) return;
+          this.emit({
+            type: "error",
+            error: {
+              code: "HTML5_4",
+              message: `No source could be decoded (${type})`,
+              fatal: true,
+              details: { url: source.url, type }
+            }
+          });
+        });
         v.appendChild(s);
         v.removeAttribute("src");
       } else {
@@ -154,6 +208,8 @@ var NativeEngine = class {
     await v.load();
     if (opts?.startTimeSec != null && isFinite(opts.startTimeSec)) {
       v.currentTime = Math.max(0, opts.startTimeSec);
+    } else if (!source.live) {
+      v.currentTime = 0;
     }
   }
   async destroy() {
@@ -176,7 +232,10 @@ var NativeEngine = class {
     if (this.video) this.video.playbackRate = rate;
   }
   async setVolume(volume) {
-    if (this.video) this.video.volume = Math.min(1, Math.max(0, volume));
+    if (!this.video) return;
+    const level = Math.min(1, Math.max(0, volume));
+    this.video.volume = level;
+    this.video.muted = level <= 0;
   }
   async setTextTrack(_trackId) {
   }
@@ -301,7 +360,7 @@ async function detectPlaybackCapabilities(videoEl) {
   caps.eme = !!(w.navigator && w.navigator.requestMediaKeySystemAccess);
   caps.mediaCapabilities = !!(w.navigator && w.navigator.mediaCapabilities);
   const v = videoEl ?? (typeof document !== "undefined" ? document.createElement("video") : void 0);
-  const canPlay = (mime) => {
+  const canPlay2 = (mime) => {
     try {
       if (caps.mse && w.MediaSource?.isTypeSupported) return !!w.MediaSource.isTypeSupported(mime);
       if (v && typeof v.canPlayType === "function") return v.canPlayType(mime) !== "";
@@ -310,12 +369,12 @@ async function detectPlaybackCapabilities(videoEl) {
       return false;
     }
   };
-  caps.codecs.mp4_h264 = canPlay('video/mp4; codecs="avc1.42E01E"');
-  caps.codecs.mp4_hevc = canPlay('video/mp4; codecs="hvc1.1.6.L93.B0"');
-  caps.codecs.webm_vp9 = canPlay('video/webm; codecs="vp09.00.10.08"');
-  caps.codecs.webm_av1 = canPlay('video/webm; codecs="av01.0.05M.08"');
+  caps.codecs.mp4_h264 = canPlay2('video/mp4; codecs="avc1.42E01E"');
+  caps.codecs.mp4_hevc = canPlay2('video/mp4; codecs="hvc1.1.6.L93.B0"');
+  caps.codecs.webm_vp9 = canPlay2('video/webm; codecs="vp09.00.10.08"');
+  caps.codecs.webm_av1 = canPlay2('video/webm; codecs="av01.0.05M.08"');
   caps.dash = caps.mse;
-  caps.hls = canPlay("application/vnd.apple.mpegurl") || canPlay("application/x-mpegURL") || caps.mse;
+  caps.hls = canPlay2("application/vnd.apple.mpegurl") || canPlay2("application/x-mpegURL") || caps.mse;
   caps.progressive = caps.codecs.mp4_h264 || caps.codecs.webm_vp9 || caps.codecs.webm_av1 || true;
   if (caps.eme && w.navigator?.requestMediaKeySystemAccess) {
     const probe = async (ks) => {
@@ -390,7 +449,7 @@ function createCapabilityReport(videoEl, cfg, mediaDecoding) {
   const mediaCapabilities = !!(w.navigator && w.navigator.mediaCapabilities);
   if (!mse) notes.push("MediaSource (MSE) not available");
   if (!eme) notes.push("Encrypted Media Extensions (EME) not available");
-  const canPlay = {
+  const canPlay2 = {
     'video/mp4; codecs="avc1.42E01E"': canPlayType(videoEl, 'video/mp4; codecs="avc1.42E01E"'),
     'video/mp4; codecs="hvc1.1.6.L93.B0"': canPlayType(videoEl, 'video/mp4; codecs="hvc1.1.6.L93.B0"'),
     'video/webm; codecs="vp09.00.10.08"': canPlayType(videoEl, 'video/webm; codecs="vp09.00.10.08"'),
@@ -421,7 +480,7 @@ function createCapabilityReport(videoEl, cfg, mediaDecoding) {
     } : void 0,
     platform: { isSecureContext: secure },
     features: { mse, eme, mediaCapabilities },
-    canPlay,
+    canPlay: canPlay2,
     mediaDecoding,
     notes
   };
@@ -568,6 +627,7 @@ var PlayerFacade = class {
   constructor(ports = createDefaultPorts()) {
     this.ports = ports;
   }
+  ports;
   engineFactories = [createNativeEngineFactory()];
   engineId = "native";
   lastNonFatal = null;
@@ -597,16 +657,21 @@ var PlayerFacade = class {
   playlistIndex$ = this.playlistIndexSub.asObservable();
   playlist = [];
   playlistKey = "";
-  externalVttUrl;
+  /** Subtitles loaded from files, shown by the host from `captionCues$` rather than by the browser. */
+  externalTexts = [];
+  externalTextCount = 0;
+  /** The text track picked here; undefined while the engine's own choice stands. */
+  textSelection = void 0;
+  engineTracks = [];
+  offCueChange;
+  captionCuesSub = new rxjs.BehaviorSubject([]);
+  /** The cues of the loaded subtitles to show now: the host draws them over the video. */
+  captionCues$ = this.captionCuesSub.asObservable();
   attach(videoEl, plugins = [], config, ports, engines) {
     if (ports) {
       this.ports = { ...this.ports, ...ports };
     }
-    if (engines && engines.length) {
-      this.engineFactories = [createNativeEngineFactory(), ...engines];
-    } else {
-      this.engineFactories = [createNativeEngineFactory()];
-    }
+    this.setEngines(engines);
     this.video = videoEl;
     this.plugins = plugins ?? [];
     this.ctx = { config, facade: this, ports: this.ports, contentId: config.source.contentId };
@@ -654,6 +719,7 @@ var PlayerFacade = class {
     }
     this.ctx.config = config;
     this.ctx.contentId = config.source.contentId;
+    this.timeSub.next({ currentTime: Math.max(0, opts?.startTimeSec ?? 0), duration: 0 });
     this.emitTelemetry("player:load_start", "info");
     try {
       const now = globalThis.performance?.now?.() ?? Date.now();
@@ -672,6 +738,7 @@ var PlayerFacade = class {
       } catch {
       }
     }
+    this.clearExternalTextTracks();
     if (this.engine) {
       try {
         await this.engine.destroy();
@@ -718,6 +785,13 @@ var PlayerFacade = class {
       }
     }
   }
+  /**
+   * Replaces the engines the next load chooses from (a remote device session starting or ending). The native engine is
+   * always kept as fallback so progressive and local playback never breaks; call `load` or `reload` to switch now.
+   */
+  setEngines(engines) {
+    this.engineFactories = engines && engines.length ? [createNativeEngineFactory(), ...engines] : [createNativeEngineFactory()];
+  }
   async reload(opts) {
     if (!this.ctx) throw new Error("PlayerFacade context missing");
     const snap = this.snapshot();
@@ -759,6 +833,7 @@ var PlayerFacade = class {
         await this.engine?.destroy();
       } catch {
       }
+      this.clearExternalTextTracks();
       this.engine = void 0;
       this.video = void 0;
       this.ctx = void 0;
@@ -912,9 +987,17 @@ var PlayerFacade = class {
       this.emitTelemetry("player:play_ok", "info");
     } catch (err) {
       const name = err?.name;
+      if (name === "AbortError") {
+        this.emitTelemetry("player:play_aborted", "info", {}, err?.message);
+        return;
+      }
       if (name === "NotAllowedError") {
         this.emitNonFatal(err, "AUTOPLAY_BLOCKED");
         this.emitTelemetry("player:play_fail", "warn", { code: "AUTOPLAY_BLOCKED" }, err?.message);
+      } else if (name === "RemotePlaybackError") {
+        const code = remotePlaybackErrorCode(err.code);
+        this.emitFatal(err, code);
+        this.emitTelemetry("player:play_fail", "error", { code }, err?.message);
       } else {
         this.emitFatal(err, "UNKNOWN");
         this.emitTelemetry("player:play_fail", "error", { code: "UNKNOWN" }, err?.message);
@@ -925,8 +1008,15 @@ var PlayerFacade = class {
   async pause() {
     await this.engine?.pause();
   }
+  /**
+   * Seeks the attached engine. Resolves to false when no engine can take the request yet (a load is replacing it), so
+   * callers keep the position and apply it once the media is ready instead of assuming it happened.
+   */
   async seekTo(timeSec) {
-    await this.engine?.seekTo(timeSec);
+    const engine = this.engine;
+    if (!engine) return false;
+    await engine.seekTo(timeSec);
+    return true;
   }
   async setRate(rate) {
     await this.engine?.setPlaybackRate(rate);
@@ -934,14 +1024,34 @@ var PlayerFacade = class {
   async setVolume(volume) {
     await this.engine?.setVolume(volume);
   }
+  /**
+   * Shows a text track: one of the engine's, one loaded from a file (`addExternalTextTrack`), or none (null).
+   * "external" still names the last file loaded.
+   */
   async setTextTrack(trackId) {
-    if (trackId === "external") {
-      if (this.video && this.externalVttUrl) {
-        this.ensureExternalTrack(this.externalVttUrl);
-      }
-      return;
-    }
-    await this.engine?.setTextTrack(trackId);
+    const id = trackId === "external" ? this.externalTexts[this.externalTexts.length - 1]?.id ?? null : trackId;
+    const external = this.externalTexts.find((text6) => text6.id === id);
+    this.showExternalText(external);
+    await this.engine?.setTextTrack(external ? null : id);
+    this.textSelection = id;
+    this.emitTracks();
+  }
+  /** Adds subtitles read from a file (WebVTT) to the media playing, and shows them; resolves to the new track's id. */
+  async addExternalTextTrack(text6) {
+    if (!this.video) throw new Error("PlayerFacade not attached");
+    const id = `external:${++this.externalTextCount}`;
+    const url = URL.createObjectURL(new Blob([text6.vtt], { type: "text/vtt" }));
+    const element = document.createElement("track");
+    element.kind = "subtitles";
+    element.label = text6.label;
+    if (text6.language) element.srclang = text6.language;
+    element.src = url;
+    element.setAttribute("data-external", "true");
+    this.video.appendChild(element);
+    element.track.mode = "disabled";
+    this.externalTexts.push({ id, label: text6.label, ...text6.language ? { language: text6.language } : {}, url, element });
+    await this.setTextTrack(id);
+    return id;
   }
   async setAudioTrack(trackId) {
     await this.engine?.setAudioTrack(trackId);
@@ -1004,25 +1114,52 @@ var PlayerFacade = class {
   // External tracks (for provider-based subtitles)
   async setExternalVttTrack(lang, vtt) {
     if (!this.video) return;
-    const blob = new Blob([vtt], { type: "text/vtt" });
-    this.externalVttUrl = URL.createObjectURL(blob);
-    this.ensureExternalTrack(this.externalVttUrl, lang);
+    await this.addExternalTextTrack({ label: `External (${lang})`, language: lang, vtt });
   }
   setMetadata(meta) {
     this.metadataSub.next(meta);
   }
-  ensureExternalTrack(url, lang = "und") {
-    if (!this.video) return;
-    const prev = this.video.querySelector('track[data-external="true"]');
-    if (prev) prev.remove();
-    const track = document.createElement("track");
-    track.kind = "subtitles";
-    track.label = `External (${lang})`;
-    track.srclang = lang;
-    track.src = url;
-    track.default = true;
-    track.setAttribute("data-external", "true");
-    this.video.appendChild(track);
+  /** Shows `shown` (its cues go to `captionCues$`, the browser draws none) and turns the other files' subtitles off. */
+  showExternalText(shown) {
+    this.offCueChange?.();
+    this.offCueChange = void 0;
+    for (const text6 of this.externalTexts) {
+      if (text6 !== shown) text6.element.track.mode = "disabled";
+    }
+    if (!shown) {
+      this.captionCuesSub.next([]);
+      return;
+    }
+    const track = shown.element.track;
+    track.mode = "hidden";
+    const publish = () => this.captionCuesSub.next(Array.from(track.activeCues ?? []));
+    track.addEventListener("cuechange", publish);
+    this.offCueChange = () => track.removeEventListener("cuechange", publish);
+    publish();
+  }
+  clearExternalTextTracks() {
+    const hadSelection = this.textSelection !== void 0 || this.externalTexts.length > 0;
+    this.showExternalText(void 0);
+    for (const text6 of this.externalTexts) {
+      text6.element.remove();
+      URL.revokeObjectURL(text6.url);
+    }
+    this.externalTexts = [];
+    this.textSelection = void 0;
+    if (hadSelection) this.emitTracks();
+  }
+  /** The engine's tracks and the loaded subtitles, the text track picked here marked active. */
+  emitTracks() {
+    const selection = this.textSelection;
+    const engine = selection === void 0 ? this.engineTracks : this.engineTracks.map((track) => track.kind === "text" ? { ...track, active: track.id === selection } : track);
+    const external = this.externalTexts.map((text6) => ({
+      id: text6.id,
+      kind: "text",
+      label: text6.label,
+      ...text6.language ? { language: text6.language } : {},
+      active: text6.id === selection
+    }));
+    this.tracksSub.next([...engine, ...external]);
   }
   handleEngineEvent(ev) {
     if (ev.type === "timeupdate") {
@@ -1034,7 +1171,8 @@ var PlayerFacade = class {
       return;
     }
     if (ev.type === "tracks") {
-      this.tracksSub.next(ev.tracks);
+      this.engineTracks = ev.tracks;
+      this.emitTracks();
       return;
     }
     if (ev.type === "state") {
@@ -1080,14 +1218,14 @@ var LocalMetadataProvider = class {
     const res = await fetch(id);
     if (!res.ok) throw new Error(`Metadata fetch failed: ${res.status}`);
     const ct = res.headers.get("content-type") ?? "";
-    const text = await res.text();
-    if (ct.includes("application/json") || looksLikeJson(text)) {
+    const text6 = await res.text();
+    if (ct.includes("application/json") || looksLikeJson(text6)) {
       try {
-        return JSON.parse(text);
+        return JSON.parse(text6);
       } catch {
       }
     }
-    return { description: text };
+    return { description: text6 };
   }
 };
 function looksLikeJson(t) {
@@ -1109,6 +1247,73 @@ var LocalSubtitleProvider = class {
   }
 };
 
+// src/plugins/subtitles/subtitle-file.ts
+function decodeSubtitleBytes(bytes) {
+  if (bytes[0] === 255 && bytes[1] === 254) return new TextDecoder("utf-16le").decode(bytes.subarray(2));
+  if (bytes[0] === 254 && bytes[1] === 255) return new TextDecoder("utf-16be").decode(bytes.subarray(2));
+  const body = bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191 ? bytes.subarray(3) : bytes;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(body);
+  } catch {
+    return new TextDecoder("windows-1252").decode(body);
+  }
+}
+function subtitleTextToVtt(text6) {
+  const lines = text6.replace(/^/, "").replace(/\r\n?/g, "\n");
+  if (/^WEBVTT/.test(lines)) return lines;
+  const body = lines.replace(/(\d{1,2}:\d{2}:\d{2}),(\d{3})/g, "$1.$2").replace(/\{\\[^}]*\}/g, "").trim();
+  return `WEBVTT
+
+${body}
+`;
+}
+var LANGUAGE_NAMES = {
+  fr: "fr",
+  fre: "fr",
+  fra: "fr",
+  french: "fr",
+  francais: "fr",
+  vf: "fr",
+  vostfr: "fr",
+  en: "en",
+  eng: "en",
+  english: "en",
+  anglais: "en",
+  es: "es",
+  spa: "es",
+  spanish: "es",
+  espanol: "es",
+  de: "de",
+  ger: "de",
+  deu: "de",
+  german: "de",
+  deutsch: "de",
+  it: "it",
+  ita: "it",
+  italian: "it",
+  italiano: "it",
+  pt: "pt",
+  por: "pt",
+  portuguese: "pt",
+  nl: "nl",
+  dut: "nl",
+  nld: "nl",
+  dutch: "nl",
+  ja: "ja",
+  jpn: "ja",
+  japanese: "ja",
+  ar: "ar",
+  ara: "ar",
+  arabic: "ar"
+};
+function describeSubtitleFile(fileName) {
+  const base = fileName.replace(/\.(srt|vtt)$/i, "");
+  const parts = base.split(".");
+  const tag = parts.length > 1 ? parts[parts.length - 1].normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase() : "";
+  const language = LANGUAGE_NAMES[tag];
+  return { label: base, ...language ? { language } : {} };
+}
+
 // src/utils/cache-store.ts
 var DefaultCacheStore = class {
   dbp = null;
@@ -1295,7 +1500,10 @@ var ResiliencePlugin = class {
   id = "resilience";
   attempts = 0;
   recovering = false;
+  /** Bumped by every load: a retry only reloads the media that failed, never one loaded since. */
+  loadGeneration = 0;
   async onLoadStart(ctx) {
+    this.loadGeneration++;
     this.attempts = 0;
     this.recovering = false;
     if (ctx.config.resilience.healthEndpoint) {
@@ -1309,6 +1517,7 @@ var ResiliencePlugin = class {
     if (this.attempts >= max) return;
     this.attempts++;
     this.recovering = true;
+    const generation = this.loadGeneration;
     const min = ctx.config.resilience.backoffMs?.min ?? 500;
     const maxMs = ctx.config.resilience.backoffMs?.max ?? 8e3;
     const backoff = Math.min(maxMs, min * Math.pow(2, this.attempts - 1));
@@ -1317,6 +1526,7 @@ var ResiliencePlugin = class {
       await this.health(ctx);
     }
     await sleep(backoff);
+    if (generation !== this.loadGeneration) return;
     try {
       const snap = ctx.facade.snapshot();
       await ctx.facade.reload({ startTimeSec: snap.currentTime || void 0 });
@@ -1376,6 +1586,3827 @@ function createSsaiManifestRewritePlugin() {
   };
 }
 
+// src/engine/remote-playback.engine.ts
+function createRemotePlaybackEngineFactory(options) {
+  return {
+    id: "remote",
+    priority: options.priority ?? 100,
+    supports: (config) => options.session() !== null && !!config.source.url,
+    supportsWithCaps: (config) => options.session() !== null && !!config.source.url,
+    create: () => new RemotePlaybackEngine(options)
+  };
+}
+var RemotePlaybackEngine = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  id = "remote";
+  listeners = /* @__PURE__ */ new Set();
+  session = null;
+  source = null;
+  /** What the device plays, as the app described it. */
+  media = null;
+  startSec = 0;
+  sent = false;
+  /** The device played the media to its end: it closed it, and only takes it again sent anew. */
+  finished = false;
+  durationSec = 0;
+  positionSec = 0;
+  /** Where a converted stream starts in the media: the device counts from there. */
+  offsetSec = 0;
+  /** Furthest position the device reported since the media was sent: an end before any progress is a refusal. */
+  furthestSec = 0;
+  conversionTried = false;
+  lastState = null;
+  timer;
+  polling = false;
+  failures = 0;
+  destroyed = false;
+  async attach(videoEl) {
+    try {
+      videoEl.pause();
+      while (videoEl.firstChild) videoEl.removeChild(videoEl.firstChild);
+      videoEl.removeAttribute("src");
+      videoEl.load();
+    } catch {
+    }
+  }
+  async load(source, opts) {
+    this.session = this.options.session();
+    if (!this.session) throw new Error("No remote device is selected");
+    this.source = source;
+    this.media = null;
+    this.startSec = Math.max(0, opts?.startTimeSec ?? 0);
+    this.positionSec = this.startSec;
+    this.offsetSec = 0;
+    this.sent = false;
+    this.finished = false;
+    this.furthestSec = 0;
+    this.conversionTried = false;
+    this.lastState = null;
+    this.emit({ type: "timeupdate", currentTime: this.positionSec, duration: this.durationSec });
+  }
+  async play() {
+    const session = this.requireSession();
+    if (this.finished) this.restartAt(0);
+    if (!this.sent) {
+      this.emit({ type: "state", state: "loading" });
+      const media = this.media ?? await this.options.media(this.source, this.startSec);
+      if (this.destroyed) return;
+      try {
+        await this.send(session, media, this.startSec);
+      } catch (error) {
+        if (!this.convertible(media) || !(error instanceof RemotePlaybackError)) throw error;
+        this.conversionTried = true;
+        const converted = await this.options.convertedMedia(this.source, this.startSec).catch(() => {
+          throw error;
+        });
+        if (this.destroyed) return;
+        await this.send(session, converted, this.startSec);
+      }
+      this.sent = true;
+      this.startPolling();
+    } else {
+      await session.play();
+    }
+    this.lastState = "playing";
+    this.emit({ type: "state", state: "playing" });
+  }
+  async pause() {
+    if (!this.sent) return;
+    await this.requireSession().pause();
+    this.lastState = "paused";
+    this.emit({ type: "state", state: "paused" });
+  }
+  async seekTo(timeSec) {
+    const target = Math.max(0, timeSec);
+    this.positionSec = target;
+    if (!this.sent || this.finished) {
+      this.restartAt(target);
+    } else if (this.media?.conversion) {
+      const session = this.requireSession();
+      const paused = this.lastState === "paused";
+      await this.send(session, this.media, target);
+      if (paused) await session.pause();
+    } else {
+      await this.requireSession().seek(target);
+    }
+    this.emit({ type: "timeupdate", currentTime: target, duration: this.durationSec });
+  }
+  async setVolume(volume) {
+    if (!this.session) return;
+    await this.session.setVolume(Math.min(1, Math.max(0, volume))).catch(() => void 0);
+  }
+  async setPlaybackRate(_rate) {
+  }
+  async setTextTrack(_trackId) {
+  }
+  async setAudioTrack(_trackId) {
+  }
+  async setVideoTrack(_trackId) {
+  }
+  async getTracks() {
+    return [];
+  }
+  onEvent(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  /** Stops following the device; the session stays open for the next media. */
+  async destroy() {
+    this.destroyed = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    this.listeners.clear();
+  }
+  /** Reads the device once; exposed for hosts and tests that do not want to wait for the timer. */
+  async poll() {
+    if (!this.session || !this.sent || this.polling || this.destroyed) return;
+    this.polling = true;
+    try {
+      const status = await this.session.status();
+      if (this.destroyed) return;
+      this.failures = 0;
+      if (status.durationSec && !this.media?.conversion) this.durationSec = status.durationSec;
+      if (status.positionSec !== void 0) this.positionSec = this.offsetSec + status.positionSec;
+      this.furthestSec = Math.max(this.furthestSec, this.positionSec - this.offsetSec);
+      const wasPlaying = this.lastState === "playing" || this.lastState === "buffering";
+      const refused = (status.ended || status.state === "stopped") && this.furthestSec < 1 && !this.source?.live && (status.ended || wasPlaying);
+      if ((refused || status.error) && this.convertible(this.media)) {
+        await this.convertAfterRefusal(status.error);
+        return;
+      }
+      this.emit({ type: "timeupdate", currentTime: this.positionSec, duration: this.durationSec });
+      if (status.error) {
+        this.emit({ type: "error", error: { code: "REMOTE_PLAYBACK", message: status.error, fatal: false } });
+      }
+      if (refused) {
+        this.emit({ type: "error", error: { code: "REMOTE_PLAYBACK", message: status.error ?? "The device could not play this media", fatal: false } });
+        this.lastState = status.state;
+        if (this.timer) clearInterval(this.timer);
+        this.timer = void 0;
+        return;
+      }
+      const nearEnd = this.durationSec > 0 && this.positionSec >= this.durationSec - 3;
+      let state = null;
+      if (status.state === "playing") state = { type: "state", state: "playing" };
+      else if (status.state === "paused") state = { type: "state", state: "paused" };
+      else if (status.state === "buffering" || status.state === "loading") state = { type: "state", state: "buffering" };
+      else if (status.ended || wasPlaying && nearEnd && !this.source?.live) state = { type: "state", state: "ended" };
+      else if (wasPlaying) state = { type: "state", state: "paused" };
+      if (state?.state === "ended") {
+        this.finished = true;
+        if (this.timer) clearInterval(this.timer);
+        this.timer = void 0;
+      }
+      if (state && status.state !== this.lastState) this.emit(state);
+      this.lastState = status.state;
+    } catch (error) {
+      this.failures += 1;
+      if (this.failures === 3) {
+        this.emit({ type: "error", error: { code: "REMOTE_UNREACHABLE", message: error instanceof Error ? error.message : String(error), fatal: false } });
+      }
+    } finally {
+      this.polling = false;
+    }
+  }
+  restartAt(positionSec) {
+    this.finished = false;
+    this.sent = false;
+    this.startSec = positionSec;
+  }
+  /** Sends a media to the device from a position of it; a converted stream starts there and counts from 0. */
+  async send(session, media, startSec) {
+    const conversion = media.conversion;
+    this.durationSec = media.durationSec ?? 0;
+    await session.load(conversion ? { ...media, url: conversion.at(startSec), startSec: 0, ...media.durationSec ? { durationSec: Math.max(0, media.durationSec - startSec) } : {} } : { ...media, startSec });
+    this.media = media;
+    this.offsetSec = conversion ? startSec : 0;
+    this.positionSec = startSec;
+    this.furthestSec = 0;
+  }
+  convertible(media) {
+    return !!this.options.convertedMedia && !!media && !media.conversion && !media.live && !this.conversionTried;
+  }
+  /** The device gave up on the media as it is: it gets it converted, from where it was. */
+  async convertAfterRefusal(reason) {
+    this.conversionTried = true;
+    const position = this.positionSec;
+    try {
+      const converted = await this.options.convertedMedia(this.source, position);
+      if (this.destroyed) return;
+      await this.send(this.requireSession(), converted, position);
+      this.lastState = "playing";
+    } catch {
+      if (this.destroyed) return;
+      this.emit({ type: "error", error: { code: "REMOTE_PLAYBACK", message: reason ?? "The device could not play this media", fatal: false } });
+      if (this.timer) clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  startPolling() {
+    if (this.timer || this.destroyed) return;
+    this.timer = setInterval(() => void this.poll(), this.options.pollMs ?? 1e3);
+  }
+  requireSession() {
+    if (!this.session || this.destroyed) throw new Error("No remote device is selected");
+    return this.session;
+  }
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
+  }
+};
+
+// src/domain/audio-library.ts
+function createAudioLibrarySnapshot(tracks, playlists = []) {
+  const trackCopies = tracks.map(cloneAudioTrack);
+  return {
+    tracks: trackCopies,
+    albums: groupAudioAlbums(trackCopies),
+    artists: groupAudioArtists(trackCopies),
+    genres: groupAudioGenres(trackCopies),
+    playlists: playlists.map((playlist) => ({ ...playlist, trackIds: [...playlist.trackIds] }))
+  };
+}
+function searchAudioLibrarySnapshot(snapshot, searchTerm) {
+  const query = normalizeAudioSearchText(searchTerm);
+  if (!query) {
+    return {
+      ...cloneAudioLibrarySnapshot(snapshot),
+      active: false,
+      query,
+      directTrackIds: [],
+      matchedTrackIds: [],
+      matchedAlbumIds: [],
+      matchedArtistIds: [],
+      matchedGenreIds: [],
+      matchedPlaylistIds: []
+    };
+  }
+  const directTrackIds = ids(snapshot.tracks.filter((track) => metadataMatchesQuery(audioTrackSearchValues(track), query)));
+  const matchedAlbumIds = ids(snapshot.albums.filter((album) => metadataMatchesQuery(audioAlbumSearchValues(album), query)));
+  const matchedArtistIds = ids(snapshot.artists.filter((artist) => metadataMatchesQuery(audioArtistSearchValues(artist), query)));
+  const matchedGenreIds = ids(snapshot.genres.filter((genre) => metadataMatchesQuery(audioGenreSearchValues(genre), query)));
+  const matchedPlaylistIds = ids(snapshot.playlists.filter((playlist) => metadataMatchesQuery(audioPlaylistSearchValues(playlist), query)));
+  const matchedTrackIds = new Set(directTrackIds);
+  for (const album of snapshot.albums) {
+    if (matchedAlbumIds.includes(album.id)) addTrackIds(matchedTrackIds, album.tracks);
+  }
+  for (const artist of snapshot.artists) {
+    if (matchedArtistIds.includes(artist.id)) addTrackIds(matchedTrackIds, artist.tracks);
+  }
+  for (const genre of snapshot.genres) {
+    if (matchedGenreIds.includes(genre.id)) addTrackIds(matchedTrackIds, genre.tracks);
+  }
+  for (const playlist of snapshot.playlists) {
+    if (matchedPlaylistIds.includes(playlist.id)) {
+      playlist.trackIds.forEach((trackId) => matchedTrackIds.add(trackId));
+    }
+  }
+  const matchedTracks = snapshot.tracks.filter((track) => matchedTrackIds.has(track.id));
+  const matchedAlbums = snapshot.albums.filter((album) => matchedAlbumIds.includes(album.id) || album.tracks.some((track) => matchedTrackIds.has(track.id)));
+  const matchedArtists = snapshot.artists.filter((artist) => matchedArtistIds.includes(artist.id) || artist.tracks.some((track) => matchedTrackIds.has(track.id)));
+  const matchedGenres = snapshot.genres.filter((genre) => matchedGenreIds.includes(genre.id) || genre.tracks.some((track) => matchedTrackIds.has(track.id)));
+  const matchedPlaylists = snapshot.playlists.filter((playlist) => matchedPlaylistIds.includes(playlist.id) || !matchedPlaylistIds.length && playlist.trackIds.some((trackId) => matchedTrackIds.has(trackId)));
+  return {
+    active: true,
+    query,
+    tracks: matchedTracks.map(cloneAudioTrack),
+    albums: matchedAlbums.map(cloneAudioAlbum),
+    artists: matchedArtists.map(cloneAudioArtist),
+    genres: matchedGenres.map(cloneAudioGenre),
+    playlists: matchedPlaylists.map(cloneAudioPlaylist),
+    directTrackIds,
+    matchedTrackIds: [...matchedTrackIds],
+    matchedAlbumIds,
+    matchedArtistIds,
+    matchedGenreIds,
+    matchedPlaylistIds
+  };
+}
+function normalizeAudioSearchText(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim();
+}
+function audioTrackMatchesSearch(track, searchTerm) {
+  const query = normalizeAudioSearchText(searchTerm);
+  return !!query && metadataMatchesQuery(audioTrackSearchValues(track), query);
+}
+function groupAudioAlbums(tracks) {
+  const groups = groupByMetadata(
+    tracks,
+    (track) => track.album,
+    (track) => track.albumArtist ? `${metadataGroupKey(track.albumArtist)}\0` : ""
+  );
+  const titleCounts = /* @__PURE__ */ new Map();
+  for (const [albumTitle] of groups) {
+    const slug = slugifyAudioLibraryId(albumTitle);
+    titleCounts.set(slug, (titleCounts.get(slug) ?? 0) + 1);
+  }
+  const albums = groups.map(([albumTitle, albumTracks]) => {
+    const albumArtist = firstDefined(albumTracks.map((track) => track.albumArtist?.trim() || void 0));
+    const slug = slugifyAudioLibraryId(albumTitle);
+    return {
+      // Same-title albums of different artists get the artist in their id to stay distinct.
+      id: albumArtist && (titleCounts.get(slug) ?? 0) > 1 ? `album:${slug}--${slugifyAudioLibraryId(albumArtist)}` : `album:${slug}`,
+      title: albumTitle,
+      artist: uniqueValues(albumTracks.map((track) => track.albumArtist ?? track.artist)).join(", ") || void 0,
+      year: mostFrequentYear(albumTracks),
+      artwork: firstDefined(albumTracks.map((track) => track.artwork?.[0]?.src)),
+      tracks: albumTracks.map(cloneAudioTrack)
+    };
+  });
+  return albums.sort((left, right) => (right.year ?? Number.NEGATIVE_INFINITY) - (left.year ?? Number.NEGATIVE_INFINITY) || left.title.localeCompare(right.title, void 0, { sensitivity: "base", numeric: true }));
+}
+function groupAudioArtists(tracks) {
+  return groupByMetadata(tracks, (track) => track.albumArtist ?? track.artist).map(([artistName, artistTracks]) => ({
+    id: `artist:${slugifyAudioLibraryId(artistName)}`,
+    name: artistName,
+    artwork: firstDefined(artistTracks.map((track) => track.artwork?.[0]?.src)),
+    tracks: artistTracks.map(cloneAudioTrack)
+  }));
+}
+function groupAudioGenres(tracks) {
+  return groupByMetadata(tracks, (track) => track.genre).map(([genreName, genreTracks]) => ({
+    id: `genre:${slugifyAudioLibraryId(genreName)}`,
+    name: genreName,
+    tracks: genreTracks.map(cloneAudioTrack)
+  }));
+}
+function cloneAudioLibrarySnapshot(snapshot) {
+  return {
+    tracks: snapshot.tracks.map(cloneAudioTrack),
+    albums: snapshot.albums.map(cloneAudioAlbum),
+    artists: snapshot.artists.map(cloneAudioArtist),
+    genres: snapshot.genres.map(cloneAudioGenre),
+    playlists: snapshot.playlists.map(cloneAudioPlaylist)
+  };
+}
+function cloneAudioAlbum(album) {
+  return {
+    ...album,
+    tracks: album.tracks.map(cloneAudioTrack)
+  };
+}
+function cloneAudioArtist(artist) {
+  return {
+    ...artist,
+    tracks: artist.tracks.map(cloneAudioTrack)
+  };
+}
+function cloneAudioGenre(genre) {
+  return {
+    ...genre,
+    tracks: genre.tracks.map(cloneAudioTrack)
+  };
+}
+function cloneAudioPlaylist(playlist) {
+  return {
+    ...playlist,
+    trackIds: [...playlist.trackIds]
+  };
+}
+function cloneAudioTrack(track) {
+  return {
+    ...track,
+    artwork: track.artwork?.map((artwork) => ({ ...artwork }))
+  };
+}
+function groupByMetadata(tracks, pickValue, scope = () => "") {
+  const groups = /* @__PURE__ */ new Map();
+  for (const track of tracks) {
+    const name = pickValue(track)?.trim();
+    if (!name) continue;
+    const key = scope(track) + (metadataGroupKey(name) || name);
+    const group = groups.get(key) ?? { names: /* @__PURE__ */ new Map(), tracks: [] };
+    group.names.set(name, (group.names.get(name) ?? 0) + 1);
+    group.tracks.push(track);
+    groups.set(key, group);
+  }
+  return [...groups.values()].map((group) => {
+    const name = [...group.names].sort((left, right) => right[1] - left[1] || casingQuality(right[0]) - casingQuality(left[0]))[0][0];
+    return [name, group.tracks];
+  });
+}
+function casingQuality(value) {
+  return value !== value.toLowerCase() && value !== value.toUpperCase() ? 1 : 0;
+}
+function metadataGroupKey(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/&/g, "and").replace(/[^\p{L}\p{N}]+/gu, "");
+}
+function mostFrequentYear(tracks) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const track of tracks) {
+    if (track.year !== void 0) counts.set(track.year, (counts.get(track.year) ?? 0) + 1);
+  }
+  return [...counts].sort((left, right) => right[1] - left[1] || left[0] - right[0])[0]?.[0];
+}
+function uniqueValues(values) {
+  return [...new Set(values.flatMap((value) => {
+    const cleanValue = value?.trim();
+    return cleanValue ? [cleanValue] : [];
+  }))];
+}
+function firstDefined(values) {
+  return values.find((value) => value !== void 0);
+}
+function addTrackIds(target, tracks) {
+  tracks.forEach((track) => target.add(track.id));
+}
+function ids(items) {
+  return items.map((item) => item.id);
+}
+function audioTrackSearchValues(track) {
+  return [
+    track.title,
+    track.artist,
+    track.albumArtist,
+    track.album,
+    track.genre,
+    track.subtitle,
+    track.durationSec,
+    track.trackNo,
+    track.discNo,
+    track.year
+  ];
+}
+function audioAlbumSearchValues(album) {
+  return [
+    album.title,
+    album.artist,
+    album.year
+  ];
+}
+function audioArtistSearchValues(artist) {
+  return [
+    artist.name
+  ];
+}
+function audioGenreSearchValues(genre) {
+  return [
+    genre.name
+  ];
+}
+function audioPlaylistSearchValues(playlist) {
+  return [
+    playlist.name,
+    playlist.description
+  ];
+}
+function metadataMatchesQuery(values, query) {
+  return values.some((value) => {
+    if (value === void 0) return false;
+    return normalizeAudioSearchText(String(value)).includes(query);
+  });
+}
+function slugifyAudioLibraryId(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "unknown";
+}
+
+// src/domain/audio-metadata-harmony.ts
+var GENRE_KEY_ALIASES = {
+  rb: "rnb",
+  randb: "rnb",
+  rhythmandblues: "rnb",
+  rhythmnblues: "rnb",
+  hiphoprap: "hiphop",
+  raphiphop: "hiphop",
+  rocknroll: "rockandroll",
+  rockroll: "rockandroll",
+  ost: "soundtrack",
+  originalsoundtrack: "soundtrack",
+  worldmusic: "world"
+};
+var TRACK_NUMBER_PREFIX = /^\s*(\d{1,3})\s*(?:[.)_]|-(?!\d))\s*(?=[\p{L}(["'¿¡])/u;
+var DISC_SUFFIX = /\s*[([]?\s*(?:cd|disc|disk|disque)\s*(\d{1,2})\s*[)\]]?\s*$/iu;
+function harmonizeAudioMetadata(tracks) {
+  const corrections = { artists: 0, albums: 0, genres: 0, titles: 0, filled: 0 };
+  const corrected = /* @__PURE__ */ new Set();
+  const note = (track, kind) => {
+    corrections[kind] += 1;
+    corrected.add(track.id);
+  };
+  const working = tracks.map((original) => {
+    const track = { ...original };
+    const artist = cleanAudioArtistName(track.artist);
+    const albumArtist = cleanAudioArtistName(track.albumArtist);
+    if (artist !== tidy(track.artist) || albumArtist !== tidy(track.albumArtist)) note(track, "artists");
+    track.artist = artist;
+    track.albumArtist = albumArtist;
+    const album = tidy(track.album);
+    const disc = album ? DISC_SUFFIX.exec(album) : null;
+    if (album && disc && album.slice(0, disc.index).trim()) {
+      track.album = album.slice(0, disc.index).trim();
+      if (track.discNo === void 0) track.discNo = Number(disc[1]);
+      note(track, "albums");
+    } else {
+      track.album = album;
+    }
+    const genre = tidy(track.genre);
+    track.genre = genre;
+    const title = tidy(track.title) ?? track.title;
+    const numbered = TRACK_NUMBER_PREFIX.exec(title);
+    if (numbered && title.slice(numbered[0].length).trim()) {
+      track.title = title.slice(numbered[0].length).trim();
+      if (track.trackNo === void 0) track.trackNo = Number(numbered[1]);
+      note(track, "titles");
+    } else {
+      track.title = title;
+    }
+    return track;
+  });
+  const artistNames = preferredSpellings(working.flatMap((track) => [track.artist, track.albumArtist]), artistKey);
+  for (const track of working) {
+    const artist = track.artist && artistNames.get(artistKey(track.artist));
+    const albumArtist = track.albumArtist && artistNames.get(artistKey(track.albumArtist));
+    if (artist && artist !== track.artist || albumArtist && albumArtist !== track.albumArtist) note(track, "artists");
+    if (artist) track.artist = artist;
+    if (albumArtist) track.albumArtist = albumArtist;
+  }
+  for (const track of working) {
+    const separator = track.title.indexOf(" - ");
+    if (separator <= 0) continue;
+    const prefix = artistNames.get(artistKey(track.title.slice(0, separator)));
+    const rest = track.title.slice(separator + 3).trim();
+    if (!prefix || !rest) continue;
+    if (track.artist && artistKey(track.artist) !== artistKey(prefix)) continue;
+    track.title = rest;
+    note(track, "titles");
+    if (!track.artist) track.artist = prefix;
+  }
+  const genreNames = preferredSpellings(working.map((track) => track.genre), genreKey, readableCase);
+  for (const track of working) {
+    const genre = track.genre && genreNames.get(genreKey(track.genre));
+    if (genre && genre !== track.genre) {
+      track.genre = genre;
+      note(track, "genres");
+    }
+  }
+  for (const albumTracks of albumGroups(working)) {
+    const title = preferredSpellings(albumTracks.map((track) => track.album), metadataKey).get(metadataKey(albumTracks[0].album ?? ""));
+    const albumArtist = mostFrequent(albumTracks.map((track) => track.albumArtist), artistKey);
+    const year = mostFrequent(albumTracks.map((track) => track.year), String);
+    const genre = mostFrequent(albumTracks.map((track) => track.genre), genreKey);
+    for (const track of albumTracks) {
+      if (title && track.album !== title) {
+        track.album = title;
+        note(track, "albums");
+      }
+      if (albumArtist && !track.albumArtist) {
+        track.albumArtist = albumArtist;
+        note(track, "filled");
+      }
+      if (year !== void 0 && track.year === void 0) {
+        track.year = year;
+        note(track, "filled");
+      }
+      if (genre && !track.genre) {
+        track.genre = genre;
+        note(track, "filled");
+      }
+    }
+  }
+  return { tracks: working, corrections, correctedTracks: corrected.size };
+}
+function cleanAudioArtistName(value) {
+  let name = tidy(value);
+  if (!name) return void 0;
+  const numbered = TRACK_NUMBER_PREFIX.exec(name);
+  if (numbered && name.slice(numbered[0].length).trim()) name = name.slice(numbered[0].length).trim();
+  if (name.includes("_") && !name.includes(" ")) name = name.replace(/_+/g, " ").trim();
+  return name || void 0;
+}
+function mediaMetadataKey(value) {
+  return metadataKey(value);
+}
+function metadataKey(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/&/g, "and").replace(/[^\p{L}\p{N}]+/gu, "");
+}
+function artistKey(value) {
+  const key = metadataKey(value.replace(/^\s*the\s+/i, ""));
+  return key || metadataKey(value);
+}
+function genreKey(value) {
+  const key = metadataKey(value);
+  return GENRE_KEY_ALIASES[key] ?? key;
+}
+function albumGroups(tracks) {
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const track of tracks) {
+    if (!track.album) continue;
+    const key = metadataKey(track.album);
+    if (!key) continue;
+    byTitle.set(key, [...byTitle.get(key) ?? [], track]);
+  }
+  return [...byTitle.values()].flatMap((titleTracks) => {
+    const albumArtistKeys = new Set(titleTracks.flatMap((track) => track.albumArtist ? [artistKey(track.albumArtist)] : []));
+    if (albumArtistKeys.size <= 1) return [titleTracks];
+    const groups = /* @__PURE__ */ new Map();
+    for (const track of titleTracks) {
+      const key = track.albumArtist ? artistKey(track.albumArtist) : track.artist ? artistKey(track.artist) : "";
+      groups.set(key, [...groups.get(key) ?? [], track]);
+    }
+    return [...groups.values()];
+  });
+}
+function preferredSpellings(values, keyOf, finish = (value) => value) {
+  const variants = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (!value) continue;
+    const key = keyOf(value);
+    if (!key) continue;
+    const counts = variants.get(key) ?? /* @__PURE__ */ new Map();
+    counts.set(value, (counts.get(value) ?? 0) + 1);
+    variants.set(key, counts);
+  }
+  return new Map([...variants].map(([key, counts]) => {
+    const best = [...counts].sort(([left, leftCount], [right, rightCount]) => rightCount - leftCount || spellingQuality(right) - spellingQuality(left) || left.localeCompare(right))[0][0];
+    return [key, finish(best)];
+  }));
+}
+function mostFrequent(values, keyOf) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    if (value === void 0 || value === "") continue;
+    const key = keyOf(value);
+    const entry = counts.get(key);
+    counts.set(key, { value: entry?.value ?? value, count: (entry?.count ?? 0) + 1 });
+  }
+  return [...counts.values()].sort((left, right) => right.count - left.count)[0]?.value;
+}
+function spellingQuality(value) {
+  const acronym = value === value.toUpperCase() && value.replace(/[^\p{L}]/gu, "").length <= 4;
+  const mixedCase = acronym || value !== value.toLowerCase() && value !== value.toUpperCase() ? 2 : 0;
+  const accents = value.normalize("NFD").length !== value.length ? 1 : 0;
+  return mixedCase + accents;
+}
+function readableCase(value) {
+  const letters = value.replace(/[^\p{L}]/gu, "");
+  if (letters.length <= 3) return value;
+  if (value !== value.toLowerCase() && value !== value.toUpperCase()) return value;
+  return value.toLowerCase().replace(/(^|[\s\-/&(])(\p{L})/gu, (_, separator, letter) => separator + letter.toUpperCase());
+}
+function tidy(value) {
+  const text6 = value?.replace(/\s+/g, " ").trim().replace(/^["'](.*)["']$/, "$1").trim();
+  return text6 || void 0;
+}
+
+// src/domain/audio-identification.ts
+var AUDIO_IDENTIFICATION_VERSION = 1;
+var AUDIO_IDENTIFICATION_RETRY_MS = { unmatched: 30 * 24 * 36e5, error: 36e5 };
+var MIN_SEARCH_SCORE = 90;
+var DURATION_TOLERANCE_SEC = 4;
+var MIN_FINGERPRINT_SCORE = 0.85;
+var FINGERPRINT_DURATION_TOLERANCE_SEC = 7;
+function audioIdentificationDoubts(input) {
+  const inferred = new Set(input.inferredFields ?? []);
+  return ["title", "artist", "album"].filter((field) => inferred.has(field) || !input[field]);
+}
+function needsAudioIdentification(previous, fileKey, now, methods = ["text"]) {
+  if (!previous || previous.fileKey !== fileKey) return true;
+  if (previous.status === "trusted" || previous.status === "matched") return false;
+  if (previous.status === "error") return now - previous.checkedAt >= AUDIO_IDENTIFICATION_RETRY_MS.error;
+  if (methods.includes("fingerprint") && previous.method !== "fingerprint") return true;
+  if (previous.version < AUDIO_IDENTIFICATION_VERSION) return true;
+  return now - previous.checkedAt >= AUDIO_IDENTIFICATION_RETRY_MS.unmatched;
+}
+function pickAcoustIdRecording(input, results) {
+  const inferred = new Set(input.inferredFields ?? []);
+  const titleKey = !inferred.has("title") ? mediaMetadataKey(input.title) : "";
+  const best = [...results].filter((result) => result.score >= MIN_FINGERPRINT_SCORE && result.recordings.length).sort((left, right) => right.score - left.score)[0];
+  if (!best) return null;
+  const recordings = best.recordings.filter((recording2) => !input.durationSec || !recording2.durationSec || Math.abs(input.durationSec - recording2.durationSec) <= FINGERPRINT_DURATION_TOLERANCE_SEC);
+  const recording = recordings.find((item) => titleKey && item.title && mediaMetadataKey(item.title) === titleKey) ?? recordings[0];
+  return recording ? { recordingId: recording.id, confidence: Math.min(1, best.score) } : null;
+}
+function matchFingerprintedRecording(input, recording, confidence) {
+  if (!recording) return { status: "unmatched", method: "fingerprint", confidence: 0, fields: {} };
+  const inferred = new Set(input.inferredFields ?? []);
+  const release = pickRelease({ ...input, artist: inferred.has("artist") || !input.artist ? recording.artist : input.artist }, recording, [recording]);
+  const fields = { title: recording.title };
+  if (recording.artist) fields.artist = recording.artist;
+  addReleaseFields(fields, release);
+  return { status: "matched", method: "fingerprint", recordingId: recording.id, releaseId: release?.id, confidence, fields };
+}
+function matchMusicBrainzRecording(input, recordings) {
+  const titleKey = mediaMetadataKey(input.title);
+  const artistKey2 = input.artist ? mediaMetadataKey(input.artist) : "";
+  const candidates = !artistKey2 ? [] : recordings.filter((recording) => {
+    if (recording.score < MIN_SEARCH_SCORE || !titleKey || mediaMetadataKey(recording.title) !== titleKey) return false;
+    if (input.durationSec && recording.durationSec && Math.abs(input.durationSec - recording.durationSec) > DURATION_TOLERANCE_SEC) return false;
+    return sameArtist(artistKey2, recording.artist);
+  });
+  if (!candidates.length) return { status: "unmatched", method: "text", confidence: 0, fields: {} };
+  const best = [...candidates].sort((left, right) => right.score - left.score || durationGap(input, left) - durationGap(input, right))[0];
+  const release = pickRelease(input, best, candidates);
+  const fields = { title: best.title };
+  if (best.artist) fields.artist = best.artist;
+  addReleaseFields(fields, release);
+  return {
+    status: "matched",
+    method: "text",
+    recordingId: best.id,
+    releaseId: release?.id,
+    confidence: Math.min(1, best.score / 100),
+    fields
+  };
+}
+function applyAudioIdentification(item, identification) {
+  if (identification?.status !== "matched" || !identification.fields) return item;
+  const inferred = new Set(item.inferredFields ?? []);
+  const next = { ...item };
+  for (const [field, value] of Object.entries(identification.fields)) {
+    if (value === void 0 || item[field] !== void 0 && item[field] !== "" && !inferred.has(field)) continue;
+    next[field] = value;
+  }
+  return next;
+}
+function addReleaseFields(fields, release) {
+  if (!release) return;
+  fields.album = release.title;
+  if (release.artist) fields.albumArtist = release.artist;
+  if (release.year) fields.year = release.year;
+  if (release.trackNo) fields.trackNo = release.trackNo;
+}
+function pickRelease(input, best, candidates) {
+  const releases = [best, ...candidates.filter((candidate) => candidate !== best)].flatMap((recording) => recording.releases);
+  if (input.album) {
+    const albumKey = mediaMetadataKey(input.album);
+    return releases.find((release) => mediaMetadataKey(release.title) === albumKey);
+  }
+  const artistKey2 = mediaMetadataKey(input.artist ?? best.artist ?? "");
+  return releases.filter((release) => release.status === "Official" && release.primaryType === "Album" && sameArtist(artistKey2, release.artist)).sort((left, right) => (left.year ?? Number.MAX_SAFE_INTEGER) - (right.year ?? Number.MAX_SAFE_INTEGER))[0];
+}
+function sameArtist(artistKey2, candidate) {
+  if (!artistKey2 || !candidate) return false;
+  const candidateKey = mediaMetadataKey(candidate);
+  return candidateKey === artistKey2 || candidateKey.startsWith(artistKey2) || artistKey2.startsWith(candidateKey);
+}
+function durationGap(input, recording) {
+  return input.durationSec && recording.durationSec ? Math.abs(input.durationSec - recording.durationSec) : 0;
+}
+
+// src/domain/audio-identification-routine.ts
+var RETRY_INTERVAL_MS = 60 * 60 * 1e3;
+var NOTIFY_INTERVAL_MS = 3e3;
+function fileKeyFor(item) {
+  return `${item.size}:${Math.round(item.mtimeMs)}`;
+}
+function createIdentificationRoutine(options) {
+  const {
+    library,
+    identify,
+    methods = ["text"],
+    source = "musicbrainz",
+    now = Date.now,
+    retryIntervalMs = RETRY_INTERVAL_MS,
+    maxConsecutiveErrors = 3,
+    onError = (error) => console.error("[identification] run failed", error)
+  } = options;
+  let running = null;
+  let rerun = false;
+  let timer = null;
+  let disposed = false;
+  async function runOnce() {
+    const due = library.identificationCandidates().filter((item) => needsAudioIdentification(item.identification, fileKeyFor(item), now(), methods));
+    const lookups = [];
+    for (const item of due) {
+      if (audioIdentificationDoubts(item).length) {
+        lookups.push(item);
+      } else {
+        library.recordIdentification(item.id, {
+          version: AUDIO_IDENTIFICATION_VERSION,
+          status: "trusted",
+          checkedAt: now(),
+          fileKey: fileKeyFor(item)
+        });
+      }
+    }
+    if (!lookups.length) return { checked: 0, matched: 0 };
+    let checked = 0;
+    let matched = 0;
+    let consecutiveErrors = 0;
+    let lastNotifiedAt = now();
+    library.setIdentificationProgress({ identifying: true, identified: 0, identifyTotal: lookups.length });
+    for (const item of lookups) {
+      if (disposed) break;
+      const base = { version: AUDIO_IDENTIFICATION_VERSION, checkedAt: now(), fileKey: fileKeyFor(item), source };
+      try {
+        const match = await identify(item);
+        consecutiveErrors = 0;
+        library.recordIdentification(item.id, {
+          ...base,
+          status: match.status,
+          method: match.method,
+          recordingId: match.recordingId,
+          releaseId: match.releaseId,
+          confidence: match.confidence,
+          fields: match.status === "matched" ? match.fields : void 0
+        });
+        if (match.status === "matched") matched += 1;
+      } catch {
+        library.recordIdentification(item.id, { ...base, status: "error" });
+        consecutiveErrors += 1;
+      }
+      checked += 1;
+      library.setIdentificationProgress({ identifying: true, identified: checked, identifyTotal: lookups.length });
+      if (matched && now() - lastNotifiedAt >= NOTIFY_INTERVAL_MS) {
+        lastNotifiedAt = now();
+        library.notifyChanged();
+      }
+      if (consecutiveErrors >= maxConsecutiveErrors) break;
+    }
+    library.setIdentificationProgress({ identifying: false, identified: 0, identifyTotal: 0 });
+    await library.flush();
+    if (matched) library.notifyChanged();
+    return { checked, matched };
+  }
+  function run() {
+    if (disposed) return Promise.resolve();
+    if (running) {
+      rerun = true;
+      return running;
+    }
+    running = (async () => {
+      do {
+        rerun = false;
+        await runOnce();
+      } while (rerun && !disposed);
+    })().catch(onError).finally(() => {
+      running = null;
+    });
+    return running;
+  }
+  return {
+    run,
+    start() {
+      void run();
+      timer = setInterval(() => void run(), retryIntervalMs);
+      timer.unref?.();
+    },
+    dispose() {
+      disposed = true;
+      if (timer) clearInterval(timer);
+    }
+  };
+}
+
+// src/domain/media-library-model.ts
+var MEDIA_LIBRARY_MODEL_VERSION = 3;
+var MEDIA_EXTENSIONS = {
+  audio: /* @__PURE__ */ new Set([".aac", ".aif", ".aiff", ".flac", ".m4a", ".mp3", ".oga", ".ogg", ".opus", ".wav", ".weba", ".wma"]),
+  video: /* @__PURE__ */ new Set([".avi", ".m4v", ".mkv", ".mov", ".mp4", ".mpeg", ".mpg", ".ogv", ".webm", ".wmv"])
+};
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp"]);
+var FOLDER_ARTWORK_NAMES = ["cover", "folder", "front", "album", "poster", "artwork"];
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "$recycle.bin", "@eadir", "system volume information", ".trash", ".trashes"]);
+var CONTENT_TYPES = /* @__PURE__ */ new Map([
+  [".aac", "audio/aac"],
+  [".aif", "audio/aiff"],
+  [".aiff", "audio/aiff"],
+  [".avi", "video/x-msvideo"],
+  [".flac", "audio/flac"],
+  [".jpeg", "image/jpeg"],
+  [".jpg", "image/jpeg"],
+  [".m4a", "audio/mp4"],
+  [".m4v", "video/mp4"],
+  [".mkv", "video/x-matroska"],
+  [".mov", "video/quicktime"],
+  [".mp3", "audio/mpeg"],
+  [".mp4", "video/mp4"],
+  [".mpeg", "video/mpeg"],
+  [".mpg", "video/mpeg"],
+  [".oga", "audio/ogg"],
+  [".ogg", "audio/ogg"],
+  [".ogv", "video/ogg"],
+  [".opus", "audio/ogg"],
+  [".png", "image/png"],
+  [".wav", "audio/wav"],
+  [".weba", "audio/webm"],
+  [".webm", "video/webm"],
+  [".webp", "image/webp"],
+  [".wma", "audio/x-ms-wma"],
+  [".wmv", "video/x-ms-wmv"]
+]);
+var RELEASE_TOKEN = /[\s._\-([]+(?:2160p|1080p|720p|576p|480p|4k|uhd|hdr10?|dv|x264|x265|h\.?264|h\.?265|hevc|avc|bluray|blu-ray|brrip|bdrip|web[\s._-]?dl|webrip|hdtv|dvdrip|remux|proper|repack|multi|vostfr|vf[fqi]?|truefrench|french|english|subfrench|aac|ac3|eac3|dts|ddp?5\.1|5\.1|7\.1|10bit)\b.*$/i;
+var YEAR = /(?:^|[\s._\-([])((?:19|20)\d{2})(?=$|[\s._\-)\]])/;
+var EPISODE_SXE = /^(.*?)[\s._-]*\bs(\d{1,2})[\s._-]*e(\d{1,3})(?:[\s._-]*e\d{1,3})*\b[\s._-]*(.*)$/i;
+var EPISODE_NXN = /^(.*?)[\s._-]+(\d{1,2})x(\d{2,3})\b[\s._-]*(.*)$/i;
+var SEASON_FOLDER = /^(?:season|saison|staffel|temporada|s)[\s._-]*(\d{1,2})$/i;
+var EPISODE_ONLY = /^(?:e|ep|episode|épisode)?[\s._-]*(\d{1,3})\b[\s._-]*(.*)$/i;
+var MOVIE_FOLDER = /^(?:movies?|films?|cin[ée]ma)$/i;
+var SERIES_FOLDER = /^(?:series|s[ée]ries|tv|tv[\s._-]?shows?|shows?)$/i;
+var LEADING_TRACK_NUMBER = /^(\d{1,3})(?:[\s._-]+|\s*-\s*)(.+)$/;
+function mediaFileExtension(fileName) {
+  const name = fileName.split("/").pop() ?? fileName;
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot).toLowerCase() : "";
+}
+function isMediaFileName(fileName, kind) {
+  return MEDIA_EXTENSIONS[kind].has(mediaFileExtension(fileName));
+}
+function isImageFileName(fileName) {
+  return IMAGE_EXTENSIONS.has(mediaFileExtension(fileName));
+}
+function isIgnoredDirectoryName(name) {
+  return name.startsWith(".") || IGNORED_DIRECTORIES.has(name.toLowerCase());
+}
+function mediaContentType(fileName) {
+  return CONTENT_TYPES.get(mediaFileExtension(fileName)) ?? "application/octet-stream";
+}
+function folderArtworkRank(fileName) {
+  if (!isImageFileName(fileName)) return -1;
+  return FOLDER_ARTWORK_NAMES.indexOf(fileStem(fileName).toLowerCase());
+}
+function cleanMediaTitle(fileStemValue) {
+  const withoutRelease = String(fileStemValue).replace(RELEASE_TOKEN, "");
+  return tidy2(withoutRelease.replace(/\[[^\]]*\]/g, ""));
+}
+function parseEpisodeFileName(stem) {
+  const match = EPISODE_SXE.exec(stem) ?? EPISODE_NXN.exec(stem);
+  if (!match) return null;
+  return {
+    series: nonEmpty(cleanMediaTitle(match[1])),
+    season: positiveInteger(match[2]),
+    episode: positiveInteger(match[3]),
+    // The separator before the rest was consumed by the pattern: restore one so release tags ("1080p") are recognised.
+    episodeTitle: nonEmpty(cleanMediaTitle(` ${match[4] ?? ""}`))
+  };
+}
+function audioFieldsFromTags({ relativePath, common = {}, format = {} }) {
+  const stem = fileStem(relativePath);
+  const numbered = LEADING_TRACK_NUMBER.exec(stem);
+  const ancestors = ancestorNames(relativePath);
+  const artists = Array.isArray(common.artists) ? common.artists.filter(Boolean) : [];
+  const genre = Array.isArray(common.genre) ? common.genre.find(Boolean) : common.genre;
+  const taggedArtist = nonEmpty(common.artist) ?? nonEmpty(artists.join(", ")) ?? nonEmpty(common.albumartist);
+  const inferredFields = [
+    !nonEmpty(common.title) && "title",
+    !taggedArtist && "artist",
+    !nonEmpty(common.albumartist) && !nonEmpty(common.artist) && "albumArtist",
+    !nonEmpty(common.album) && "album",
+    !positiveInteger(common.track?.no) && numbered && "trackNo"
+  ].filter((field) => typeof field === "string");
+  return {
+    title: nonEmpty(common.title) ?? cleanMediaTitle(numbered ? numbered[2] : stem),
+    artist: taggedArtist ?? (ancestors[1] ? tidy2(ancestors[1]) : void 0),
+    albumArtist: nonEmpty(common.albumartist) ?? nonEmpty(common.artist) ?? (ancestors[1] ? tidy2(ancestors[1]) : void 0),
+    album: nonEmpty(common.album) ?? (ancestors[0] ? tidy2(ancestors[0]) : void 0),
+    genre: nonEmpty(genre),
+    trackNo: positiveInteger(common.track?.no) ?? (numbered ? positiveInteger(numbered[1]) : void 0),
+    discNo: positiveInteger(common.disk?.no),
+    year: positiveInteger(common.year),
+    durationSec: durationOf(format),
+    inferredFields: inferredFields.length ? inferredFields : void 0
+  };
+}
+function videoFieldsFromTags({ relativePath, common = {}, format = {} }) {
+  const stem = fileStem(relativePath);
+  const ancestors = ancestorNames(relativePath);
+  const durationSec = durationOf(format);
+  const yearMatch = YEAR.exec(stem);
+  const taggedTitle = nonEmpty(common.title);
+  const base = { durationSec, year: positiveInteger(common.year) ?? (yearMatch ? positiveInteger(yearMatch[1]) : void 0) };
+  if (common.stik === 10 || nonEmpty(common.tvShow)) {
+    const parsed2 = parseEpisodeFileName(stem);
+    return {
+      ...base,
+      category: "episode",
+      series: nonEmpty(common.tvShow) ?? parsed2?.series ?? seriesFromFolders(ancestors) ?? cleanMediaTitle(stem),
+      season: positiveInteger(common.tvSeason) ?? parsed2?.season ?? seasonFromFolders(ancestors),
+      episode: positiveInteger(common.tvEpisode) ?? parsed2?.episode,
+      title: taggedTitle ?? parsed2?.episodeTitle ?? cleanMediaTitle(stem)
+    };
+  }
+  const parsed = parseEpisodeFileName(stem);
+  if (parsed?.season !== void 0 && parsed.episode !== void 0) {
+    return {
+      ...base,
+      category: "episode",
+      // The folder wins over the file name. A season folder says what the series is with far
+      // more authority than a release name: the same series arrives with several spellings, or
+      // with none at all when the name is obfuscated, and each spelling would be its own series
+      // in the library. What the viewer named the folder is what they mean.
+      series: seriesFromFolders(ancestors) ?? parsed.series ?? cleanMediaTitle(stem),
+      season: parsed.season,
+      episode: parsed.episode,
+      title: taggedTitle ?? parsed.episodeTitle ?? cleanMediaTitle(stem)
+    };
+  }
+  const seasonFolderIndex = ancestors.findIndex((name) => SEASON_FOLDER.test(name));
+  if (seasonFolderIndex === 0) {
+    const episodeMatch = EPISODE_ONLY.exec(stem);
+    const series = ancestors[1] && !SERIES_FOLDER.test(ancestors[1]) ? tidy2(ancestors[1]) : void 0;
+    if (series) {
+      return {
+        ...base,
+        category: "episode",
+        series,
+        season: positiveInteger(SEASON_FOLDER.exec(ancestors[0])?.[1]),
+        episode: episodeMatch ? positiveInteger(episodeMatch[1]) : void 0,
+        title: taggedTitle ?? nonEmpty(cleanMediaTitle(episodeMatch?.[2] ?? "")) ?? cleanMediaTitle(stem)
+      };
+    }
+  }
+  const underSeriesFolder = ancestors.findIndex((name) => SERIES_FOLDER.test(name));
+  if (underSeriesFolder > 0) {
+    const episodeMatch = EPISODE_ONLY.exec(stem);
+    return {
+      ...base,
+      category: "episode",
+      series: tidy2(ancestors[underSeriesFolder - 1]),
+      season: seasonFromFolders(ancestors.slice(0, underSeriesFolder)),
+      episode: episodeMatch ? positiveInteger(episodeMatch[1]) : void 0,
+      title: taggedTitle ?? nonEmpty(cleanMediaTitle(episodeMatch?.[2] ?? "")) ?? cleanMediaTitle(stem)
+    };
+  }
+  const movieTitle = taggedTitle ?? cleanMediaTitle(yearMatch ? stem.slice(0, yearMatch.index) : stem);
+  const inMovieFolder = ancestors.some((name) => MOVIE_FOLDER.test(name));
+  if (common.stik === 9 || inMovieFolder || yearMatch || durationSec !== void 0 && durationSec >= 40 * 60) {
+    return { ...base, category: "movie", title: movieTitle || cleanMediaTitle(stem) };
+  }
+  return { ...base, category: "other", title: taggedTitle ?? cleanMediaTitle(stem) };
+}
+function ancestorNames(relativePath) {
+  return relativePath.split("/").filter(Boolean).slice(0, -1).reverse();
+}
+function fileStem(path) {
+  const name = path.split("/").pop() ?? path;
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function tidy2(value) {
+  return String(value ?? "").replace(/[._]+/g, " ").replace(/\s*[-–]\s*$/, "").replace(/^\s*[-–]\s*/, "").replace(/\s{2,}/g, " ").trim();
+}
+function nonEmpty(value) {
+  const text6 = typeof value === "string" ? value.trim() : "";
+  return text6 || void 0;
+}
+function positiveInteger(value) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : void 0;
+}
+function durationOf(format) {
+  return typeof format.duration === "number" && Number.isFinite(format.duration) && format.duration > 0 ? Math.round(format.duration) : void 0;
+}
+function seasonFromFolders(ancestors) {
+  for (const name of ancestors) {
+    const match = SEASON_FOLDER.exec(name);
+    if (match) return positiveInteger(match[1]);
+  }
+  return void 0;
+}
+function seriesFromFolders(ancestors) {
+  const seasonIndex = ancestors.findIndex((name) => SEASON_FOLDER.test(name));
+  if (seasonIndex >= 0 && ancestors[seasonIndex + 1]) return tidy2(ancestors[seasonIndex + 1]);
+  return void 0;
+}
+
+// src/domain/media-source.ts
+function normalizeMediaSourceAddress(address) {
+  const trimmed = address.trim();
+  if (!trimmed) throw new Error("Server address is required");
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `http://${trimmed}`;
+  const url = new URL(withScheme);
+  if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("Server address must be http or https");
+  url.hash = "";
+  url.search = "";
+  return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}
+function mediaSourceItemId(accountId, remoteId) {
+  return `src:${accountId}:${remoteId}`;
+}
+function parseMediaSourceItemId(id) {
+  const match = /^src:([^:]+):(.+)$/.exec(id);
+  return match ? { accountId: match[1], remoteId: match[2] } : null;
+}
+function ticksToSeconds(ticks) {
+  const value = Number(ticks);
+  return Number.isFinite(value) && value > 0 ? Math.round(value / 1e7) : void 0;
+}
+
+// src/domain/ringtone.ts
+var RINGTONE_MAX_SEC = 30;
+var RINGTONE_FADE_SEC = 0.05;
+function ringtoneSegment(options) {
+  const duration = Math.max(0, finite(options.trackDurationSec));
+  const wanted = Math.min(Math.max(1, finite(options.lengthSec)), RINGTONE_MAX_SEC);
+  const lengthSec = duration > 0 ? Math.min(wanted, duration) : wanted;
+  const position = Math.min(Math.max(0, finite(options.positionSec)), duration);
+  const startSec = duration > 0 ? Math.min(position, Math.max(0, duration - lengthSec)) : 0;
+  return { startSec, lengthSec };
+}
+function fadeEdges(channels, sampleRate, fadeSec = RINGTONE_FADE_SEC) {
+  const frames = channels[0]?.length ?? 0;
+  if (!frames || sampleRate <= 0) return;
+  const fade = Math.max(1, Math.min(Math.round(fadeSec * sampleRate), Math.floor(frames / 2)));
+  for (const channel of channels) {
+    for (let index = 0; index < fade; index += 1) {
+      const gain = index / fade;
+      channel[index] *= gain;
+      channel[frames - 1 - index] *= gain;
+    }
+  }
+}
+function encodeWav(channels, sampleRate) {
+  const channelCount = Math.max(1, channels.length);
+  const frames = channels[0]?.length ?? 0;
+  const bytesPerSample = 2;
+  const blockAlign = channelCount * bytesPerSample;
+  const dataBytes = frames * blockAlign;
+  const buffer = new ArrayBuffer(44 + dataBytes);
+  const view = new DataView(buffer);
+  writeText(view, 0, "RIFF");
+  view.setUint32(4, 36 + dataBytes, true);
+  writeText(view, 8, "WAVE");
+  writeText(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channelCount, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * blockAlign, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, 8 * bytesPerSample, true);
+  writeText(view, 36, "data");
+  view.setUint32(40, dataBytes, true);
+  let offset = 44;
+  for (let frame = 0; frame < frames; frame += 1) {
+    for (let channel = 0; channel < channelCount; channel += 1) {
+      const sample = Math.max(-1, Math.min(1, channels[channel]?.[frame] ?? 0));
+      view.setInt16(offset, Math.round(sample * (sample < 0 ? 32768 : 32767)), true);
+      offset += bytesPerSample;
+    }
+  }
+  return buffer;
+}
+function ringtoneFileName(title, extension = "wav") {
+  const safe = String(title ?? "").replace(/[/\\:*?"<>|\u0000-\u001f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 60);
+  return `${safe || "ringtone"}.${extension}`;
+}
+function finite(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+function writeText(view, offset, text6) {
+  for (let index = 0; index < text6.length; index += 1) view.setUint8(offset + index, text6.charCodeAt(index));
+}
+
+// src/domain/shake.ts
+var DEFAULTS = {
+  force: 12,
+  reversals: 3,
+  window: 700,
+  rest: 600,
+  pairWindow: 1800
+};
+function createShakeDetector(options = {}) {
+  const settings = { ...DEFAULTS, ...options };
+  let last = null;
+  let direction = 0;
+  let reversals = [];
+  let restingUntil = 0;
+  let firstShakeAt = 0;
+  function read(sample) {
+    const previous = last;
+    last = sample;
+    if (!previous) return null;
+    if (sample.at < restingUntil) return null;
+    const elapsed = sample.at - previous.at;
+    if (elapsed <= 0) return null;
+    const speed = (Math.abs(sample.x - previous.x) + Math.abs(sample.y - previous.y) + Math.abs(sample.z - previous.z)) / (elapsed / 1e3);
+    if (speed < settings.force) return null;
+    const moving = Math.sign(sample.x - previous.x + (sample.y - previous.y) + (sample.z - previous.z));
+    if (moving !== 0 && moving !== direction) {
+      direction = moving;
+      reversals.push(sample.at);
+    }
+    reversals = reversals.filter((at) => sample.at - at <= settings.window);
+    if (reversals.length < settings.reversals) return null;
+    reversals = [];
+    direction = 0;
+    restingUntil = sample.at + settings.rest;
+    if (firstShakeAt && sample.at - firstShakeAt <= settings.pairWindow) {
+      firstShakeAt = 0;
+      return "double";
+    }
+    firstShakeAt = sample.at;
+    return null;
+  }
+  function settle(now) {
+    if (!firstShakeAt || now - firstShakeAt <= settings.pairWindow) return null;
+    firstShakeAt = 0;
+    return "single";
+  }
+  function pendingFor(now) {
+    return firstShakeAt ? Math.max(0, settings.pairWindow - (now - firstShakeAt)) : 0;
+  }
+  function reset() {
+    last = null;
+    direction = 0;
+    reversals = [];
+    restingUntil = 0;
+    firstShakeAt = 0;
+  }
+  return { read, settle, pendingFor, reset };
+}
+
+// src/domain/vault.ts
+var VAULT_ROUNDS = 31e4;
+async function hashPasscode(code, crypto, options = {}) {
+  const rounds = options.rounds ?? VAULT_ROUNDS;
+  const salt = options.salt ?? toBase64(crypto.getRandomValues(new Uint8Array(16)));
+  const key = await crypto.subtle.importKey("raw", encode(code), "PBKDF2", false, ["deriveBits"]);
+  const bits = await crypto.subtle.deriveBits(
+    { name: "PBKDF2", salt: fromBase64(salt), iterations: rounds, hash: "SHA-256" },
+    key,
+    256
+  );
+  return { salt, hash: toBase64(new Uint8Array(bits)), rounds };
+}
+async function verifyPasscode(code, record, crypto) {
+  if (!record?.hash || !record.salt) return false;
+  const candidate = await hashPasscode(code, crypto, { salt: record.salt, rounds: record.rounds });
+  return equalInConstantTime(candidate.hash, record.hash);
+}
+function isUsablePasscode(code) {
+  return /^[0-9]{4,}$/.test(code) && new Set(code).size > 1;
+}
+function hiddenIds(locked, state) {
+  return state.open || !state.hasPasscode ? /* @__PURE__ */ new Set() : new Set(locked);
+}
+function withoutHidden(items, idOf, hidden) {
+  return hidden.size ? items.filter((item) => !hidden.has(idOf(item))) : [...items];
+}
+function encode(text6) {
+  const encoded = new TextEncoder().encode(text6);
+  const bytes = new Uint8Array(new ArrayBuffer(encoded.length));
+  bytes.set(encoded);
+  return bytes.buffer;
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function fromBase64(text6) {
+  const binary = atob(text6);
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes.buffer;
+}
+function equalInConstantTime(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  }
+  return difference === 0;
+}
+
+// src/domain/device-playback.ts
+function createIdleDevicePlaybackState(message) {
+  return {
+    status: "idle",
+    activeDeviceId: null,
+    activeDeviceName: null,
+    ...message ? { message } : {}
+  };
+}
+function reduceDevicePlaybackState(state, event) {
+  switch (event.type) {
+    case "connect":
+      return connectDevice(event.device, event.targetUrl, event.message);
+    case "playing":
+      return transitionActiveDevice(state, event.deviceId, {
+        status: "playing",
+        message: event.message ?? `Playing on ${state.activeDeviceName ?? "device"}.`
+      });
+    case "fail":
+      return transitionActiveDevice(state, event.deviceId, {
+        status: "failed",
+        error: event.error,
+        message: event.message ?? event.error
+      });
+    case "stop":
+      if (event.deviceId && state.activeDeviceId !== event.deviceId) return state;
+      return createIdleDevicePlaybackState(event.message);
+  }
+}
+function connectDevice(device, targetUrl, message) {
+  const activeDeviceId = device.id.trim();
+  const activeDeviceName = device.name.trim();
+  const cleanTargetUrl = targetUrl.trim();
+  if (!activeDeviceId || !activeDeviceName) {
+    return {
+      status: "failed",
+      activeDeviceId: activeDeviceId || null,
+      activeDeviceName: activeDeviceName || null,
+      error: "Playback device identity is incomplete.",
+      message: "Playback device identity is incomplete."
+    };
+  }
+  if (!cleanTargetUrl) {
+    return {
+      status: "failed",
+      activeDeviceId,
+      activeDeviceName,
+      error: "Playback target URL is required.",
+      message: "Playback target URL is required."
+    };
+  }
+  return {
+    status: "connecting",
+    activeDeviceId,
+    activeDeviceName,
+    targetUrl: cleanTargetUrl,
+    message: message ?? `Connecting to ${activeDeviceName}.`
+  };
+}
+function transitionActiveDevice(state, deviceId, patch) {
+  if (state.activeDeviceId !== deviceId) return state;
+  return {
+    activeDeviceId: state.activeDeviceId,
+    activeDeviceName: state.activeDeviceName,
+    targetUrl: state.targetUrl,
+    ...patch
+  };
+}
+
+// src/online/online-http.ts
+function createFetchOnlineJsonHttp(fetchFn = (input, init) => fetch(input, init)) {
+  return {
+    async getJson(url, options = {}) {
+      const response = await fetchFn(url, { signal: options.signal, headers: { Accept: "application/json" } });
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return response.json();
+    }
+  };
+}
+
+// src/online/media-cache.ts
+function planMediaCacheEviction(entries, budgetBytes, incomingBytes, protectedKeys = /* @__PURE__ */ new Set()) {
+  let total = entries.reduce((sum, entry) => sum + entry.size, 0) + incomingBytes;
+  if (total <= budgetBytes) return [];
+  const evicted = [];
+  const candidates = entries.filter((entry) => !protectedKeys.has(entry.key)).sort((left, right) => left.lastUsedAt - right.lastUsedAt);
+  for (const entry of candidates) {
+    evicted.push(entry.key);
+    total -= entry.size;
+    if (total <= budgetBytes) return evicted;
+  }
+  return null;
+}
+function createMediaCache(options) {
+  const { store, budgetBytes } = options;
+  const maxEntryBytes = Math.min(options.maxEntryBytes ?? budgetBytes / 4, budgetBytes);
+  const fetchFn = options.fetch ?? ((input, init) => fetch(input, init));
+  const now = options.now ?? Date.now;
+  const canDownload = options.canDownload ?? (() => true);
+  const index = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const failures = /* @__PURE__ */ new Map();
+  const FAILURE_RETRY_MS = 10 * 6e4;
+  let wanted = [];
+  let current = null;
+  let loaded = false;
+  const emit = () => listeners.forEach((listener) => listener());
+  const ready = store.entries().then(
+    (entries) => {
+      entries.forEach((entry) => index.set(entry.key, entry));
+      loaded = true;
+      pump();
+    },
+    () => {
+      loaded = true;
+    }
+  );
+  function pump() {
+    if (!loaded || current) return;
+    const next = wanted.find((request2) => !index.has(request2.key) && !isFailing(request2.key));
+    if (!next || !canDownload()) return;
+    const controller = new AbortController();
+    current = { key: next.key, controller };
+    void download(next, controller.signal).finally(() => {
+      current = null;
+      pump();
+    });
+  }
+  function isFailing(key) {
+    const failedAt = failures.get(key);
+    return failedAt !== void 0 && now() - failedAt < FAILURE_RETRY_MS;
+  }
+  async function fetchFirst(urls, signal) {
+    let failure = new Error("No URL to download");
+    for (const url of urls) {
+      try {
+        const response = await fetchFn(url, { signal });
+        if (response.ok) return { response, url };
+        failure = new Error(`HTTP ${response.status}`);
+      } catch (error) {
+        if (signal.aborted) throw error;
+        failure = error;
+      }
+    }
+    throw failure;
+  }
+  async function download(request2, signal) {
+    try {
+      const { response, url } = await fetchFirst([request2.url, ...request2.alternateUrls ?? []], signal);
+      const announced = Number(response.headers.get("content-length"));
+      if (announced > maxEntryBytes) {
+        failures.set(request2.key, now());
+        return;
+      }
+      const data = await response.blob();
+      if (signal.aborted || data.size === 0 || data.size > maxEntryBytes) return;
+      const protectedKeys = new Set(wanted.map((item) => item.key));
+      const evicted = planMediaCacheEviction([...index.values()], budgetBytes, data.size, protectedKeys);
+      if (!evicted) return;
+      if (evicted.length) {
+        await store.remove(evicted);
+        evicted.forEach((key) => index.delete(key));
+      }
+      const time = now();
+      const entry = {
+        key: request2.key,
+        url,
+        size: data.size,
+        contentType: data.type || response.headers.get("content-type") || "application/octet-stream",
+        storedAt: time,
+        lastUsedAt: time
+      };
+      await store.write(entry, data);
+      index.set(entry.key, entry);
+      failures.delete(request2.key);
+      emit();
+    } catch {
+      if (!signal.aborted) failures.set(request2.key, now());
+    }
+  }
+  return {
+    ready,
+    has: (key) => index.has(key),
+    async open(key) {
+      const entry = index.get(key);
+      if (!entry) return null;
+      const data = await store.read(key).catch(() => null);
+      if (!data) {
+        index.delete(key);
+        await store.remove([key]).catch(() => void 0);
+        emit();
+        return null;
+      }
+      entry.lastUsedAt = now();
+      void store.touch(key, entry.lastUsedAt).catch(() => void 0);
+      return data;
+    },
+    keep(requests) {
+      const seen = /* @__PURE__ */ new Set();
+      wanted = requests.filter((request2) => request2.key && request2.url && !seen.has(request2.key) && seen.add(request2.key));
+      if (current && !wanted.some((request2) => request2.key === current?.key)) current.controller.abort();
+      pump();
+    },
+    usage() {
+      const entries = [...index.values()];
+      return { bytes: entries.reduce((sum, entry) => sum + entry.size, 0), count: entries.length, budgetBytes };
+    },
+    async clear() {
+      wanted = [];
+      current?.controller.abort();
+      const keys = [...index.keys()];
+      index.clear();
+      failures.clear();
+      await store.remove(keys);
+      emit();
+    },
+    onChange(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/online/jellyfin.ts
+var JELLYFIN_CLIENT = { name: "NGXSP", version: "1.0.0" };
+var AUDIO_FIELDS = "Genres,ProductionYear,RunTimeTicks,ParentIndexNumber,IndexNumber,AlbumArtist,Artists,MediaSources";
+var VIDEO_FIELDS = "Genres,ProductionYear,RunTimeTicks,ParentIndexNumber,IndexNumber,SeriesName,MediaSources";
+var PAGE_SIZE = 200;
+function createJellyfinConnector(deviceId = "ngxsp") {
+  return {
+    kind: "jellyfin",
+    connect: (input, http) => connectJellyfin(input, http, deviceId),
+    browse: (account, options, http) => browseJellyfin(account, options, http),
+    lyrics: (account, item, http) => readJellyfinLyrics(account, item, http)
+  };
+}
+async function connectJellyfin(input, http, deviceId = "ngxsp") {
+  const baseUrl = normalizeMediaSourceAddress(input.address);
+  const system = await readJson(http, { url: `${baseUrl}/System/Info/Public` });
+  const serverName = text(system?.["ServerName"]);
+  const response = await http.send({
+    url: `${baseUrl}/Users/AuthenticateByName`,
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: jellyfinClientHeader(deviceId)
+    },
+    json: { Username: input.username ?? "", Pw: input.password ?? "" }
+  });
+  if (response.status === 401) throw new Error("Jellyfin refused this user name or password");
+  if (response.status >= 400) throw new Error(`Jellyfin sign-in failed (HTTP ${response.status})`);
+  const body = await response.json();
+  const token = text(body?.["AccessToken"]);
+  const user = body?.["User"] ?? {};
+  const userId = text(user["Id"]);
+  if (!token || !userId) throw new Error("Jellyfin did not return an access token");
+  return {
+    id: `jellyfin-${userId.slice(0, 8)}`,
+    kind: "jellyfin",
+    name: input.name?.trim() || serverName || new URL(baseUrl).host,
+    baseUrl,
+    username: text(user["Name"]) ?? input.username,
+    secret: token,
+    userId
+  };
+}
+async function browseJellyfin(account, options, http) {
+  const { userId } = account;
+  if (!userId) throw new Error("Jellyfin account is not signed in");
+  if (!options.containerId && !options.search) {
+    const body2 = await readJson(http, request(account, `${account.baseUrl}/Users/${userId}/Views`, options.signal));
+    const containers = itemsOf(body2).map((view) => libraryContainer(account, view)).filter((container) => !!container && (!options.kind || container.kind === options.kind || container.kind === "mixed"));
+    return { containers, items: [] };
+  }
+  const parameters = new URLSearchParams({
+    Recursive: "true",
+    Fields: options.kind === "video" ? VIDEO_FIELDS : AUDIO_FIELDS,
+    StartIndex: String(Math.max(0, options.startIndex ?? 0)),
+    Limit: String(Math.min(PAGE_SIZE, Math.max(1, options.limit ?? PAGE_SIZE))),
+    ImageTypeLimit: "1",
+    EnableImageTypes: "Primary"
+  });
+  if (options.containerId) parameters.set("ParentId", options.containerId);
+  if (options.search) parameters.set("SearchTerm", options.search);
+  if (options.kind === "video") {
+    parameters.set("IncludeItemTypes", "Movie,Episode,Video");
+    parameters.set("SortBy", "SeriesSortName,ParentIndexNumber,IndexNumber,SortName");
+  } else {
+    parameters.set("IncludeItemTypes", "Audio");
+    parameters.set("SortBy", "AlbumArtist,Album,ParentIndexNumber,IndexNumber,SortName");
+  }
+  parameters.set("SortOrder", "Ascending");
+  const body = await readJson(http, request(account, `${account.baseUrl}/Users/${userId}/Items?${parameters}`, options.signal));
+  const items = itemsOf(body).map((entry) => parseJellyfinItem(account, entry, options.kind ?? "audio")).filter((item) => !!item);
+  const total = Number(body?.["TotalRecordCount"]);
+  return { containers: [], items, ...Number.isFinite(total) ? { total } : {} };
+}
+async function readJellyfinLyrics(account, item, http) {
+  const remoteId = parseMediaSourceItemId(item.id)?.remoteId;
+  if (!remoteId) return null;
+  const response = await http.send(request(account, `${account.baseUrl}/Audio/${encodeURIComponent(remoteId)}/Lyrics`));
+  if (response.status >= 400) return null;
+  const lines = (await response.json())?.["Lyrics"];
+  if (!Array.isArray(lines) || !lines.length) return null;
+  const written = lines.map((line) => {
+    const entry = line;
+    const words = text(entry["Text"]) ?? "";
+    const ticks = Number(entry["Start"]);
+    return Number.isFinite(ticks) && ticks >= 0 ? `${lrcStamp(ticks / 1e7)}${words}` : words;
+  }).filter((line) => line.trim());
+  return written.length ? written.join("\n") : null;
+}
+function lrcStamp(seconds) {
+  const safe = Math.max(0, seconds);
+  const minutes = Math.floor(safe / 60);
+  return `[${String(minutes).padStart(2, "0")}:${(safe - minutes * 60).toFixed(2).padStart(5, "0")}]`;
+}
+function jellyfinStreamUrl(account, itemId, kind) {
+  const path = kind === "audio" ? `Audio/${encodeURIComponent(itemId)}/stream` : `Videos/${encodeURIComponent(itemId)}/stream`;
+  return `${account.baseUrl}/${path}?static=true&api_key=${encodeURIComponent(account.secret ?? "")}`;
+}
+function jellyfinImageUrl(account, itemId, tag, maxHeight = 480) {
+  const parameters = new URLSearchParams({ maxHeight: String(maxHeight), quality: "90" });
+  if (tag) parameters.set("tag", tag);
+  return `${account.baseUrl}/Items/${encodeURIComponent(itemId)}/Images/Primary?${parameters}`;
+}
+function jellyfinClientHeader(deviceId, token) {
+  const parts = [
+    `Client="${JELLYFIN_CLIENT.name}"`,
+    `Device="${JELLYFIN_CLIENT.name}"`,
+    `DeviceId="${deviceId}"`,
+    `Version="${JELLYFIN_CLIENT.version}"`
+  ];
+  if (token) parts.push(`Token="${token}"`);
+  return `MediaBrowser ${parts.join(", ")}`;
+}
+function parseJellyfinItem(account, entry, kind) {
+  const record = entry ?? {};
+  const remoteId = text(record["Id"]);
+  const title = text(record["Name"]);
+  if (!remoteId || !title) return null;
+  const type = text(record["Type"]);
+  const itemKind = type === "Audio" ? "audio" : type ? "video" : kind;
+  const imageTag = text(record["ImageTags"]?.["Primary"]);
+  const albumImageTag = text(record["AlbumPrimaryImageTag"]);
+  const albumId = text(record["AlbumId"]);
+  const artworkId = imageTag ? remoteId : albumImageTag && albumId ? albumId : void 0;
+  const item = {
+    id: mediaSourceItemId(account.id, remoteId),
+    kind: itemKind,
+    title,
+    url: jellyfinStreamUrl(account, remoteId, itemKind)
+  };
+  const duration = ticksToSeconds(record["RunTimeTicks"]);
+  if (duration) item.durationSec = duration;
+  if (artworkId) item.artworkUrl = jellyfinImageUrl(account, artworkId, imageTag ?? albumImageTag);
+  const year = Number(record["ProductionYear"]);
+  if (Number.isInteger(year) && year > 0) item.year = year;
+  const genre = allTexts(record["Genres"])[0];
+  if (genre) item.genre = genre;
+  const container = text(record["Container"]);
+  if (container) item.container = container;
+  if (itemKind === "audio") {
+    const artists = allTexts(record["Artists"]);
+    const albumArtist = text(record["AlbumArtist"]);
+    if (artists.length) item.artist = artists.join(", ");
+    else if (albumArtist) item.artist = albumArtist;
+    if (albumArtist) item.albumArtist = albumArtist;
+    const album = text(record["Album"]);
+    if (album) item.album = album;
+    const trackNo = positiveInteger2(record["IndexNumber"]);
+    if (trackNo) item.trackNo = trackNo;
+    const discNo = positiveInteger2(record["ParentIndexNumber"]);
+    if (discNo) item.discNo = discNo;
+    return item;
+  }
+  const series = text(record["SeriesName"]);
+  if (series) {
+    item.series = series;
+    const season = positiveInteger2(record["ParentIndexNumber"]);
+    if (season) item.season = season;
+    const episode = positiveInteger2(record["IndexNumber"]);
+    if (episode) item.episode = episode;
+  }
+  return item;
+}
+function libraryContainer(account, view) {
+  const record = view ?? {};
+  const id = text(record["Id"]);
+  const title = text(record["Name"]);
+  if (!id || !title) return null;
+  const collection = text(record["CollectionType"]);
+  const kind = collection === "music" ? "audio" : collection === "movies" || collection === "tvshows" || collection === "homevideos" || collection === "musicvideos" ? "video" : collection ? null : "mixed";
+  if (!kind) return null;
+  const imageTag = text(record["ImageTags"]?.["Primary"]);
+  return {
+    id,
+    title,
+    kind,
+    ...collection ? { subtitle: collection } : {},
+    ...imageTag ? { artworkUrl: jellyfinImageUrl(account, id, imageTag) } : {}
+  };
+}
+function request(account, url, signal) {
+  return {
+    url,
+    headers: { Authorization: jellyfinClientHeader(account.id, account.secret), Accept: "application/json" },
+    ...signal ? { signal } : {}
+  };
+}
+async function readJson(http, options) {
+  const response = await http.send(options);
+  if (response.status === 401 || response.status === 403) throw new Error("Jellyfin refused the connection; sign in again");
+  if (response.status >= 400) throw new Error(`Jellyfin request failed (HTTP ${response.status})`);
+  return response.json();
+}
+function itemsOf(body) {
+  const items = body?.["Items"];
+  return Array.isArray(items) ? items : [];
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function allTexts(value) {
+  return (Array.isArray(value) ? value : [value]).flatMap((entry) => {
+    const item = text(entry);
+    return item ? [item] : [];
+  });
+}
+function positiveInteger2(value) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : void 0;
+}
+
+// src/online/xml-text.ts
+function xmlTagContent(xml, name) {
+  const match = new RegExp(`<(?:[\\w.-]+:)?${name}\\b[^>]*?(?:/>|>([\\s\\S]*?)</(?:[\\w.-]+:)?${name}>)`, "i").exec(xml);
+  return match ? match[1] ?? "" : void 0;
+}
+function xmlTagText(xml, name) {
+  return xmlText(xmlTagContent(xml, name));
+}
+function xmlElements(xml, name) {
+  const pattern = new RegExp(`<(?:[\\w.-]+:)?${name}\\b((?:[^>"']|"[^"]*"|'[^']*')*?)(?:/>|>([\\s\\S]*?)</(?:[\\w.-]+:)?${name}>)`, "gi");
+  return [...xml.matchAll(pattern)].map((match) => ({ attributes: xmlAttributes(match[1]), content: match[2] }));
+}
+function xmlText(content) {
+  const value = content === void 0 ? void 0 : decodeXmlEntities(content.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1")).trim();
+  return value || void 0;
+}
+function decodeXmlEntities(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code))).replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16))).replace(/&amp;/g, "&");
+}
+function escapeXmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function xmlAttributes(source) {
+  const attributes = {};
+  for (const match of source.matchAll(/([\w.:-]+)\s*=\s*("([^"]*)"|'([^']*)')/g)) {
+    attributes[match[1].replace(/^[\w.-]+:/, "")] = decodeXmlEntities(match[3] ?? match[4] ?? "");
+  }
+  return attributes;
+}
+
+// src/online/upnp.ts
+var UpnpActionError = class extends Error {
+  constructor(action, code, status) {
+    super(`UPnP ${action} failed (${code ? `UPnP error ${code}` : `HTTP ${status}`})`);
+    this.action = action;
+    this.code = code;
+    this.status = status;
+    this.name = "UpnpActionError";
+  }
+  action;
+  code;
+  status;
+};
+function parseUpnpDeviceDescription(xml, descriptionUrl) {
+  const base = xmlTagText(xml, "URLBase") ?? descriptionUrl;
+  const services = xmlElements(xml, "service").flatMap((element) => {
+    const content = element.content ?? "";
+    const serviceType = xmlTagText(content, "serviceType");
+    const controlUrl = resolveUpnpUrl(xmlTagText(content, "controlURL"), base);
+    return serviceType && controlUrl ? [{ serviceType, controlUrl }] : [];
+  });
+  const icon = xmlElements(xml, "icon").map((element) => ({
+    url: resolveUpnpUrl(xmlTagText(element.content ?? "", "url"), base),
+    width: Number(xmlTagText(element.content ?? "", "width")) || 0,
+    type: xmlTagText(element.content ?? "", "mimetype") ?? ""
+  })).filter((candidate) => candidate.url && /png|jpe?g/i.test(candidate.type)).sort((left, right) => right.width - left.width)[0];
+  const udn = xmlTagText(xml, "UDN");
+  const deviceType = xmlTagText(xml, "deviceType");
+  const manufacturer = xmlTagText(xml, "manufacturer");
+  const modelName = xmlTagText(xml, "modelName");
+  const contentDirectory2 = findUpnpService(services, "ContentDirectory");
+  return {
+    friendlyName: xmlTagText(xml, "friendlyName") ?? modelName ?? new URL(descriptionUrl).host,
+    ...udn ? { udn } : {},
+    ...deviceType ? { deviceType } : {},
+    ...manufacturer ? { manufacturer } : {},
+    ...modelName ? { modelName } : {},
+    ...icon?.url ? { iconUrl: icon.url } : {},
+    services,
+    ...contentDirectory2 ? { contentDirectory: contentDirectory2 } : {}
+  };
+}
+function findUpnpService(services, name) {
+  return services.find((service) => service.serviceType.startsWith(`urn:schemas-upnp-org:service:${name}:`));
+}
+async function upnpAction(http, service, action, soapArguments, signal) {
+  const body = `<?xml version="1.0" encoding="utf-8"?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:${action} xmlns:u="${service.serviceType}">` + Object.entries(soapArguments).map(([name, value]) => `<${name}>${escapeXmlText(value)}</${name}>`).join("") + `</u:${action}></s:Body></s:Envelope>`;
+  const response = await http.send({
+    url: service.controlUrl,
+    method: "POST",
+    headers: { "Content-Type": 'text/xml; charset="utf-8"', SOAPACTION: `"${service.serviceType}#${action}"` },
+    body,
+    ...signal ? { signal } : {}
+  });
+  const text6 = await response.text();
+  if (response.status >= 400) throw new UpnpActionError(action, xmlTagText(text6, "errorCode"), response.status);
+  return text6;
+}
+function resolveUpnpUrl(value, base) {
+  if (!value) return void 0;
+  try {
+    const url = new URL(value, base);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/online/dlna.ts
+var DLNA_MEDIA_SERVER_SEARCH_TARGET = "urn:schemas-upnp-org:device:MediaServer:1";
+var DESCRIPTION_PATHS = ["/rootDesc.xml", "/description.xml", "/DeviceDescription.xml"];
+var LEADING_TRACK_NUMBER2 = /^(\d{1,3})(?:[\s._-]+|\s*-\s*)(.+)$/;
+var PAGE_SIZE2 = 200;
+var MAX_ENTRIES = 5e3;
+function createDlnaConnector() {
+  return {
+    kind: "dlna",
+    connect: (input, http) => connectDlna(input, http),
+    browse: (account, options, http) => browseDlna(account, options, http)
+  };
+}
+async function connectDlna(input, http) {
+  const address = normalizeMediaSourceAddress(input.address);
+  const candidates = new URL(address).pathname === "/" ? DESCRIPTION_PATHS.map((path) => `${address}${path}`) : [address];
+  for (const descriptionUrl of candidates) {
+    const response = await http.send({ url: descriptionUrl });
+    if (response.status >= 400) continue;
+    const description = parseUpnpDeviceDescription(await response.text(), descriptionUrl);
+    if (!description.contentDirectory) throw new Error("This device is not a media server");
+    contentDirectories.set(descriptionUrl, Promise.resolve(description.contentDirectory));
+    return {
+      id: `dlna-${shortHash(description.udn ?? descriptionUrl)}`,
+      kind: "dlna",
+      name: input.name?.trim() || description.friendlyName,
+      baseUrl: descriptionUrl
+    };
+  }
+  throw new Error("No media server description at this address");
+}
+async function browseDlna(account, options, http) {
+  const service = await contentDirectory(account, http, options.signal);
+  const kind = options.kind ?? "audio";
+  const limit = Math.min(options.limit ?? MAX_ENTRIES, MAX_ENTRIES);
+  const objects = [];
+  let start = options.startIndex ?? 0;
+  let total;
+  try {
+    while (objects.length < limit) {
+      const count = Math.min(PAGE_SIZE2, limit - objects.length);
+      const soapArguments = options.search ? {
+        ContainerID: "0",
+        SearchCriteria: `upnp:class derivedfrom "object.item.${kind}Item" and dc:title contains "${options.search.replace(/["\\]/g, "\\$&")}"`,
+        Filter: "*",
+        StartingIndex: String(start),
+        RequestedCount: String(count),
+        SortCriteria: ""
+      } : {
+        ObjectID: options.containerId ?? "0",
+        BrowseFlag: "BrowseDirectChildren",
+        Filter: "*",
+        StartingIndex: String(start),
+        RequestedCount: String(count),
+        SortCriteria: ""
+      };
+      const answer = await soap(http, service, options.search ? "Search" : "Browse", soapArguments, options.signal, Boolean(options.search));
+      if (!answer) return { containers: [], items: [] };
+      const page = parseDidlLite(answer.result, service.controlUrl);
+      objects.push(...page);
+      total = answer.totalMatches;
+      start += answer.numberReturned || page.length;
+      if (!page.length || total !== void 0 && start >= total) break;
+    }
+  } catch (error) {
+    contentDirectories.delete(account.baseUrl);
+    throw error;
+  }
+  const containers = options.search ? [] : objects.filter((object) => object.container && showsContainer(object, kind)).map(containerFrom);
+  const items = objects.filter((object) => !object.container).flatMap((object) => itemFrom(account, object, kind) ?? []);
+  return { containers, items, total: items.length };
+}
+function parseDidlLite(xml, baseUrl) {
+  const document2 = /<(?:[\w.-]+:)?DIDL-Lite\b/i.test(xml) ? xml : "";
+  const read = (element, container) => {
+    const content = element.content ?? "";
+    const id = element.attributes["id"];
+    if (!id) return null;
+    const resources = xmlElements(content, "res").flatMap((resource) => {
+      const url = resolveUpnpUrl(xmlText(resource.content), baseUrl);
+      if (!url) return [];
+      const mimeType = resource.attributes["protocolInfo"]?.split(":")[2];
+      const durationSec = parseDuration(resource.attributes["duration"]);
+      const size = Number(resource.attributes["size"]);
+      return [{
+        url,
+        ...mimeType && mimeType !== "*" ? { mimeType: mimeType.toLowerCase() } : {},
+        ...durationSec ? { durationSec } : {},
+        ...Number.isFinite(size) && size > 0 ? { size } : {}
+      }];
+    });
+    const childCount = Number(element.attributes["childCount"]);
+    const object = {
+      id,
+      container,
+      title: xmlTagText(content, "title") ?? id,
+      upnpClass: xmlTagText(content, "class") ?? (container ? "object.container" : "object.item"),
+      artists: xmlElements(content, "artist").flatMap((artist) => {
+        const name = xmlText(artist.content);
+        return name ? [{ name, ...artist.attributes["role"] ? { role: artist.attributes["role"] } : {} }] : [];
+      }),
+      resources
+    };
+    const optional = {
+      parentId: element.attributes["parentID"],
+      childCount: Number.isFinite(childCount) && element.attributes["childCount"] !== void 0 ? childCount : void 0,
+      creator: xmlTagText(content, "creator"),
+      album: xmlTagText(content, "album"),
+      genre: xmlTagText(content, "genre"),
+      date: xmlTagText(content, "date"),
+      trackNo: positive(xmlTagText(content, "originalTrackNumber")),
+      artworkUrl: resolveUpnpUrl(xmlTagText(content, "albumArtURI"), baseUrl),
+      seriesTitle: xmlTagText(content, "seriesTitle"),
+      season: positive(xmlTagText(content, "episodeSeason")),
+      episode: positive(xmlTagText(content, "episodeNumber"))
+    };
+    for (const [key, value] of Object.entries(optional)) {
+      if (value !== void 0) object[key] = value;
+    }
+    return object;
+  };
+  return [
+    ...xmlElements(document2, "container").flatMap((element) => read(element, true) ?? []),
+    ...xmlElements(document2, "item").flatMap((element) => read(element, false) ?? [])
+  ];
+}
+var contentDirectories = /* @__PURE__ */ new Map();
+function contentDirectory(account, http, signal) {
+  let pending = contentDirectories.get(account.baseUrl);
+  if (!pending) {
+    pending = (async () => {
+      const response = await http.send({ url: account.baseUrl, ...signal ? { signal } : {} });
+      if (response.status >= 400) throw new Error("The media server is not reachable at its last address");
+      const service = parseUpnpDeviceDescription(await response.text(), account.baseUrl).contentDirectory;
+      if (!service) throw new Error("This device is not a media server");
+      return service;
+    })();
+    contentDirectories.set(account.baseUrl, pending);
+    pending.catch(() => contentDirectories.delete(account.baseUrl));
+  }
+  return pending;
+}
+async function soap(http, service, action, soapArguments, signal, optional) {
+  let text6;
+  try {
+    text6 = await upnpAction(http, service, action, soapArguments, signal);
+  } catch (error) {
+    if (!(error instanceof UpnpActionError)) throw error;
+    if (optional && (error.code === "401" || error.code === "708" || error.code === "710")) return null;
+    if (error.code === "701" || error.code === "710") throw new Error("This folder is no longer on the media server");
+    throw new Error(`Media server request failed (${error.code ? `UPnP error ${error.code}` : `HTTP ${error.status}`})`);
+  }
+  const totalMatches = Number(xmlTagText(text6, "TotalMatches"));
+  return {
+    result: xmlText(xmlTagContent(text6, "Result")) ?? "",
+    numberReturned: Number(xmlTagText(text6, "NumberReturned")) || 0,
+    ...Number.isFinite(totalMatches) && xmlTagText(text6, "TotalMatches") !== void 0 ? { totalMatches } : {}
+  };
+}
+function showsContainer(object, kind) {
+  const upnpClass = object.upnpClass.toLowerCase();
+  if (upnpClass.startsWith("object.container.album.photoalbum")) return false;
+  if (kind === "video") return !/^object\.container\.(album\.musicalbum|person\.musicartist|genre\.musicgenre)/.test(upnpClass);
+  return !/^object\.container\.(genre\.moviegenre|storagefolder\.video)/.test(upnpClass);
+}
+function containerFrom(object) {
+  const upnpClass = object.upnpClass.toLowerCase();
+  const kind = /music|audio/.test(upnpClass) ? "audio" : /video|movie/.test(upnpClass) ? "video" : "mixed";
+  const artist = object.artists.find((entry) => !entry.role)?.name ?? object.creator;
+  return {
+    id: object.id,
+    title: object.title,
+    kind,
+    ...artist && upnpClass.startsWith("object.container.album") ? { subtitle: artist } : {},
+    ...object.artworkUrl ? { artworkUrl: object.artworkUrl } : {},
+    ...object.childCount !== void 0 ? { childCount: object.childCount } : {}
+  };
+}
+function itemFrom(account, object, kind) {
+  const upnpClass = object.upnpClass.toLowerCase();
+  const classKind = upnpClass.startsWith("object.item.audioitem") ? "audio" : upnpClass.startsWith("object.item.videoitem") ? "video" : void 0;
+  if (classKind && classKind !== kind) return null;
+  const resource = object.resources.find((entry) => entry.mimeType?.startsWith(`${kind}/`)) ?? (classKind ? object.resources.find((entry) => !entry.mimeType?.startsWith("image/")) : void 0);
+  if (!resource) return null;
+  const item = {
+    id: mediaSourceItemId(account.id, object.id),
+    kind,
+    title: object.title,
+    url: resource.url
+  };
+  if (resource.durationSec) item.durationSec = resource.durationSec;
+  if (object.artworkUrl) item.artworkUrl = object.artworkUrl;
+  if (object.genre) item.genre = object.genre;
+  const year = object.date && !object.date.includes("T") ? positive(object.date.slice(0, 4)) : void 0;
+  if (year) item.year = year;
+  if (kind === "audio") {
+    const albumArtist = object.artists.find((entry) => /^albumartist$/i.test(entry.role ?? ""))?.name;
+    const artist = object.artists.find((entry) => !entry.role || /^performer$/i.test(entry.role))?.name ?? object.creator ?? albumArtist;
+    if (artist) item.artist = artist;
+    if (albumArtist) item.albumArtist = albumArtist;
+    if (object.album) item.album = object.album;
+    if (object.trackNo) item.trackNo = object.trackNo;
+    const numbered = LEADING_TRACK_NUMBER2.exec(object.title);
+    if (numbered && !object.trackNo && !object.album && !artist) {
+      item.trackNo = Number(numbered[1]);
+      item.title = cleanMediaTitle(numbered[2]) || object.title;
+    }
+    return item;
+  }
+  if (object.seriesTitle || object.season && object.episode) {
+    if (object.seriesTitle) item.series = object.seriesTitle;
+    if (object.season) item.season = object.season;
+    if (object.episode) item.episode = object.episode;
+    return item;
+  }
+  const parsed = parseEpisodeFileName(object.title);
+  if (parsed?.season !== void 0 && parsed.episode !== void 0) {
+    if (parsed.series) item.series = parsed.series;
+    item.season = parsed.season;
+    item.episode = parsed.episode;
+    item.title = parsed.episodeTitle ?? parsed.series ?? object.title;
+  } else if (!/\s/.test(object.title) && /[._]/.test(object.title)) {
+    item.title = cleanMediaTitle(object.title) || object.title;
+  }
+  return item;
+}
+function parseDuration(value) {
+  const match = /^(\d+):(\d{1,2}):(\d{1,2})(?:\.(\d+)(?:\/(\d+))?)?$/.exec(value?.trim() ?? "");
+  if (!match) return void 0;
+  const fraction = match[4] ? match[5] ? Number(match[4]) / Number(match[5]) : Number(`0.${match[4]}`) : 0;
+  const seconds = Number(match[1]) * 3600 + Number(match[2]) * 60 + Number(match[3]) + fraction;
+  return seconds > 0 ? Math.round(seconds) : void 0;
+}
+function positive(value) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : void 0;
+}
+function shortHash(value) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) hash = Math.imul(31, hash) + value.charCodeAt(index) | 0;
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/online/dlna-renderer.ts
+var DLNA_MEDIA_RENDERER_SEARCH_TARGET = "urn:schemas-upnp-org:device:MediaRenderer:1";
+async function readDlnaRenderer(descriptionUrl, http) {
+  const response = await http.send({ url: descriptionUrl });
+  if (response.status >= 400) throw new Error("The renderer is not reachable");
+  const description = parseUpnpDeviceDescription(await response.text(), descriptionUrl);
+  const avTransport = findUpnpService(description.services, "AVTransport");
+  if (!avTransport) throw new Error("This device cannot play media sent to it");
+  const renderingControl = findUpnpService(description.services, "RenderingControl");
+  return {
+    name: description.friendlyName,
+    ...description.udn ? { udn: description.udn } : {},
+    ...description.modelName ? { modelName: description.modelName } : {},
+    avTransport,
+    ...renderingControl ? { renderingControl } : {}
+  };
+}
+async function createDlnaRendererSession(descriptionUrl, http) {
+  const renderer = await readDlnaRenderer(descriptionUrl, http);
+  const transport = (action, soapArguments = {}) => upnpAction(http, renderer.avTransport, action, { InstanceID: "0", ...soapArguments });
+  return {
+    kind: "dlna",
+    async load(media) {
+      const soapArguments = { CurrentURI: media.url, CurrentURIMetaData: didlMetadata(media) };
+      try {
+        await transport("SetAVTransportURI", soapArguments);
+      } catch (error) {
+        if (!(error instanceof UpnpActionError)) throw error;
+        await transport("Stop").catch(() => void 0);
+        await transport("SetAVTransportURI", soapArguments).catch((retryError) => {
+          if (retryError instanceof UpnpActionError && retryError.code === "714") {
+            throw new RemotePlaybackError("load-failed", "The renderer does not read this format");
+          }
+          throw retryError;
+        });
+      }
+      await transport("Play", { Speed: "1" });
+      if (media.startSec && media.startSec > 1 && !media.live) {
+        for (let attempt = 0; attempt < 20; attempt++) {
+          const state = xmlTagText(await transport("GetTransportInfo").catch(() => ""), "CurrentTransportState");
+          if (state === "PAUSED_PLAYBACK") break;
+          if (state === "PLAYING" && (parseRemoteClock(xmlTagText(await transport("GetPositionInfo").catch(() => ""), "RelTime")) ?? 0) > 0) break;
+          await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        await transport("Seek", { Unit: "REL_TIME", Target: formatRemoteClock(media.startSec) }).catch(() => void 0);
+      }
+    },
+    play: async () => void await transport("Play", { Speed: "1" }),
+    pause: async () => void await transport("Pause"),
+    seek: async (positionSec) => void await transport("Seek", { Unit: "REL_TIME", Target: formatRemoteClock(positionSec) }),
+    stop: async () => void await transport("Stop"),
+    async setVolume(level) {
+      if (!renderer.renderingControl) return;
+      const volume = String(Math.round(Math.min(Math.max(level, 0), 1) * 100));
+      await upnpAction(http, renderer.renderingControl, "SetVolume", { InstanceID: "0", Channel: "Master", DesiredVolume: volume });
+    },
+    async status() {
+      const [transportInfo, positionInfo, volumeInfo] = await Promise.all([
+        transport("GetTransportInfo"),
+        transport("GetPositionInfo").catch(() => ""),
+        renderer.renderingControl ? upnpAction(http, renderer.renderingControl, "GetVolume", { InstanceID: "0", Channel: "Master" }).catch(() => "") : Promise.resolve("")
+      ]);
+      const positionSec = parseRemoteClock(xmlTagText(positionInfo, "RelTime"));
+      const durationSec = parseRemoteClock(xmlTagText(positionInfo, "TrackDuration"));
+      const volume = Number(xmlTagText(volumeInfo, "CurrentVolume"));
+      const transportStatus = xmlTagText(transportInfo, "CurrentTransportStatus");
+      return {
+        state: playerState(xmlTagText(transportInfo, "CurrentTransportState")),
+        ...positionSec !== void 0 ? { positionSec } : {},
+        ...durationSec ? { durationSec } : {},
+        ...volumeInfo && Number.isFinite(volume) ? { volume: Math.min(Math.max(volume / 100, 0), 1) } : {},
+        ...transportStatus && transportStatus !== "OK" ? { error: transportStatus } : {}
+      };
+    },
+    // UPnP control is stateless: there is no connection to leave.
+    close: async () => void 0
+  };
+}
+function playerState(value) {
+  switch (value) {
+    case "PLAYING":
+      return "playing";
+    case "PAUSED_PLAYBACK":
+    case "PAUSED_RECORDING":
+      return "paused";
+    case "TRANSITIONING":
+      return "buffering";
+    case "STOPPED":
+      return "stopped";
+    default:
+      return "idle";
+  }
+}
+function didlMetadata(media) {
+  const upnpClass = media.kind === "video" ? "object.item.videoItem" : "object.item.audioItem.musicTrack";
+  const duration = media.durationSec && !media.live ? ` duration="${formatRemoteClock(media.durationSec)}.000"` : "";
+  return `<DIDL-Lite xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/"><item id="0" parentID="-1" restricted="1"><dc:title>${escapeXmlText(media.title)}</dc:title>` + (media.artist ? `<upnp:artist>${escapeXmlText(media.artist)}</upnp:artist>` : "") + (media.album ? `<upnp:album>${escapeXmlText(media.album)}</upnp:album>` : "") + (media.artworkUrl ? `<upnp:albumArtURI>${escapeXmlText(media.artworkUrl)}</upnp:albumArtURI>` : "") + `<upnp:class>${upnpClass}</upnp:class><res protocolInfo="http-get:*:${escapeXmlText(media.contentType)}:*"${duration}>${escapeXmlText(media.url)}</res></item></DIDL-Lite>`;
+}
+
+// src/online/mdns.ts
+var MDNS_ADDRESS = "224.0.0.251";
+var MDNS_PORT = 5353;
+function encodeMdnsQuery(serviceType, id = 1 + Math.floor(Math.random() * 65534)) {
+  const bytes = [id >> 8, id & 255, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0];
+  for (const label of serviceType.replace(/\.$/, "").split(".")) {
+    const encoded = new TextEncoder().encode(label);
+    if (!encoded.length || encoded.length > 63) throw new Error("Invalid service type");
+    bytes.push(encoded.length, ...encoded);
+  }
+  bytes.push(0, 0, 12, 0, 1);
+  return new Uint8Array(bytes);
+}
+function parseMdnsQuestions(bytes) {
+  try {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.getUint16(2) & 32768) return [];
+    const questions = [];
+    let offset = 12;
+    for (let index = 0; index < Math.min(view.getUint16(4), 32); index++) {
+      const { name, next } = readName(bytes, offset);
+      questions.push({ name, type: view.getUint16(next) });
+      offset = next + 4;
+    }
+    return questions;
+  } catch {
+    return [];
+  }
+}
+function encodeMdnsResponse(records, options = {}) {
+  const bytes = [];
+  const u16 = (value) => bytes.push(value >> 8 & 255, value & 255);
+  const u32 = (value) => bytes.push(value >>> 24 & 255, value >> 16 & 255, value >> 8 & 255, value & 255);
+  const name = (value, into = bytes) => {
+    for (const label of value.replace(/\.$/, "").split(".")) {
+      const encoded = new TextEncoder().encode(label);
+      if (!encoded.length || encoded.length > 63) throw new Error("Invalid DNS name");
+      into.push(encoded.length, ...encoded);
+    }
+    into.push(0);
+  };
+  u16(options.id ?? 0);
+  u16(33792);
+  u16(options.question ? 1 : 0);
+  u16(records.length);
+  u16(0);
+  u16(0);
+  if (options.question) {
+    name(options.question.name);
+    u16(options.question.type);
+    u16(1);
+  }
+  for (const record of records) {
+    const data = [];
+    if (record.type === "PTR") name(record.target, data);
+    if (record.type === "SRV") {
+      data.push(0, 0, 0, 0, record.port >> 8 & 255, record.port & 255);
+      name(record.target, data);
+    }
+    if (record.type === "TXT") {
+      for (const [key, value] of Object.entries(record.entries)) {
+        const entry = new TextEncoder().encode(`${key}=${value}`).subarray(0, 255);
+        data.push(entry.length, ...entry);
+      }
+      if (!data.length) data.push(0);
+    }
+    if (record.type === "A") data.push(...record.address.split(".").map((part) => Number(part) & 255));
+    name(record.name);
+    u16({ PTR: 12, SRV: 33, TXT: 16, A: 1 }[record.type]);
+    u16(1);
+    u32(options.ttl ?? (record.type === "SRV" || record.type === "A" ? 120 : 4500));
+    u16(data.length);
+    bytes.push(...data);
+  }
+  return new Uint8Array(bytes);
+}
+function parseMdnsMessage(bytes) {
+  try {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const questions = view.getUint16(4);
+    const records = view.getUint16(6) + view.getUint16(8) + view.getUint16(10);
+    let offset = 12;
+    for (let index = 0; index < questions; index++) {
+      offset = readName(bytes, offset).next + 4;
+    }
+    const result = [];
+    for (let index = 0; index < records; index++) {
+      const { name, next } = readName(bytes, offset);
+      const type = view.getUint16(next);
+      const length = view.getUint16(next + 8);
+      const data = next + 10;
+      if (data + length > bytes.length) break;
+      if (type === 12) {
+        result.push({ type: "PTR", name, target: readName(bytes, data).name });
+      } else if (type === 33) {
+        result.push({ type: "SRV", name, port: view.getUint16(data + 4), target: readName(bytes, data + 6).name });
+      } else if (type === 16) {
+        result.push({ type: "TXT", name, entries: readTxt(bytes.subarray(data, data + length)) });
+      } else if (type === 1 && length === 4) {
+        result.push({ type: "A", name, address: [...bytes.subarray(data, data + 4)].join(".") });
+      }
+      offset = data + length;
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+function mdnsServices(serviceType, answers) {
+  const type = normalize(serviceType);
+  const services = /* @__PURE__ */ new Map();
+  const addresses = /* @__PURE__ */ new Map();
+  const pending = answers.map((answer) => ({ records: parseMdnsMessage(answer.bytes), ...answer.from ? { from: answer.from } : {} }));
+  for (const { records } of pending) {
+    for (const record of records) {
+      if (record.type === "A") addresses.set(normalize(record.name), record.address);
+      if (record.type === "PTR" && normalize(record.name) === type && !services.has(normalize(record.target))) {
+        services.set(normalize(record.target), { instance: record.target.replace(/\.$/, ""), txt: {} });
+      }
+    }
+  }
+  for (const { records, from } of pending) {
+    for (const record of records) {
+      const service = services.get(normalize(record.name));
+      if (!service) continue;
+      if (record.type === "SRV") {
+        service.host = record.target.replace(/\.$/, "");
+        service.port = record.port;
+        if (!service.address && from) service.address = from;
+      }
+      if (record.type === "TXT") service.txt = { ...service.txt, ...record.entries };
+    }
+  }
+  for (const service of services.values()) {
+    const address = service.host ? addresses.get(normalize(service.host)) : void 0;
+    if (address) service.address = address;
+  }
+  return [...services.values()];
+}
+function readName(bytes, start) {
+  const labels = [];
+  let offset = start;
+  let next = -1;
+  for (let jumps = 0; jumps < 32; jumps++) {
+    const length = bytes[offset];
+    if (length === void 0) throw new Error("Truncated name");
+    if (length === 0) {
+      return { name: labels.join("."), next: next >= 0 ? next : offset + 1 };
+    }
+    if ((length & 192) === 192) {
+      if (next < 0) next = offset + 2;
+      offset = (length & 63) << 8 | bytes[offset + 1];
+      continue;
+    }
+    labels.push(new TextDecoder().decode(bytes.subarray(offset + 1, offset + 1 + length)));
+    offset += 1 + length;
+  }
+  throw new Error("Name compression loop");
+}
+function readTxt(bytes) {
+  const entries = {};
+  let offset = 0;
+  while (offset < bytes.length) {
+    const length = bytes[offset];
+    const entry = new TextDecoder().decode(bytes.subarray(offset + 1, offset + 1 + length));
+    offset += 1 + length;
+    const separator = entry.indexOf("=");
+    if (separator > 0) entries[entry.slice(0, separator).toLowerCase()] = entry.slice(separator + 1);
+    else if (entry) entries[entry.toLowerCase()] = "";
+  }
+  return entries;
+}
+function normalize(name) {
+  return name.replace(/\.$/, "").toLowerCase();
+}
+
+// src/online/cast-v2.ts
+var CAST_MDNS_SERVICE = "_googlecast._tcp";
+var CAST_PORT = 8009;
+var CAST_DEFAULT_MEDIA_RECEIVER = "CC1AD845";
+var NS_CONNECTION = "urn:x-cast:com.google.cast.tp.connection";
+var NS_HEARTBEAT = "urn:x-cast:com.google.cast.tp.heartbeat";
+var NS_RECEIVER = "urn:x-cast:com.google.cast.receiver";
+var NS_MEDIA = "urn:x-cast:com.google.cast.media";
+var RECEIVER_ID = "receiver-0";
+var FAILURES = /* @__PURE__ */ new Set(["LOAD_FAILED", "LOAD_CANCELLED", "INVALID_REQUEST", "INVALID_PLAYER_STATE", "LAUNCH_ERROR"]);
+var CAST_UNSUPPORTED_TYPES = /* @__PURE__ */ new Map([
+  ["video/x-msvideo", "AVI"],
+  ["video/avi", "AVI"],
+  ["video/x-ms-wmv", "WMV"],
+  ["video/x-ms-asf", "ASF"],
+  ["audio/x-ms-wma", "WMA"],
+  ["video/x-flv", "FLV"]
+]);
+var CAST_TYPE_ALIASES = /* @__PURE__ */ new Map([
+  ["video/x-matroska", "video/mp4"],
+  ["video/quicktime", "video/mp4"]
+]);
+function castContentType(contentType) {
+  const type = contentType.split(";")[0].trim().toLowerCase();
+  const unsupported = CAST_UNSUPPORTED_TYPES.get(type);
+  if (unsupported) return { unsupported };
+  return { contentType: CAST_TYPE_ALIASES.get(type) ?? contentType };
+}
+function castDevicesFromMdns(answers) {
+  const devices = /* @__PURE__ */ new Map();
+  for (const service of mdnsServices(`${CAST_MDNS_SERVICE}.local`, answers)) {
+    if (!service.address) continue;
+    const id = service.txt["id"] || service.instance;
+    const capabilities = Number(service.txt["ca"]);
+    devices.set(id, {
+      id,
+      name: service.txt["fn"] || service.instance.split("._")[0],
+      ...service.txt["md"] ? { model: service.txt["md"] } : {},
+      address: service.address,
+      port: service.port ?? CAST_PORT,
+      // Capability bit 0 is video output; unknown capabilities are treated as a screen.
+      video: Number.isFinite(capabilities) ? (capabilities & 1) === 1 : true
+    });
+  }
+  return [...devices.values()];
+}
+function encodeCastMessage(message) {
+  const body = [];
+  const text6 = new TextEncoder();
+  const varint = (value) => {
+    let rest = value >>> 0;
+    while (rest > 127) {
+      body.push(rest & 127 | 128);
+      rest >>>= 7;
+    }
+    body.push(rest);
+  };
+  const string = (field, value) => {
+    const bytes = text6.encode(value);
+    varint(field << 3 | 2);
+    varint(bytes.length);
+    body.push(...bytes);
+  };
+  varint(1 << 3);
+  varint(0);
+  string(2, message.sourceId);
+  string(3, message.destinationId);
+  string(4, message.namespace);
+  varint(5 << 3);
+  varint(0);
+  string(6, message.payload);
+  const frame = new Uint8Array(4 + body.length);
+  new DataView(frame.buffer).setUint32(0, body.length);
+  frame.set(body, 4);
+  return frame;
+}
+function decodeCastFrames(buffer) {
+  const messages = [];
+  let offset = 0;
+  while (buffer.length - offset >= 4) {
+    const length = new DataView(buffer.buffer, buffer.byteOffset + offset, 4).getUint32(0);
+    if (buffer.length - offset - 4 < length) break;
+    const message = decodeCastMessage(buffer.subarray(offset + 4, offset + 4 + length));
+    if (message) messages.push(message);
+    offset += 4 + length;
+  }
+  return { messages, rest: buffer.slice(offset) };
+}
+function decodeCastMessage(bytes) {
+  const text6 = new TextDecoder();
+  const message = {};
+  let offset = 0;
+  const varint = () => {
+    let value = 0;
+    let shift = 0;
+    while (offset < bytes.length) {
+      const byte = bytes[offset++];
+      value += (byte & 127) * 2 ** shift;
+      if (byte < 128) return value;
+      shift += 7;
+    }
+    throw new Error("Truncated varint");
+  };
+  try {
+    while (offset < bytes.length) {
+      const key = varint();
+      const field = Math.floor(key / 8);
+      const wireType = key & 7;
+      if (wireType === 0) {
+        varint();
+      } else if (wireType === 2) {
+        const length = varint();
+        const value = bytes.subarray(offset, offset + length);
+        offset += length;
+        if (field === 2) message.sourceId = text6.decode(value);
+        else if (field === 3) message.destinationId = text6.decode(value);
+        else if (field === 4) message.namespace = text6.decode(value);
+        else if (field === 6) message.payload = text6.decode(value);
+      } else if (wireType === 5) {
+        offset += 4;
+      } else if (wireType === 1) {
+        offset += 8;
+      } else {
+        return null;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return message.namespace && message.payload !== void 0 ? { sourceId: message.sourceId ?? "", destinationId: message.destinationId ?? "", namespace: message.namespace, payload: message.payload } : null;
+}
+function createCastSession(socket, options = {}) {
+  const appId = options.appId ?? CAST_DEFAULT_MEDIA_RECEIVER;
+  const senderId = options.senderId ?? `sender-${Math.random().toString(36).slice(2, 10)}`;
+  const requestTimeoutMs = options.requestTimeoutMs ?? 1e4;
+  const loadTimeoutMs = options.loadTimeoutMs ?? Math.max(requestTimeoutMs, 3e4);
+  const pending = /* @__PURE__ */ new Map();
+  let buffer = new Uint8Array(0);
+  let nextRequestId = 1;
+  let closed = null;
+  let transportId = null;
+  let appSessionId = null;
+  let mediaSessionId = null;
+  let lastMedia = null;
+  let loaded = null;
+  let volume;
+  const connected = /* @__PURE__ */ new Set();
+  let heartbeat;
+  const send = (destinationId, namespace, payload) => {
+    if (closed) throw new Error(closed);
+    return socket.send(encodeCastMessage({ sourceId: senderId, destinationId, namespace, payload: JSON.stringify(payload) }));
+  };
+  const connect = async (destinationId) => {
+    if (connected.has(destinationId)) return;
+    await send(destinationId, NS_CONNECTION, { type: "CONNECT", origin: {} });
+    connected.add(destinationId);
+  };
+  const request2 = async (destinationId, namespace, payload, timeoutMs = requestTimeoutMs) => {
+    const requestId = nextRequestId++;
+    const answer = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(requestId);
+        reject(new RemotePlaybackError("timeout", "The Cast device did not answer"));
+      }, timeoutMs);
+      pending.set(requestId, { resolve, reject, timer });
+    });
+    try {
+      await send(destinationId, namespace, { ...payload, requestId });
+    } catch (error) {
+      clearTimeout(pending.get(requestId)?.timer);
+      pending.delete(requestId);
+      throw error;
+    }
+    return answer;
+  };
+  const shutdown = (reason) => {
+    if (closed) return;
+    closed = reason;
+    if (heartbeat) clearInterval(heartbeat);
+    for (const [requestId, entry] of pending) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error(reason));
+      pending.delete(requestId);
+    }
+  };
+  const remember = (payload) => {
+    if (payload.type === "RECEIVER_STATUS") {
+      const status = payload["status"];
+      if (typeof status?.volume?.level === "number") volume = status.volume.level;
+      const application = status?.applications?.find((entry) => entry.appId === appId);
+      if (!application) {
+        transportId = null;
+        appSessionId = null;
+        mediaSessionId = null;
+      } else if (application.transportId) {
+        transportId = application.transportId;
+        appSessionId = application.sessionId ?? null;
+      }
+    }
+    if (payload.type === "MEDIA_STATUS") {
+      const statuses = payload["status"] ?? [];
+      const current = statuses.find((entry) => entry.mediaSessionId === mediaSessionId) ?? statuses[0];
+      if (current?.mediaSessionId !== void 0) mediaSessionId = current.mediaSessionId;
+      lastMedia = current ?? (lastMedia ? { ...lastMedia, playerState: "IDLE", idleReason: lastMedia.idleReason ?? "FINISHED" } : null);
+      if (loaded && typeof current?.currentTime === "number") loaded = { ...loaded, positionSec: current.currentTime };
+    }
+  };
+  const unsubscribeData = socket.onData((chunk) => {
+    const joined = new Uint8Array(buffer.length + chunk.length);
+    joined.set(buffer);
+    joined.set(chunk, buffer.length);
+    const { messages, rest } = decodeCastFrames(joined);
+    buffer = rest;
+    for (const message of messages) {
+      let payload;
+      try {
+        payload = JSON.parse(message.payload);
+      } catch {
+        continue;
+      }
+      if (message.namespace === NS_HEARTBEAT && payload.type === "PING") {
+        void Promise.resolve(send(message.sourceId, NS_HEARTBEAT, { type: "PONG" })).catch(() => void 0);
+        continue;
+      }
+      if (message.namespace === NS_CONNECTION && payload.type === "CLOSE") {
+        connected.delete(message.sourceId);
+        if (message.sourceId === transportId) {
+          transportId = null;
+          mediaSessionId = null;
+        }
+        continue;
+      }
+      remember(payload);
+      const entry = payload.requestId ? pending.get(payload.requestId) : void 0;
+      if (!entry) continue;
+      pending.delete(payload.requestId);
+      clearTimeout(entry.timer);
+      if (payload.type && FAILURES.has(payload.type)) {
+        entry.reject(payload.type === "LOAD_FAILED" ? new RemotePlaybackError("load-failed", "The Cast device could not play this media") : new Error(`The Cast device refused the request (${payload.type})`));
+      } else {
+        entry.resolve(payload);
+      }
+    }
+  });
+  const unsubscribeClose = socket.onClose((reason) => shutdown(reason ?? "The Cast device closed the connection"));
+  const heartbeatMs = options.heartbeatMs ?? 5e3;
+  if (heartbeatMs > 0) {
+    heartbeat = setInterval(() => {
+      if (!closed) void Promise.resolve(send(RECEIVER_ID, NS_HEARTBEAT, { type: "PING" })).catch(() => void 0);
+    }, heartbeatMs);
+  }
+  const ready = connect(RECEIVER_ID);
+  const launch = async () => {
+    await ready;
+    if (!transportId) remember(await request2(RECEIVER_ID, NS_RECEIVER, { type: "GET_STATUS" }));
+    for (let attempt = 0; !transportId && attempt < 5; attempt++) {
+      remember(attempt === 0 ? await request2(RECEIVER_ID, NS_RECEIVER, { type: "LAUNCH", appId }) : await request2(RECEIVER_ID, NS_RECEIVER, { type: "GET_STATUS" }));
+      if (!transportId) await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    if (!transportId) throw new Error("The Cast device did not start its media player");
+    await connect(transportId);
+    return transportId;
+  };
+  const sendMedia = async (media, positionSec) => {
+    const type = castContentType(media.contentType);
+    if ("unsupported" in type) {
+      throw new RemotePlaybackError("unsupported-format", `Cast devices do not read ${type.unsupported} files`, type.unsupported);
+    }
+    const destination = await launch();
+    const answer = await request2(destination, NS_MEDIA, {
+      type: "LOAD",
+      ...appSessionId ? { sessionId: appSessionId } : {},
+      autoplay: true,
+      currentTime: media.live ? 0 : Math.max(0, positionSec),
+      media: {
+        contentId: media.url,
+        contentUrl: media.url,
+        contentType: type.contentType,
+        streamType: media.live ? "LIVE" : "BUFFERED",
+        ...media.durationSec && !media.live ? { duration: media.durationSec } : {},
+        metadata: {
+          // 3: MusicTrackMediaMetadata, 0: GenericMediaMetadata.
+          metadataType: media.kind === "audio" ? 3 : 0,
+          title: media.title,
+          ...media.artist ? { artist: media.artist, subtitle: media.artist } : {},
+          ...media.album ? { albumName: media.album } : {},
+          ...media.artworkUrl ? { images: [{ url: media.artworkUrl }] } : {}
+        }
+      }
+    }, loadTimeoutMs);
+    loaded = { media, positionSec: media.live ? 0 : Math.max(0, positionSec) };
+    remember(answer);
+  };
+  const mediaCommand = async (type, extra = {}) => {
+    if ((!transportId || mediaSessionId === null) && loaded && type !== "STOP") {
+      await sendMedia(loaded.media, loaded.positionSec);
+      if (type === "PLAY") return;
+    }
+    if (!transportId || mediaSessionId === null) throw new Error("Nothing is playing on the Cast device");
+    remember(await request2(transportId, NS_MEDIA, { type, mediaSessionId, ...extra }));
+  };
+  return {
+    kind: "chromecast",
+    load: (media) => sendMedia(media, media.live ? 0 : media.startSec ?? 0),
+    play: () => mediaCommand("PLAY"),
+    pause: () => mediaCommand("PAUSE"),
+    seek: (positionSec) => mediaCommand("SEEK", { currentTime: Math.max(0, positionSec) }),
+    async setVolume(level) {
+      await ready;
+      remember(await request2(RECEIVER_ID, NS_RECEIVER, { type: "SET_VOLUME", volume: { level: Math.min(Math.max(level, 0), 1) } }));
+    },
+    async stop() {
+      if (transportId && mediaSessionId !== null) await mediaCommand("STOP").catch(() => void 0);
+      if (appSessionId) remember(await request2(RECEIVER_ID, NS_RECEIVER, { type: "STOP", sessionId: appSessionId }).catch(() => ({})));
+      mediaSessionId = null;
+      lastMedia = null;
+      loaded = null;
+    },
+    async status() {
+      if (transportId && mediaSessionId !== null) {
+        remember(await request2(transportId, NS_MEDIA, { type: "GET_STATUS", mediaSessionId }));
+      } else {
+        await ready;
+        remember(await request2(RECEIVER_ID, NS_RECEIVER, { type: "GET_STATUS" }));
+      }
+      return castStatus(lastMedia, volume);
+    },
+    async close() {
+      for (const destination of [...connected].reverse()) {
+        await Promise.resolve(send(destination, NS_CONNECTION, { type: "CLOSE" })).catch(() => void 0);
+      }
+      shutdown("The Cast session is closed");
+      unsubscribeData();
+      unsubscribeClose();
+      socket.close();
+    }
+  };
+}
+function castStatus(media, volume) {
+  const base = volume !== void 0 ? { volume } : {};
+  if (!media) return { state: "idle", ...base };
+  const states = { PLAYING: "playing", PAUSED: "paused", BUFFERING: "buffering", LOADING: "loading" };
+  const state = states[media.playerState ?? ""] ?? (media.idleReason ? "stopped" : "idle");
+  return {
+    state,
+    ...base,
+    ...typeof media.currentTime === "number" ? { positionSec: media.currentTime } : {},
+    ...media.media?.duration ? { durationSec: media.media.duration } : {},
+    ...media.idleReason === "ERROR" ? { error: "The Cast device could not play this media" } : {},
+    ...media.idleReason === "FINISHED" ? { ended: true } : {}
+  };
+}
+
+// src/online/playback-transfer.ts
+var NGXSP_SERVICE_TYPE = "_ngxsp._tcp.local";
+var PLAYBACK_TRANSFER_PATH = "/ngxsp/transfer";
+var PLAYBACK_TRANSFER_VERSION = 1;
+var PLAYBACK_TRANSFER_PROMPT_MS = 6e4;
+var MAX_ITEMS = 200;
+var MAX_TEXT = 300;
+function ngxspTxt(identity) {
+  return { v: String(PLAYBACK_TRANSFER_VERSION), id: identity.id, app: identity.app, name: identity.name.slice(0, 120) };
+}
+function ngxspServiceRecords(identity, port, addresses) {
+  const label = `${identity.name.replace(/[.\s]+/g, " ").trim().slice(0, 40) || "NGXSP"} (NGXSP ${identity.app === "audio" ? "Audio" : "Video"})`;
+  const instance = `${label}.${NGXSP_SERVICE_TYPE}`;
+  const host = `ngxsp-${identity.id.replace(/[^a-z0-9]/gi, "").slice(0, 12).toLowerCase() || "app"}.local`;
+  return [
+    { type: "PTR", name: NGXSP_SERVICE_TYPE, target: instance },
+    { type: "SRV", name: instance, target: host, port },
+    { type: "TXT", name: instance, entries: ngxspTxt(identity) },
+    ...addresses.map((address) => ({ type: "A", name: host, address }))
+  ];
+}
+function ngxspPeersFromMdns(answers, self) {
+  const peers = /* @__PURE__ */ new Map();
+  for (const service of mdnsServices(NGXSP_SERVICE_TYPE, answers)) {
+    const { id, app, name } = service.txt;
+    if (!id || id === self.id || app !== self.app || !service.address || !service.port) continue;
+    peers.set(id, { id, app, name: name || service.instance.split(".")[0], address: service.address, port: service.port });
+  }
+  return [...peers.values()];
+}
+function readPlaybackTransfer(value) {
+  if (!value || typeof value !== "object") return null;
+  const input = value;
+  const from = input["from"];
+  const app = from?.["app"];
+  if (input["version"] !== PLAYBACK_TRANSFER_VERSION || !from || typeof from["id"] !== "string" || !from["id"] || app !== "audio" && app !== "video") return null;
+  const items = Array.isArray(input["items"]) ? input["items"].slice(0, MAX_ITEMS).flatMap((item) => {
+    const entry = readItem(item);
+    return entry ? [entry] : [];
+  }) : [];
+  if (!items.length) return null;
+  const index = Number(input["index"]);
+  const positionSec = Number(input["positionSec"]);
+  return {
+    version: PLAYBACK_TRANSFER_VERSION,
+    from: { id: text2(from["id"]).slice(0, 64), name: text2(from["name"]) || text2(from["id"]).slice(0, 8), app },
+    items,
+    index: Number.isInteger(index) && index >= 0 && index < items.length ? index : 0,
+    positionSec: Number.isFinite(positionSec) && positionSec > 0 ? positionSec : 0,
+    playing: input["playing"] !== false
+  };
+}
+function readItem(value) {
+  if (!value || typeof value !== "object") return null;
+  const input = value;
+  const url = text2(input["url"], 4e3);
+  if (!/^https?:\/\//i.test(url)) return null;
+  const artworkUrl = text2(input["artworkUrl"], 4e3);
+  const durationSec = Number(input["durationSec"]);
+  return {
+    url,
+    title: text2(input["title"]) || url.split(/[?#]/)[0].split("/").pop() || url,
+    ...text2(input["artist"]) ? { artist: text2(input["artist"]) } : {},
+    ...text2(input["album"]) ? { album: text2(input["album"]) } : {},
+    .../^https?:\/\//i.test(artworkUrl) ? { artworkUrl } : {},
+    ...Number.isFinite(durationSec) && durationSec > 0 ? { durationSec } : {},
+    ...input["live"] === true ? { live: true } : {}
+  };
+}
+function text2(value, max = MAX_TEXT) {
+  return typeof value === "string" ? value.replace(/[\u0000-\u001f]/g, " ").trim().slice(0, max) : "";
+}
+function createPlaybackTransferReceiver(options) {
+  let asking = false;
+  async function isTrusted(from, authorization) {
+    const token = /^NGXSP\s+(\S{16,200})$/.exec(authorization?.trim() ?? "")?.[1];
+    const sender = options.trusted().find((entry) => entry.id === from.id);
+    return !!token && !!sender && await options.sha256Hex(token) === sender.tokenHash;
+  }
+  async function handle(request2) {
+    if (request2.method.toUpperCase() !== "POST") return { status: 405, body: { accepted: false, reason: "invalid" } };
+    if (!options.enabled()) return { status: 403, body: { accepted: false, reason: "disabled" } };
+    let transfer = null;
+    try {
+      transfer = readPlaybackTransfer(JSON.parse(request2.body));
+    } catch {
+      transfer = null;
+    }
+    if (!transfer) return { status: 400, body: { accepted: false, reason: "invalid" } };
+    if (transfer.from.app !== options.app) return { status: 422, body: { accepted: false, reason: "other-app" } };
+    if (await isTrusted(transfer.from, request2.authorization)) {
+      const from = transfer.from;
+      options.saveTrusted(options.trusted().map((entry) => entry.id === from.id ? { ...entry, name: from.name } : entry));
+      options.apply(transfer);
+      return { status: 200, body: { accepted: true } };
+    }
+    if (asking) return { status: 409, body: { accepted: false, reason: "busy" } };
+    asking = true;
+    let allowed;
+    try {
+      allowed = await Promise.race([
+        options.ask(transfer.from),
+        new Promise((resolve) => setTimeout(() => resolve("timeout"), options.promptMs ?? PLAYBACK_TRANSFER_PROMPT_MS))
+      ]);
+    } finally {
+      asking = false;
+    }
+    if (allowed === "timeout") return { status: 408, body: { accepted: false, reason: "timeout" } };
+    if (!allowed) return { status: 403, body: { accepted: false, reason: "refused" } };
+    const token = options.randomToken();
+    const sender = { id: transfer.from.id, name: transfer.from.name, tokenHash: await options.sha256Hex(token), since: Date.now() };
+    options.saveTrusted([...options.trusted().filter((entry) => entry.id !== sender.id), sender]);
+    options.apply(transfer);
+    return { status: 200, body: { accepted: true, token } };
+  }
+  return { handle };
+}
+async function sendPlaybackTransfer(http, peer, transfer, token) {
+  let response;
+  try {
+    response = await http.send({
+      url: `http://${peer.address}:${peer.port}${PLAYBACK_TRANSFER_PATH}`,
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...token ? { Authorization: `NGXSP ${token}` } : {} },
+      body: JSON.stringify(transfer),
+      // The other device may be waiting for its user.
+      timeoutMs: PLAYBACK_TRANSFER_PROMPT_MS + 15e3
+    });
+  } catch {
+    return { accepted: false, reason: "unreachable" };
+  }
+  let body = {};
+  try {
+    body = JSON.parse(await response.text());
+  } catch {
+    body = {};
+  }
+  if (response.status === 200 && body["accepted"] === true) {
+    return { accepted: true, ...typeof body["token"] === "string" ? { token: body["token"] } : {} };
+  }
+  const reasons = ["refused", "busy", "timeout", "disabled", "other-app", "invalid"];
+  const reason = reasons.find((entry) => entry === body["reason"]);
+  return { accepted: false, reason: reason ?? "unreachable" };
+}
+
+// src/online/md5.ts
+function md5Hex(input) {
+  const bytes = new TextEncoder().encode(input);
+  const bitLength = bytes.length * 8;
+  const paddedLength = ((bytes.length + 8 >>> 6) + 1) * 64;
+  const buffer = new Uint8Array(paddedLength);
+  buffer.set(bytes);
+  buffer[bytes.length] = 128;
+  const view = new DataView(buffer.buffer);
+  view.setUint32(paddedLength - 8, bitLength >>> 0, true);
+  view.setUint32(paddedLength - 4, Math.floor(bitLength / 4294967296), true);
+  let a0 = 1732584193;
+  let b0 = 4023233417;
+  let c0 = 2562383102;
+  let d0 = 271733878;
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    let a = a0;
+    let b = b0;
+    let c = c0;
+    let d = d0;
+    for (let index = 0; index < 64; index += 1) {
+      let f;
+      let g;
+      if (index < 16) {
+        f = b & c | ~b & d;
+        g = index;
+      } else if (index < 32) {
+        f = d & b | ~d & c;
+        g = (5 * index + 1) % 16;
+      } else if (index < 48) {
+        f = b ^ c ^ d;
+        g = (3 * index + 5) % 16;
+      } else {
+        f = c ^ (b | ~d);
+        g = 7 * index % 16;
+      }
+      const rotated = a + f + K[index] + view.getUint32(offset + g * 4, true) | 0;
+      a = d;
+      d = c;
+      c = b;
+      b = b + (rotated << S[index] | rotated >>> 32 - S[index]) | 0;
+    }
+    a0 = a0 + a | 0;
+    b0 = b0 + b | 0;
+    c0 = c0 + c | 0;
+    d0 = d0 + d | 0;
+  }
+  const digest = new Uint8Array(16);
+  const out = new DataView(digest.buffer);
+  [a0, b0, c0, d0].forEach((word, index) => out.setUint32(index * 4, word >>> 0, true));
+  return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+var S = [
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  7,
+  12,
+  17,
+  22,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  5,
+  9,
+  14,
+  20,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  4,
+  11,
+  16,
+  23,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21,
+  6,
+  10,
+  15,
+  21
+];
+var K = Array.from({ length: 64 }, (_, index) => Math.floor(Math.abs(Math.sin(index + 1)) * 4294967296) | 0);
+
+// src/online/subsonic.ts
+var SUBSONIC_API_VERSION = "1.16.1";
+var SUBSONIC_CLIENT = "NGXSP";
+var ALBUM_PREFIX = "album:";
+var PAGE_SIZE3 = 500;
+function createSubsonicConnector(salt = randomSalt) {
+  return {
+    kind: "subsonic",
+    connect: (input, http) => connectSubsonic(input, http, salt),
+    browse: (account, options, http) => browseSubsonic(account, options, http)
+  };
+}
+async function connectSubsonic(input, http, salt = randomSalt) {
+  const baseUrl = normalizeMediaSourceAddress(input.address);
+  const username = input.username?.trim() ?? "";
+  if (!username) throw new Error("A Subsonic server needs a user name");
+  const signatureSalt = salt();
+  const account = {
+    id: `subsonic-${md5Hex(`${baseUrl}|${username}`).slice(0, 8)}`,
+    kind: "subsonic",
+    name: input.name?.trim() || new URL(baseUrl).host,
+    baseUrl,
+    username,
+    secret: `${signatureSalt}:${md5Hex(`${input.password ?? ""}${signatureSalt}`)}`
+  };
+  const response = await call(http, account, "ping", {});
+  const serverType = text3(response["type"]);
+  return serverType && !input.name?.trim() ? { ...account, name: `${capitalize(serverType)} - ${new URL(baseUrl).host}` } : account;
+}
+async function browseSubsonic(account, options, http) {
+  if (options.kind === "video") return { containers: [], items: [] };
+  if (options.search) {
+    const response2 = await call(http, account, "search3", { query: options.search, songCount: "100", albumCount: "0", artistCount: "0" }, options.signal);
+    const songs = asArray(response2["searchResult3"]?.["song"]);
+    return { containers: [], items: songs.flatMap((song) => itemOrEmpty(account, song)) };
+  }
+  if (options.containerId?.startsWith(ALBUM_PREFIX)) {
+    const response2 = await call(http, account, "getAlbum", { id: options.containerId.slice(ALBUM_PREFIX.length) }, options.signal);
+    const songs = asArray(response2["album"]?.["song"]);
+    return { containers: [], items: songs.flatMap((song) => itemOrEmpty(account, song)), total: songs.length };
+  }
+  const response = await call(http, account, "getAlbumList2", {
+    type: "alphabeticalByArtist",
+    size: String(Math.min(PAGE_SIZE3, Math.max(1, options.limit ?? PAGE_SIZE3))),
+    offset: String(Math.max(0, options.startIndex ?? 0))
+  }, options.signal);
+  const albums = asArray(response["albumList2"]?.["album"]);
+  return {
+    containers: albums.flatMap((album) => {
+      const record = album ?? {};
+      const id = text3(record["id"]);
+      const title = text3(record["name"]) ?? text3(record["album"]);
+      if (!id || !title) return [];
+      const coverArt = text3(record["coverArt"]);
+      const songCount = positiveInteger3(record["songCount"]);
+      return [{
+        id: `${ALBUM_PREFIX}${id}`,
+        title,
+        kind: "audio",
+        ...text3(record["artist"]) ? { subtitle: text3(record["artist"]) } : {},
+        ...coverArt ? { artworkUrl: subsonicCoverUrl(account, coverArt) } : {},
+        ...songCount ? { childCount: songCount } : {}
+      }];
+    }),
+    items: []
+  };
+}
+function subsonicStreamUrl(account, songId) {
+  return subsonicUrl(account, "stream", { id: songId }, false);
+}
+function subsonicCoverUrl(account, coverArtId, size = 480) {
+  return subsonicUrl(account, "getCoverArt", { id: coverArtId, size: String(size) }, false);
+}
+function parseSubsonicSong(account, entry) {
+  const record = entry ?? {};
+  const id = text3(record["id"]);
+  const title = text3(record["title"]);
+  if (!id || !title || record["isVideo"] === true) return null;
+  const coverArt = text3(record["coverArt"]);
+  const item = {
+    id: mediaSourceItemId(account.id, id),
+    kind: "audio",
+    title,
+    url: subsonicStreamUrl(account, id)
+  };
+  const artist = text3(record["artist"]);
+  if (artist) item.artist = artist;
+  const album = text3(record["album"]);
+  if (album) item.album = album;
+  const genre = text3(record["genre"]);
+  if (genre) item.genre = genre;
+  const year = positiveInteger3(record["year"]);
+  if (year) item.year = year;
+  const trackNo = positiveInteger3(record["track"]);
+  if (trackNo) item.trackNo = trackNo;
+  const discNo = positiveInteger3(record["discNumber"]);
+  if (discNo) item.discNo = discNo;
+  const duration = positiveInteger3(record["duration"]);
+  if (duration) item.durationSec = duration;
+  if (coverArt) item.artworkUrl = subsonicCoverUrl(account, coverArt);
+  const suffix = text3(record["suffix"]);
+  if (suffix) item.container = suffix;
+  return item;
+}
+function itemOrEmpty(account, song) {
+  const item = parseSubsonicSong(account, song);
+  return item ? [item] : [];
+}
+function subsonicUrl(account, method, parameters, json) {
+  const [salt = "", token = ""] = (account.secret ?? "").split(":");
+  const query = new URLSearchParams({
+    ...parameters,
+    u: account.username ?? "",
+    t: token,
+    s: salt,
+    v: SUBSONIC_API_VERSION,
+    c: SUBSONIC_CLIENT,
+    ...json ? { f: "json" } : {}
+  });
+  return `${account.baseUrl}/rest/${method}.view?${query}`;
+}
+async function call(http, account, method, parameters, signal) {
+  const response = await http.send({ url: subsonicUrl(account, method, parameters, true), ...signal ? { signal } : {} });
+  if (response.status === 404) throw new Error("No Subsonic API at this address");
+  if (response.status >= 400) throw new Error(`Subsonic request failed (HTTP ${response.status})`);
+  const body = await response.json();
+  const payload = body?.["subsonic-response"];
+  if (!payload) throw new Error("No Subsonic API at this address");
+  if (payload["status"] !== "ok") {
+    const error = payload["error"] ?? {};
+    const code = Number(error["code"]);
+    if (code === 40) throw new Error("The server refused this user name or password");
+    if (code === 41) throw new Error("This server does not accept signed requests");
+    throw new Error(text3(error["message"]) ?? "Subsonic request failed");
+  }
+  return payload;
+}
+function randomSalt() {
+  const bytes = new Uint8Array(8);
+  globalThis.crypto.getRandomValues(bytes);
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function asArray(value) {
+  if (Array.isArray(value)) return value;
+  return value === void 0 || value === null ? [] : [value];
+}
+function text3(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function positiveInteger3(value) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : void 0;
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+// src/online/webdav.ts
+var PROPFIND_BODY = '<?xml version="1.0" encoding="utf-8"?><d:propfind xmlns:d="DAV:"><d:prop><d:displayname/><d:resourcetype/><d:getcontentlength/><d:getcontenttype/><d:getlastmodified/></d:prop></d:propfind>';
+function createWebDavConnector() {
+  return {
+    kind: "webdav",
+    connect: (input, http) => connectWebDav(input, http),
+    browse: (account, options, http) => browseWebDav(account, options, http),
+    lyrics: (account, item, http) => readWebDavLyrics(account, item, http)
+  };
+}
+async function connectWebDav(input, http) {
+  const baseUrl = normalizeMediaSourceAddress(input.address);
+  const username = input.username?.trim();
+  const account = {
+    id: `webdav-${shortHash2(`${baseUrl}|${username ?? ""}`)}`,
+    kind: "webdav",
+    name: input.name?.trim() || decodeURIComponent(new URL(baseUrl).pathname.split("/").filter(Boolean).pop() ?? "") || new URL(baseUrl).host,
+    baseUrl,
+    ...username ? { username, secret: basicCredentials(username, input.password ?? "") } : {}
+  };
+  const entries = await propfind(http, account, `${baseUrl}/`, "0");
+  if (!entries[0]?.collection) throw new Error("This address is a file, not a WebDAV folder");
+  return account;
+}
+async function browseWebDav(account, options, http) {
+  const kind = options.kind ?? "audio";
+  const basePath = new URL(account.baseUrl).pathname.replace(/\/+$/, "");
+  const folderPath = options.containerId ?? basePath;
+  if (!isInside(basePath, folderPath)) throw new Error("This folder is outside the WebDAV share");
+  const folderUrl = `${new URL(account.baseUrl).origin}${encodePath(folderPath)}/`;
+  const entries = await propfind(http, account, folderUrl, "1", options.signal);
+  const current = trimSlash(folderPath) || "/";
+  const children = entries.filter((entry) => (trimSlash(entry.path) || "/") !== current && isInside(basePath, entry.path));
+  const containers = children.filter((entry) => entry.collection && !isIgnoredDirectoryName(entry.name)).sort((left, right) => left.name.localeCompare(right.name, void 0, { numeric: true, sensitivity: "base" })).map((entry) => ({ id: trimSlash(entry.path), title: entry.name, kind: "mixed" }));
+  const items = children.filter((entry) => !entry.collection && isMediaFileName(entry.name, kind)).sort((left, right) => left.name.localeCompare(right.name, void 0, { numeric: true, sensitivity: "base" })).map((entry) => webDavItem(account, entry, basePath, kind));
+  return { containers, items, total: items.length };
+}
+function parseWebDavMultistatus(xml) {
+  const responses = [...xml.matchAll(/<(?:[\w.-]+:)?response\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?response>/gi)];
+  return responses.flatMap((match) => {
+    const block = match[1];
+    const href = xmlTagText(block, "href");
+    if (!href) return [];
+    const okProps = [...block.matchAll(/<(?:[\w.-]+:)?propstat\b[^>]*>([\s\S]*?)<\/(?:[\w.-]+:)?propstat>/gi)].map((propstat) => propstat[1]).filter((propstat) => !/<(?:[\w.-]+:)?status\b[^>]*>[^<]*\b(?:4\d\d|5\d\d)\b/i.test(propstat)).join("");
+    const props = okProps || block;
+    let path;
+    try {
+      path = decodeURIComponent(new URL(decodeXmlEntities(href), "http://webdav.invalid").pathname);
+    } catch {
+      return [];
+    }
+    const collection = /<(?:[\w.-]+:)?collection\b/i.test(xmlTagContent(props, "resourcetype") ?? "");
+    const name = xmlTagText(props, "displayname") || path.replace(/\/+$/, "").split("/").pop() || "";
+    const size = Number(xmlTagText(props, "getcontentlength"));
+    const modified = Date.parse(xmlTagText(props, "getlastmodified") ?? "");
+    const contentType = xmlTagText(props, "getcontenttype");
+    return [{
+      path,
+      name,
+      collection,
+      ...Number.isFinite(size) && size > 0 ? { size } : {},
+      ...contentType ? { contentType } : {},
+      ...Number.isFinite(modified) ? { lastModified: modified } : {}
+    }];
+  });
+}
+function webDavAuthorization(account) {
+  return account.secret?.startsWith("basic:") ? `Basic ${account.secret.slice(6)}` : void 0;
+}
+var MAX_LYRICS_BYTES = 256 * 1024;
+async function readWebDavLyrics(account, item, http) {
+  const extension = item.url.lastIndexOf(".");
+  if (extension < 0) return null;
+  const authorization = webDavAuthorization(account);
+  const response = await http.send({
+    url: `${item.url.slice(0, extension)}.lrc`,
+    headers: authorization ? { Authorization: authorization } : {}
+  });
+  if (response.status >= 400) return null;
+  const text6 = await response.text();
+  return text6.trim() && text6.length <= MAX_LYRICS_BYTES ? text6 : null;
+}
+function webDavItem(account, entry, basePath, kind) {
+  const relativePath = trimSlash(entry.path).slice(basePath.length).replace(/^\/+/, "");
+  const item = {
+    id: mediaSourceItemId(account.id, trimSlash(entry.path)),
+    kind,
+    title: entry.name,
+    url: `${new URL(account.baseUrl).origin}${encodePath(entry.path)}`
+  };
+  if (kind === "audio") {
+    const fields = audioFieldsFromTags({ relativePath });
+    item.title = fields.title;
+    if (fields.artist) item.artist = fields.artist;
+    if (fields.albumArtist) item.albumArtist = fields.albumArtist;
+    if (fields.album) item.album = fields.album;
+    if (fields.trackNo) item.trackNo = fields.trackNo;
+  } else {
+    const fields = videoFieldsFromTags({ relativePath });
+    item.title = fields.title;
+    if (fields.series) item.series = fields.series;
+    if (fields.season) item.season = fields.season;
+    if (fields.episode) item.episode = fields.episode;
+    if (fields.year) item.year = fields.year;
+  }
+  return item;
+}
+async function propfind(http, account, url, depth, signal) {
+  const authorization = webDavAuthorization(account);
+  const response = await http.send({
+    url,
+    method: "PROPFIND",
+    headers: {
+      Depth: depth,
+      "Content-Type": "application/xml; charset=utf-8",
+      ...authorization ? { Authorization: authorization } : {}
+    },
+    body: PROPFIND_BODY,
+    ...signal ? { signal } : {}
+  });
+  if (response.status === 401 || response.status === 403) throw new Error("The WebDAV server refused this user name or password");
+  if (response.status === 404) throw new Error("No WebDAV folder at this address");
+  if (response.status === 405 || response.status === 501) throw new Error("This address does not speak WebDAV");
+  if (response.status !== 207 && response.status >= 300) throw new Error(`WebDAV request failed (HTTP ${response.status})`);
+  return parseWebDavMultistatus(await response.text());
+}
+function encodePath(path) {
+  return path.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function trimSlash(path) {
+  return path.length > 1 ? path.replace(/\/+$/, "") : path;
+}
+function isInside(basePath, path) {
+  const base = trimSlash(basePath) || "/";
+  const target = trimSlash(path);
+  if (target.split("/").includes("..")) return false;
+  return base === "/" || target === base || target.startsWith(`${base}/`);
+}
+function basicCredentials(username, password) {
+  const bytes = new TextEncoder().encode(`${username}:${password}`);
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return `basic:${btoa(binary)}`;
+}
+function shortHash2(value) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) hash = Math.imul(31, hash) + value.charCodeAt(index) | 0;
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/online/internet-archive.ts
+var INTERNET_ARCHIVE_ORIGIN = "https://archive.org";
+var INTERNET_ARCHIVE_PLAYABLE_FILTERS = [
+  "-collection:(stream_only)",
+  "-access-restricted-item:(true)"
+];
+var SEARCH_FIELDS = ["identifier", "title", "creator", "year", "licenseurl"];
+var VIDEO_FORMATS = ["h.264", "MPEG4", "h.264 HD", "512Kb MPEG4", "h.264 IA", "WebM", "Ogg Video"];
+var AUDIO_FORMATS = ["VBR MP3", "MP3", "128Kbps MP3", "64Kbps MP3", "Ogg Vorbis"];
+var LUCENE_SPECIAL = /[+\-&|!(){}[\]^"~*?:\\/]/g;
+function buildInternetArchiveSearchUrl(options) {
+  const clauses = [`mediatype:(${options.mediaType})`, ...options.filters ?? []];
+  const terms = (options.text ?? "").replace(LUCENE_SPECIAL, " ").trim().split(/\s+/).filter(Boolean);
+  if (terms.length) {
+    const words = terms.join(" AND ");
+    clauses.push(`(title:(${words}) OR creator:(${words}) OR subject:(${words}))`);
+  }
+  const params = new URLSearchParams({ q: clauses.join(" AND ") });
+  for (const field of SEARCH_FIELDS) params.append("fl[]", field);
+  params.append("sort[]", options.sort ?? "downloads desc");
+  params.set("rows", String(clampInteger(options.rows, 1, 100, 20)));
+  params.set("page", String(clampInteger(options.page, 1, 1e4, 1)));
+  params.set("output", "json");
+  return `${originOf(options.origin)}/advancedsearch.php?${params}`;
+}
+async function searchInternetArchive(options, request2 = {}) {
+  const origin = request2.origin ?? options.origin;
+  const body = await getJson(buildInternetArchiveSearchUrl({ ...options, origin }), request2);
+  const response = body?.response;
+  const docs = Array.isArray(response?.docs) ? response.docs : [];
+  const items = docs.flatMap((doc) => {
+    const record = doc;
+    const identifier = firstText(record["identifier"]);
+    if (!identifier) return [];
+    return [{
+      identifier,
+      title: firstText(record["title"]) ?? identifier,
+      creator: firstText(record["creator"]),
+      year: parseYear(record["year"]),
+      licenseUrl: firstText(record["licenseurl"]),
+      thumbnailUrl: internetArchiveThumbnailUrl(identifier, origin),
+      detailsUrl: internetArchiveDetailsUrl(identifier, origin)
+    }];
+  });
+  return {
+    total: typeof response?.numFound === "number" ? response.numFound : items.length,
+    page: clampInteger(options.page, 1, 1e4, 1),
+    items
+  };
+}
+async function fetchInternetArchiveItem(identifier, request2 = {}) {
+  const body = await getJson(`${originOf(request2.origin)}/metadata/${encodeURIComponent(identifier)}`, request2);
+  return parseInternetArchiveItem(identifier, body, request2.origin);
+}
+function parseInternetArchiveItem(identifier, body, origin) {
+  const record = body ?? {};
+  if (!record.metadata) throw new Error(`Internet Archive item not found: ${identifier}`);
+  const metadata = record.metadata;
+  const collections = allTexts2(metadata["collection"]);
+  const files = (Array.isArray(record.files) ? record.files : []).flatMap((file) => {
+    const entry = file;
+    const name = firstText(entry["name"]);
+    if (!name || firstText(entry["private"]) === "true") return [];
+    return [{
+      name,
+      format: firstText(entry["format"]),
+      source: firstText(entry["source"]),
+      original: firstText(entry["original"]),
+      title: firstText(entry["title"]),
+      creator: firstText(entry["creator"]) ?? firstText(entry["artist"]),
+      album: firstText(entry["album"]),
+      track: firstText(entry["track"]),
+      length: firstText(entry["length"]),
+      size: firstText(entry["size"])
+    }];
+  });
+  return {
+    identifier,
+    title: firstText(metadata["title"]) ?? identifier,
+    creator: allTexts2(metadata["creator"]).join(", ") || void 0,
+    year: parseYear(metadata["year"]) ?? parseYear(metadata["date"]),
+    description: plainDescription(firstText(metadata["description"])),
+    licenseUrl: firstText(metadata["licenseurl"]),
+    restricted: record.is_dark === true || firstText(metadata["access-restricted-item"]) === "true" || collections.includes("stream_only"),
+    thumbnailUrl: internetArchiveThumbnailUrl(identifier, origin),
+    detailsUrl: internetArchiveDetailsUrl(identifier, origin),
+    storageUrls: storageUrlsOf(record),
+    files
+  };
+}
+var STORAGE_HOST = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*\.archive\.org$/i;
+function storageUrlsOf(record) {
+  const dir = firstText(record.dir);
+  if (!dir || !dir.startsWith("/") || dir.includes("..")) return [];
+  const hosts = [...allTexts2(record.workable_servers), ...allTexts2(record.d1), ...allTexts2(record.d2), ...allTexts2(record.server)];
+  return [...new Set(hosts.filter((host) => STORAGE_HOST.test(host)))].map((host) => `https://${host}${dir}`);
+}
+function storageFileUrls(item, fileName) {
+  const path = fileName.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  return item.storageUrls.map((base) => `${base}/${path}`);
+}
+function selectInternetArchiveVideo(item, origin) {
+  if (item.restricted) return null;
+  for (const format of VIDEO_FORMATS) {
+    const file = item.files.find((candidate) => candidate.format === format);
+    if (file) {
+      return {
+        fileName: file.name,
+        format,
+        url: internetArchiveDownloadUrl(item.identifier, file.name, origin),
+        storageUrls: storageFileUrls(item, file.name),
+        durationSec: parseInternetArchiveLength(file.length)
+      };
+    }
+  }
+  return null;
+}
+function internetArchiveAudioTracks(item, origin) {
+  if (item.restricted) return [];
+  const format = AUDIO_FORMATS.find((candidate) => item.files.some((file) => file.format === candidate));
+  if (!format) return [];
+  const candidates = item.files.filter((file) => file.format === format);
+  const names = new Set(candidates.map((file) => file.name));
+  return candidates.filter((file) => !file.original || !names.has(file.original)).map((file) => ({
+    id: `${item.identifier}/${file.name}`,
+    identifier: item.identifier,
+    fileName: file.name,
+    title: readableTitle(file.title ?? fileStem2(file.name)),
+    artist: file.creator ?? item.creator,
+    album: file.album ?? item.title,
+    trackNo: parseTrackNumber(file.track),
+    durationSec: parseInternetArchiveLength(file.length),
+    url: internetArchiveDownloadUrl(item.identifier, file.name, origin),
+    storageUrls: storageFileUrls(item, file.name),
+    artworkUrl: item.thumbnailUrl
+  })).sort((left, right) => (left.trackNo ?? Number.MAX_SAFE_INTEGER) - (right.trackNo ?? Number.MAX_SAFE_INTEGER) || left.fileName.localeCompare(right.fileName, void 0, { numeric: true }));
+}
+function internetArchiveDownloadUrl(identifier, fileName, origin) {
+  const path = fileName.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+  return `${originOf(origin)}/download/${encodeURIComponent(identifier)}/${path}`;
+}
+function internetArchiveThumbnailUrl(identifier, origin) {
+  return `${originOf(origin)}/services/img/${encodeURIComponent(identifier)}`;
+}
+function internetArchiveDetailsUrl(identifier, origin) {
+  return `${originOf(origin)}/details/${encodeURIComponent(identifier)}`;
+}
+function parseInternetArchiveLength(length) {
+  if (!length) return void 0;
+  const parts = length.trim().split(":");
+  if (parts.some((part) => !/^\d+(?:\.\d+)?$/.test(part))) return void 0;
+  const seconds = parts.reduce((total, part) => total * 60 + Number(part), 0);
+  return seconds > 0 ? Math.round(seconds) : void 0;
+}
+async function getJson(url, request2) {
+  const http = request2.http ?? createFetchOnlineJsonHttp();
+  try {
+    return await http.getJson(url, { signal: request2.signal });
+  } catch (error) {
+    if (request2.signal?.aborted) throw error;
+    throw new Error(`Internet Archive request failed (${error instanceof Error ? error.message : String(error)})`);
+  }
+}
+function originOf(origin) {
+  return (origin ?? INTERNET_ARCHIVE_ORIGIN).replace(/\/+$/, "");
+}
+function firstText(value) {
+  return allTexts2(value)[0];
+}
+function allTexts2(value) {
+  const values = Array.isArray(value) ? value : [value];
+  return values.flatMap((entry) => {
+    if (typeof entry === "number") return [String(entry)];
+    return typeof entry === "string" && entry.trim() ? [entry.trim()] : [];
+  });
+}
+function parseYear(value) {
+  const match = /\b(1[89]\d{2}|20\d{2})\b/.exec(firstText(value) ?? "");
+  return match ? Number(match[1]) : void 0;
+}
+function parseTrackNumber(track) {
+  const match = /^\s*(\d+)/.exec(track ?? "");
+  return match ? Number(match[1]) : void 0;
+}
+function plainDescription(description) {
+  if (!description) return void 0;
+  const text6 = description.replace(/<br\s*\/?>/gi, " ").replace(/<[^>]*>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
+  if (!text6) return void 0;
+  return text6.length > 320 ? `${text6.slice(0, 317).trimEnd()}...` : text6;
+}
+function fileStem2(name) {
+  const base = name.split("/").pop() ?? name;
+  return base.replace(/\.[^.]+$/, "") || base;
+}
+function readableTitle(title) {
+  if (/\s/.test(title) && !title.includes("_")) return title;
+  return title.replace(/^\d{1,3}\s*[.\-_)]\s*/, "").replace(/_+/g, " ").replace(/\s+/g, " ").trim() || title;
+}
+function clampInteger(value, min, max, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+
+// src/online/radio-browser.ts
+var RADIO_BROWSER_ORIGIN = "https://de1.api.radio-browser.info";
+function buildRadioBrowserSearchUrl(options = {}) {
+  const params = new URLSearchParams();
+  if (options.countryCode?.trim()) params.set("countrycode", options.countryCode.trim().toUpperCase());
+  if (options.name?.trim()) params.set("name", options.name.trim());
+  if (options.tag?.trim()) params.set("tag", options.tag.trim());
+  params.set("hidebroken", String(options.hideBroken ?? true));
+  params.set("limit", String(clampInteger2(options.limit, 1, 500, 20)));
+  if (options.offset) params.set("offset", String(clampInteger2(options.offset, 0, 1e5, 0)));
+  const order = options.order ?? "clickcount";
+  params.set("order", order);
+  if (order !== "name") params.set("reverse", "true");
+  return `${originOf2(options.origin)}/json/stations/search?${params}`;
+}
+async function searchRadioStations(options = {}, request2 = {}) {
+  const url = buildRadioBrowserSearchUrl({ ...options, origin: request2.origin ?? options.origin });
+  const http = request2.http ?? createFetchOnlineJsonHttp();
+  let body;
+  try {
+    body = await http.getJson(url, { signal: request2.signal });
+  } catch (error) {
+    if (request2.signal?.aborted) throw error;
+    throw new Error(`Radio Browser request failed (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return (Array.isArray(body) ? body : []).flatMap((entry) => {
+    const station = parseRadioStation(entry);
+    if (!station || seen.has(station.id)) return [];
+    seen.add(station.id);
+    return [station];
+  });
+}
+function parseRadioStation(entry) {
+  const record = entry ?? {};
+  const id = text4(record["stationuuid"]);
+  const streamUrl = httpUrl(text4(record["url_resolved"])) ?? httpUrl(text4(record["url"]));
+  if (!id || !streamUrl) return null;
+  const bitrate = Number(record["bitrate"]);
+  return {
+    id,
+    name: text4(record["name"])?.replace(/\s+/g, " ") ?? streamUrl,
+    streamUrl,
+    homepageUrl: httpUrl(text4(record["homepage"])),
+    faviconUrl: httpUrl(text4(record["favicon"])),
+    country: text4(record["country"]),
+    countryCode: text4(record["countrycode"]),
+    language: text4(record["language"]),
+    tags: (text4(record["tags"]) ?? "").split(",").map((tag) => tag.trim()).filter(Boolean),
+    codec: text4(record["codec"]),
+    bitrateKbps: Number.isFinite(bitrate) && bitrate > 0 ? bitrate : void 0,
+    hls: record["hls"] === 1 || record["hls"] === true || /\.m3u8(?:$|\?)/i.test(streamUrl),
+    secure: streamUrl.startsWith("https://")
+  };
+}
+function text4(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function httpUrl(value) {
+  return value && /^https?:\/\//i.test(value) ? value : void 0;
+}
+function originOf2(origin) {
+  return (origin ?? RADIO_BROWSER_ORIGIN).replace(/\/+$/, "");
+}
+function clampInteger2(value, min, max, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+
+// src/online/musicbrainz.ts
+var MUSICBRAINZ_ORIGIN = "https://musicbrainz.org";
+var LUCENE_SPECIAL2 = /[+\-&|!(){}[\]^"~*?:\\/]/g;
+function buildMusicBrainzRecordingSearchUrl(query, origin) {
+  const clauses = [`recording:(${luceneWords(query.title)})`];
+  if (query.artist && luceneWords(query.artist)) clauses.push(`artist:(${luceneWords(query.artist)})`);
+  if (query.durationSec && query.durationSec > 0) {
+    const tolerance = Math.max(1, query.durationToleranceSec ?? 4);
+    const from = Math.max(0, Math.round((query.durationSec - tolerance) * 1e3));
+    const to = Math.round((query.durationSec + tolerance) * 1e3);
+    clauses.push(`dur:[${from} TO ${to}]`);
+  }
+  const params = new URLSearchParams({
+    query: clauses.join(" AND "),
+    fmt: "json",
+    limit: String(Math.min(25, Math.max(1, Math.trunc(query.limit ?? 10))))
+  });
+  return `${(origin ?? MUSICBRAINZ_ORIGIN).replace(/\/+$/, "")}/ws/2/recording?${params}`;
+}
+async function searchMusicBrainzRecordings(query, request2 = {}) {
+  if (!luceneWords(query.title)) return [];
+  const http = request2.http ?? createFetchOnlineJsonHttp();
+  let body;
+  try {
+    body = await http.getJson(buildMusicBrainzRecordingSearchUrl(query, request2.origin), { signal: request2.signal });
+  } catch (error) {
+    if (request2.signal?.aborted) throw error;
+    throw new Error(`MusicBrainz request failed (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const recordings = body?.recordings;
+  return (Array.isArray(recordings) ? recordings : []).flatMap((entry) => {
+    const recording = parseMusicBrainzRecording(entry);
+    return recording ? [recording] : [];
+  });
+}
+async function lookupMusicBrainzRecording(id, request2 = {}) {
+  if (!/^[0-9a-f-]{36}$/i.test(id)) return null;
+  const http = request2.http ?? createFetchOnlineJsonHttp();
+  const params = new URLSearchParams({ inc: "releases release-groups artist-credits media", fmt: "json" });
+  try {
+    const body = await http.getJson(`${(request2.origin ?? MUSICBRAINZ_ORIGIN).replace(/\/+$/, "")}/ws/2/recording/${id}?${params}`, { signal: request2.signal });
+    return parseMusicBrainzRecording({ score: 100, ...body });
+  } catch (error) {
+    if (request2.signal?.aborted) throw error;
+    throw new Error(`MusicBrainz request failed (${error instanceof Error ? error.message : String(error)})`);
+  }
+}
+function parseMusicBrainzRecording(entry) {
+  const record = entry ?? {};
+  const id = text5(record["id"]);
+  const title = text5(record["title"]);
+  if (!id || !title) return null;
+  const length = Number(record["length"]);
+  const releases = Array.isArray(record["releases"]) ? record["releases"] : [];
+  return {
+    id,
+    score: Number(record["score"]) || 0,
+    title,
+    artist: artistCredit(record["artist-credit"]),
+    durationSec: Number.isFinite(length) && length > 0 ? Math.round(length / 1e3) : void 0,
+    releases: releases.flatMap((release) => {
+      const item = release ?? {};
+      const releaseId = text5(item["id"]);
+      const releaseTitle = text5(item["title"]);
+      if (!releaseId || !releaseTitle) return [];
+      const medium = Array.isArray(item["media"]) ? item["media"][0] : void 0;
+      const track = Array.isArray(medium?.["track"]) ? medium["track"][0] : void 0;
+      const year = /^(\d{4})/.exec(text5(item["date"]) ?? "");
+      return [{
+        id: releaseId,
+        title: releaseTitle,
+        artist: artistCredit(item["artist-credit"]),
+        status: text5(item["status"]),
+        primaryType: text5(item["release-group"]?.["primary-type"]),
+        year: year ? Number(year[1]) : void 0,
+        discNo: positiveInteger4(medium?.["position"]),
+        // Search results list the matching track; lookups only give its offset in the medium.
+        trackNo: positiveInteger4(track?.["number"]) ?? offsetTrackNumber(medium?.["track-offset"])
+      }];
+    })
+  };
+}
+function artistCredit(value) {
+  if (!Array.isArray(value)) return void 0;
+  const credit = value.map((part) => {
+    const item = part ?? {};
+    return `${text5(item["name"]) ?? ""}${typeof item["joinphrase"] === "string" ? item["joinphrase"] : ""}`;
+  }).join("").trim();
+  return credit || void 0;
+}
+function luceneWords(value) {
+  return value.replace(LUCENE_SPECIAL2, " ").replace(/\s+/g, " ").trim();
+}
+function text5(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function offsetTrackNumber(offset) {
+  const number = Number(offset);
+  return Number.isInteger(number) && number >= 0 ? number + 1 : void 0;
+}
+function positiveInteger4(value) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : void 0;
+}
+
+// src/online/lyrics.ts
+var LRCLIB_ORIGIN = "https://lrclib.net";
+function parseLrc(text6, source = "file") {
+  const raw = String(text6 ?? "").replace(/\r\n?/g, "\n");
+  if (!raw.trim()) return null;
+  const lines = [];
+  const plain = [];
+  let offsetSec = 0;
+  let title;
+  let artist;
+  for (const line of raw.split("\n")) {
+    const tag = /^\s*\[(ti|ar|al|offset)\s*:\s*([^\]]*)\]\s*$/i.exec(line);
+    if (tag) {
+      const value = tag[2].trim();
+      if (/^ti$/i.test(tag[1])) title = value || void 0;
+      if (/^ar$/i.test(tag[1])) artist = value || void 0;
+      if (/^offset$/i.test(tag[1])) offsetSec = (Number(value) || 0) / 1e3;
+      continue;
+    }
+    const stamps = [...line.matchAll(/\[(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?\]/g)];
+    const content = line.replace(/\[(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?\]/g, "").trim();
+    if (!stamps.length) {
+      if (content) plain.push(content);
+      continue;
+    }
+    for (const stamp of stamps) {
+      const fraction = stamp[3] ? Number(`0.${stamp[3]}`) : 0;
+      lines.push({ timeSec: Number(stamp[1]) * 60 + Number(stamp[2]) + fraction, text: content });
+    }
+    if (content) plain.push(content);
+  }
+  if (!lines.length && !plain.length) return null;
+  const timed = lines.map((line) => ({ ...line, timeSec: Math.max(0, line.timeSec - offsetSec) })).sort((left, right) => left.timeSec - right.timeSec);
+  return {
+    source,
+    ...timed.length ? { lines: timed } : {},
+    plain: plain.join("\n"),
+    ...title ? { title } : {},
+    ...artist ? { artist } : {}
+  };
+}
+function lyricsFromTags(tags) {
+  const entries = Array.isArray(tags) ? [...tags] : tags ? [tags] : [];
+  for (const entry of entries) {
+    const timed = (entry?.syncText ?? []).filter((line) => typeof line?.timestamp === "number");
+    if (timed.length) {
+      return {
+        source: "tags",
+        // music-metadata reports synchronised lyrics in milliseconds.
+        lines: timed.map((line) => ({ timeSec: Math.max(0, line.timestamp / 1e3), text: (line.text ?? "").trim() })),
+        plain: timed.map((line) => (line.text ?? "").trim()).filter(Boolean).join("\n")
+      };
+    }
+  }
+  for (const entry of entries) {
+    const parsed = entry?.text ? parseLrc(entry.text, "tags") : null;
+    if (parsed) return parsed;
+  }
+  return null;
+}
+function lyricsLineIndexAt(lines, positionSec) {
+  if (!lines?.length) return -1;
+  let low = 0;
+  let high = lines.length - 1;
+  let found = -1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    if (lines[middle].timeSec <= positionSec + 1e-3) {
+      found = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return found;
+}
+function buildLrclibGetUrl(query, origin = LRCLIB_ORIGIN) {
+  const parameters = new URLSearchParams({ track_name: query.title, artist_name: query.artist ?? "" });
+  if (query.album) parameters.set("album_name", query.album);
+  if (query.durationSec) parameters.set("duration", String(Math.round(query.durationSec)));
+  return `${origin}/api/get?${parameters.toString()}`;
+}
+function buildLrclibSearchUrl(query, origin = LRCLIB_ORIGIN) {
+  const parameters = new URLSearchParams({ track_name: query.title });
+  if (query.artist) parameters.set("artist_name", query.artist);
+  return `${origin}/api/search?${parameters.toString()}`;
+}
+async function fetchLrclibLyrics(query, options = {}) {
+  const http = options.http ?? createFetchOnlineJsonHttp();
+  const request2 = options.signal ? { signal: options.signal } : {};
+  const title = query.title.trim();
+  if (!title) return null;
+  const exact = await http.getJson(buildLrclibGetUrl({ ...query, title }, options.origin), request2).catch(() => null);
+  const direct = lyricsFromRecord(exact);
+  if (direct) return direct;
+  const results = await http.getJson(buildLrclibSearchUrl({ ...query, title }, options.origin), request2).catch(() => null);
+  if (!Array.isArray(results)) return null;
+  const best = bestLrclibMatch(results, { ...query, title });
+  return best ? lyricsFromRecord(best) : null;
+}
+function bestLrclibMatch(records, query) {
+  const usable = records.filter((record) => !record.instrumental && (record.syncedLyrics || record.plainLyrics));
+  if (!usable.length) return null;
+  const score = (record) => {
+    const durationGap2 = query.durationSec && record.duration ? Math.abs(record.duration - query.durationSec) : void 0;
+    return (durationGap2 !== void 0 && durationGap2 <= 5 ? 100 - durationGap2 * 4 : 0) + (record.syncedLyrics ? 40 : 0) + similarity(record.trackName, query.title) * 30 + similarity(record.artistName, query.artist) * 20;
+  };
+  return [...usable].sort((left, right) => score(right) - score(left))[0] ?? null;
+}
+function lyricsFromRecord(record) {
+  if (!record || record.instrumental) return null;
+  const parsed = record.syncedLyrics ? parseLrc(record.syncedLyrics, "lrclib") : null;
+  const plain = record.plainLyrics?.trim();
+  if (!parsed && !plain) return null;
+  return {
+    source: "lrclib",
+    ...parsed?.lines ? { lines: parsed.lines } : {},
+    plain: plain || parsed?.plain || "",
+    ...record.trackName ? { title: record.trackName } : {},
+    ...record.artistName ? { artist: record.artistName } : {},
+    ...record.id ? { id: record.id } : {}
+  };
+}
+function similarity(left, right) {
+  const clean = (value) => (value ?? "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const a = clean(left);
+  const b = clean(right);
+  if (!a || !b) return 0;
+  if (a === b) return 1;
+  const words = new Set(a.split(" "));
+  const shared = b.split(" ").filter((word) => words.has(word)).length;
+  return shared / Math.max(words.size, b.split(" ").length);
+}
+
+// src/online/acoustid.ts
+var ACOUSTID_ORIGIN = "https://api.acoustid.org";
+function buildAcoustIdLookupUrl(query, origin) {
+  const params = new URLSearchParams({
+    client: query.clientKey,
+    meta: "recordings",
+    duration: String(Math.max(1, Math.round(query.durationSec))),
+    fingerprint: query.fingerprint,
+    format: "json"
+  });
+  return `${(origin ?? ACOUSTID_ORIGIN).replace(/\/+$/, "")}/v2/lookup?${params}`;
+}
+async function lookupAcoustId(query, request2 = {}) {
+  if (!query.clientKey || !query.fingerprint || !(query.durationSec > 0)) return [];
+  const http = request2.http ?? createFetchOnlineJsonHttp();
+  let body;
+  try {
+    body = await http.getJson(buildAcoustIdLookupUrl(query, request2.origin), { signal: request2.signal });
+  } catch (error) {
+    if (request2.signal?.aborted) throw error;
+    throw new Error(`AcoustID request failed (${error instanceof Error ? error.message : String(error)})`);
+  }
+  const record = body ?? {};
+  if (record.status !== "ok") {
+    throw new Error(`AcoustID lookup refused (${typeof record.error?.message === "string" ? record.error.message : "unknown error"})`);
+  }
+  return (Array.isArray(record.results) ? record.results : []).flatMap((entry) => {
+    const result = entry ?? {};
+    const id = typeof result["id"] === "string" ? result["id"] : "";
+    if (!id) return [];
+    const recordings = Array.isArray(result["recordings"]) ? result["recordings"] : [];
+    return [{
+      id,
+      score: Number(result["score"]) || 0,
+      recordings: recordings.flatMap((recording) => {
+        const item = recording ?? {};
+        if (typeof item["id"] !== "string") return [];
+        const artists = Array.isArray(item["artists"]) ? item["artists"] : [];
+        const artist = artists.map((part) => `${part["name"] ?? ""}${typeof part["joinphrase"] === "string" ? part["joinphrase"] : ""}`).join("").trim();
+        const duration = Number(item["duration"]);
+        return [{
+          id: item["id"],
+          title: typeof item["title"] === "string" ? item["title"] : void 0,
+          artist: artist || void 0,
+          durationSec: Number.isFinite(duration) && duration > 0 ? Math.round(duration) : void 0
+        }];
+      })
+    }];
+  });
+}
+
+exports.ACOUSTID_ORIGIN = ACOUSTID_ORIGIN;
+exports.AUDIO_IDENTIFICATION_RETRY_MS = AUDIO_IDENTIFICATION_RETRY_MS;
+exports.AUDIO_IDENTIFICATION_VERSION = AUDIO_IDENTIFICATION_VERSION;
+exports.CAST_DEFAULT_MEDIA_RECEIVER = CAST_DEFAULT_MEDIA_RECEIVER;
+exports.CAST_MDNS_SERVICE = CAST_MDNS_SERVICE;
+exports.CAST_PORT = CAST_PORT;
 exports.ConsoleLogPort = ConsoleLogPort;
 exports.DEFAULT_ADS_CONFIG = DEFAULT_ADS_CONFIG;
 exports.DEFAULT_METADATA_CONFIG = DEFAULT_METADATA_CONFIG;
@@ -1383,28 +5414,175 @@ exports.DEFAULT_PROGRESS_CONFIG = DEFAULT_PROGRESS_CONFIG;
 exports.DEFAULT_RESILIENCE_CONFIG = DEFAULT_RESILIENCE_CONFIG;
 exports.DEFAULT_SUBTITLES_CONFIG = DEFAULT_SUBTITLES_CONFIG;
 exports.DEFAULT_UI_CONFIG = DEFAULT_UI_CONFIG;
+exports.DLNA_MEDIA_RENDERER_SEARCH_TARGET = DLNA_MEDIA_RENDERER_SEARCH_TARGET;
+exports.DLNA_MEDIA_SERVER_SEARCH_TARGET = DLNA_MEDIA_SERVER_SEARCH_TARGET;
 exports.DefaultCacheStore = DefaultCacheStore;
+exports.INTERNET_ARCHIVE_ORIGIN = INTERNET_ARCHIVE_ORIGIN;
+exports.INTERNET_ARCHIVE_PLAYABLE_FILTERS = INTERNET_ARCHIVE_PLAYABLE_FILTERS;
+exports.JELLYFIN_CLIENT = JELLYFIN_CLIENT;
+exports.LRCLIB_ORIGIN = LRCLIB_ORIGIN;
 exports.LocalMetadataProvider = LocalMetadataProvider;
 exports.LocalSubtitleProvider = LocalSubtitleProvider;
+exports.MDNS_ADDRESS = MDNS_ADDRESS;
+exports.MDNS_PORT = MDNS_PORT;
+exports.MEDIA_LIBRARY_MODEL_VERSION = MEDIA_LIBRARY_MODEL_VERSION;
+exports.MUSICBRAINZ_ORIGIN = MUSICBRAINZ_ORIGIN;
 exports.MemoryStoragePort = MemoryStoragePort;
+exports.NGXSP_SERVICE_TYPE = NGXSP_SERVICE_TYPE;
 exports.NativeEngine = NativeEngine;
 exports.NoopTelemetryPort = NoopTelemetryPort;
+exports.PLAYBACK_TRANSFER_PATH = PLAYBACK_TRANSFER_PATH;
+exports.PLAYBACK_TRANSFER_PROMPT_MS = PLAYBACK_TRANSFER_PROMPT_MS;
+exports.PLAYBACK_TRANSFER_VERSION = PLAYBACK_TRANSFER_VERSION;
 exports.PlayerFacade = PlayerFacade;
 exports.ProgressPlugin = ProgressPlugin;
+exports.RADIO_BROWSER_ORIGIN = RADIO_BROWSER_ORIGIN;
+exports.RINGTONE_FADE_SEC = RINGTONE_FADE_SEC;
+exports.RINGTONE_MAX_SEC = RINGTONE_MAX_SEC;
+exports.RemotePlaybackEngine = RemotePlaybackEngine;
+exports.RemotePlaybackError = RemotePlaybackError;
 exports.ResiliencePlugin = ResiliencePlugin;
+exports.SUBSONIC_API_VERSION = SUBSONIC_API_VERSION;
+exports.SUBSONIC_CLIENT = SUBSONIC_CLIENT;
 exports.SimpleEventBus = SimpleEventBus;
+exports.UpnpActionError = UpnpActionError;
+exports.VAULT_ROUNDS = VAULT_ROUNDS;
+exports.applyAudioIdentification = applyAudioIdentification;
 exports.applyEngineProfileToSource = applyEngineProfileToSource;
 exports.applyRemoteConfig = applyRemoteConfig;
+exports.audioFieldsFromTags = audioFieldsFromTags;
+exports.audioIdentificationDoubts = audioIdentificationDoubts;
+exports.audioTrackMatchesSearch = audioTrackMatchesSearch;
+exports.bestLrclibMatch = bestLrclibMatch;
+exports.browseDlna = browseDlna;
+exports.browseJellyfin = browseJellyfin;
+exports.browseSubsonic = browseSubsonic;
+exports.browseWebDav = browseWebDav;
+exports.buildAcoustIdLookupUrl = buildAcoustIdLookupUrl;
+exports.buildInternetArchiveSearchUrl = buildInternetArchiveSearchUrl;
+exports.buildLrclibGetUrl = buildLrclibGetUrl;
+exports.buildLrclibSearchUrl = buildLrclibSearchUrl;
+exports.buildMusicBrainzRecordingSearchUrl = buildMusicBrainzRecordingSearchUrl;
+exports.buildRadioBrowserSearchUrl = buildRadioBrowserSearchUrl;
+exports.castContentType = castContentType;
+exports.castDevicesFromMdns = castDevicesFromMdns;
+exports.cleanAudioArtistName = cleanAudioArtistName;
+exports.cleanMediaTitle = cleanMediaTitle;
+exports.connectDlna = connectDlna;
+exports.connectJellyfin = connectJellyfin;
+exports.connectSubsonic = connectSubsonic;
+exports.connectWebDav = connectWebDav;
+exports.createAudioLibrarySnapshot = createAudioLibrarySnapshot;
 exports.createCapabilityReport = createCapabilityReport;
+exports.createCastSession = createCastSession;
 exports.createDefaultCapabilities = createDefaultCapabilities;
 exports.createDefaultConfig = createDefaultConfig;
 exports.createDefaultPorts = createDefaultPorts;
+exports.createDlnaConnector = createDlnaConnector;
+exports.createDlnaRendererSession = createDlnaRendererSession;
+exports.createFetchOnlineJsonHttp = createFetchOnlineJsonHttp;
+exports.createIdentificationRoutine = createIdentificationRoutine;
+exports.createIdleDevicePlaybackState = createIdleDevicePlaybackState;
+exports.createJellyfinConnector = createJellyfinConnector;
+exports.createMediaCache = createMediaCache;
 exports.createMediaDecodingReport = createMediaDecodingReport;
 exports.createNativeEngineFactory = createNativeEngineFactory;
+exports.createPlaybackTransferReceiver = createPlaybackTransferReceiver;
+exports.createRemotePlaybackEngineFactory = createRemotePlaybackEngineFactory;
+exports.createShakeDetector = createShakeDetector;
 exports.createSsaiManifestRewritePlugin = createSsaiManifestRewritePlugin;
+exports.createSubsonicConnector = createSubsonicConnector;
+exports.createWebDavConnector = createWebDavConnector;
+exports.decodeCastFrames = decodeCastFrames;
+exports.decodeSubtitleBytes = decodeSubtitleBytes;
+exports.describeSubtitleFile = describeSubtitleFile;
 exports.detectPlaybackCapabilities = detectPlaybackCapabilities;
+exports.encodeCastMessage = encodeCastMessage;
+exports.encodeMdnsQuery = encodeMdnsQuery;
+exports.encodeMdnsResponse = encodeMdnsResponse;
+exports.encodeWav = encodeWav;
+exports.fadeEdges = fadeEdges;
+exports.fetchInternetArchiveItem = fetchInternetArchiveItem;
+exports.fetchLrclibLyrics = fetchLrclibLyrics;
+exports.fileKeyFor = fileKeyFor;
+exports.findUpnpService = findUpnpService;
+exports.folderArtworkRank = folderArtworkRank;
+exports.formatRemoteClock = formatRemoteClock;
 exports.getEngineProfileHints = getEngineProfileHints;
+exports.harmonizeAudioMetadata = harmonizeAudioMetadata;
+exports.hashPasscode = hashPasscode;
+exports.hiddenIds = hiddenIds;
+exports.internetArchiveAudioTracks = internetArchiveAudioTracks;
+exports.internetArchiveDetailsUrl = internetArchiveDetailsUrl;
+exports.internetArchiveDownloadUrl = internetArchiveDownloadUrl;
+exports.internetArchiveThumbnailUrl = internetArchiveThumbnailUrl;
 exports.isCategorizedEventType = isCategorizedEventType;
+exports.isIgnoredDirectoryName = isIgnoredDirectoryName;
+exports.isImageFileName = isImageFileName;
+exports.isMediaFileName = isMediaFileName;
+exports.isUsablePasscode = isUsablePasscode;
+exports.jellyfinClientHeader = jellyfinClientHeader;
+exports.jellyfinImageUrl = jellyfinImageUrl;
+exports.jellyfinStreamUrl = jellyfinStreamUrl;
+exports.lookupAcoustId = lookupAcoustId;
+exports.lookupMusicBrainzRecording = lookupMusicBrainzRecording;
+exports.lyricsFromTags = lyricsFromTags;
+exports.lyricsLineIndexAt = lyricsLineIndexAt;
+exports.matchFingerprintedRecording = matchFingerprintedRecording;
+exports.matchMusicBrainzRecording = matchMusicBrainzRecording;
+exports.md5Hex = md5Hex;
+exports.mdnsServices = mdnsServices;
+exports.mediaContentType = mediaContentType;
+exports.mediaFileExtension = mediaFileExtension;
+exports.mediaMetadataKey = mediaMetadataKey;
+exports.mediaSourceItemId = mediaSourceItemId;
+exports.needsAudioIdentification = needsAudioIdentification;
+exports.ngxspPeersFromMdns = ngxspPeersFromMdns;
+exports.ngxspServiceRecords = ngxspServiceRecords;
+exports.ngxspTxt = ngxspTxt;
+exports.normalizeAudioSearchText = normalizeAudioSearchText;
+exports.normalizeMediaSourceAddress = normalizeMediaSourceAddress;
+exports.parseDidlLite = parseDidlLite;
+exports.parseEpisodeFileName = parseEpisodeFileName;
+exports.parseInternetArchiveItem = parseInternetArchiveItem;
+exports.parseInternetArchiveLength = parseInternetArchiveLength;
+exports.parseJellyfinItem = parseJellyfinItem;
+exports.parseLrc = parseLrc;
+exports.parseMdnsMessage = parseMdnsMessage;
+exports.parseMdnsQuestions = parseMdnsQuestions;
+exports.parseMediaSourceItemId = parseMediaSourceItemId;
+exports.parseMusicBrainzRecording = parseMusicBrainzRecording;
+exports.parseRadioStation = parseRadioStation;
+exports.parseRemoteClock = parseRemoteClock;
+exports.parseSubsonicSong = parseSubsonicSong;
+exports.parseUpnpDeviceDescription = parseUpnpDeviceDescription;
+exports.parseWebDavMultistatus = parseWebDavMultistatus;
+exports.pickAcoustIdRecording = pickAcoustIdRecording;
+exports.planMediaCacheEviction = planMediaCacheEviction;
+exports.readDlnaRenderer = readDlnaRenderer;
+exports.readJellyfinLyrics = readJellyfinLyrics;
+exports.readPlaybackTransfer = readPlaybackTransfer;
+exports.readWebDavLyrics = readWebDavLyrics;
+exports.reduceDevicePlaybackState = reduceDevicePlaybackState;
+exports.remotePlaybackErrorCode = remotePlaybackErrorCode;
+exports.remotePlaybackFailure = remotePlaybackFailure;
+exports.ringtoneFileName = ringtoneFileName;
+exports.ringtoneSegment = ringtoneSegment;
+exports.searchAudioLibrarySnapshot = searchAudioLibrarySnapshot;
+exports.searchInternetArchive = searchInternetArchive;
+exports.searchMusicBrainzRecordings = searchMusicBrainzRecordings;
+exports.searchRadioStations = searchRadioStations;
 exports.selectEngine = selectEngine;
+exports.selectInternetArchiveVideo = selectInternetArchiveVideo;
+exports.sendPlaybackTransfer = sendPlaybackTransfer;
+exports.subsonicCoverUrl = subsonicCoverUrl;
+exports.subsonicStreamUrl = subsonicStreamUrl;
+exports.subtitleTextToVtt = subtitleTextToVtt;
+exports.ticksToSeconds = ticksToSeconds;
+exports.upnpAction = upnpAction;
+exports.verifyPasscode = verifyPasscode;
+exports.videoFieldsFromTags = videoFieldsFromTags;
+exports.webDavAuthorization = webDavAuthorization;
+exports.withoutHidden = withoutHidden;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map