retiam 2.0.2 → 2.0.3

package/dist/libs/tts/node/index.js

@@ -0,0 +1,791 @@
+import { D as U, c as z, p as C, g as O, s as I, f as V, a as D } from "../../../msEdgeV2-D3w4Xsn-.js";
+import { M as q, b as G } from "../../../msEdgeV2-D3w4Xsn-.js";
+/*! Retiam: noncommercial use only unless separately licensed. See ../../../LICENSE and ../../../COMMERCIAL_LICENSE.md. Third-party notices: ../../../THIRD_PARTY_NOTICES.md and ../../../THIRD_PARTY_LICENSES.txt. */
+function $(l, e = 24e3) {
+  const n = e * 2, r = l.length * 2, a = new ArrayBuffer(44 + r), o = new DataView(a);
+  A(o, 0, "RIFF"), o.setUint32(4, 36 + r, !0), A(o, 8, "WAVE"), A(o, 12, "fmt "), o.setUint32(16, 16, !0), o.setUint16(20, 1, !0), o.setUint16(22, 1, !0), o.setUint32(24, e, !0), o.setUint32(28, n, !0), o.setUint16(32, 2, !0), o.setUint16(34, 16, !0), A(o, 36, "data"), o.setUint32(40, r, !0);
+  let f = 44;
+  for (let d = 0; d < l.length; d++) {
+    const h = Math.max(-1, Math.min(1, l[d])), c = h < 0 ? h * 32768 : h * 32767;
+    o.setInt16(f, c, !0), f += 2;
+  }
+  return a;
+}
+function A(l, e, t) {
+  for (let i = 0; i < t.length; i++)
+    l.setUint8(e + i, t.charCodeAt(i));
+}
+class M {
+  text;
+  phonemes;
+  samples;
+  sampleRate;
+  duration;
+  durationMs;
+  voice;
+  speed;
+  wordBoundaries;
+  rawBuffer;
+  mimeType;
+  _wavBuffer = null;
+  _blob = null;
+  _objectUrl = null;
+  _dataUrl = null;
+  constructor(e) {
+    this.text = e.text, this.phonemes = e.phonemes || "", this.samples = e.samples ?? new Float32Array(0), this.sampleRate = e.sampleRate ?? 24e3, this.voice = e.voice ?? "af_heart", this.speed = e.speed ?? 1, this.wordBoundaries = e.wordBoundaries, this.rawBuffer = e.rawBuffer, this.mimeType = e.mimeType || (e.rawBuffer ? "audio/mpeg" : "audio/wav"), e.durationMs !== void 0 ? (this.durationMs = e.durationMs, this.duration = e.duration ?? e.durationMs / 1e3) : e.duration !== void 0 ? (this.duration = e.duration, this.durationMs = e.duration * 1e3) : (this.duration = this.samples.length > 0 ? this.samples.length / this.sampleRate : 0, this.durationMs = this.duration * 1e3);
+  }
+  /**
+   * Converts raw PCM samples or decodes underlying rawBuffer into a Web Audio [[AudioBuffer]].
+   */
+  async getOrDecodeAudioBuffer(e) {
+    if (this.samples && this.samples.length > 0)
+      return this.toAudioBuffer(e);
+    if (this.rawBuffer)
+      try {
+        const t = await e.decodeAudioData(this.rawBuffer.slice(0));
+        return this.samples = t.getChannelData(0), this.sampleRate = t.sampleRate, t;
+      } catch (t) {
+        console.warn("[TTSAudio] Failed to decode rawBuffer via context.decodeAudioData:", t);
+      }
+    return this.toAudioBuffer(e);
+  }
+  /**
+   * Converts raw PCM samples to a Web Audio [[AudioBuffer]].
+   */
+  toAudioBuffer(e) {
+    const t = e || (typeof window < "u" ? window.__retiam_audio_context : null);
+    if (t) {
+      const s = t.createBuffer(1, Math.max(1, this.samples.length), this.sampleRate);
+      return s.getChannelData(0).set(this.samples), s;
+    }
+    const i = typeof window < "u" ? window.AudioContext || window.webkitAudioContext : null;
+    if (i) {
+      const n = new i().createBuffer(1, Math.max(1, this.samples.length), this.sampleRate);
+      return n.getChannelData(0).set(this.samples), n;
+    }
+    throw new Error("[TTSAudio] Cannot create AudioBuffer: No AudioContext available in this environment.");
+  }
+  /**
+   * Returns an ArrayBuffer containing encoded 16-bit PCM WAV audio.
+   */
+  toWav() {
+    return this._wavBuffer || (this.rawBuffer && this.mimeType.includes("wav") ? this._wavBuffer = this.rawBuffer : this._wavBuffer = $(this.samples, this.sampleRate)), this._wavBuffer;
+  }
+  /**
+   * Returns a standard WAV or MP3 [[Blob]].
+   */
+  toBlob() {
+    return this._blob || (this.rawBuffer ? this._blob = new Blob([this.rawBuffer], { type: this.mimeType }) : this._blob = new Blob([this.toWav()], { type: "audio/wav" })), this._blob;
+  }
+  /**
+   * Generates a base64 Data URL ("data:audio/...;base64,...").
+   */
+  toDataUrl() {
+    if (!this._dataUrl) {
+      const e = this.rawBuffer ? new Uint8Array(this.rawBuffer) : new Uint8Array(this.toWav());
+      let t = "";
+      const i = e.byteLength;
+      for (let n = 0; n < i; n++)
+        t += String.fromCharCode(e[n]);
+      const s = typeof btoa < "u" ? btoa(t) : Buffer.from(t, "binary").toString("base64");
+      this._dataUrl = `data:${this.mimeType};base64,${s}`;
+    }
+    return this._dataUrl;
+  }
+  /**
+   * Creates or returns a cached Object URL ("blob:...") for this audio.
+   */
+  toObjectUrl() {
+    if (!this._objectUrl)
+      if (typeof URL < "u" && typeof URL.createObjectURL == "function")
+        this._objectUrl = URL.createObjectURL(this.toBlob());
+      else
+        return this.toDataUrl();
+    return this._objectUrl;
+  }
+  /**
+   * Revokes any generated Object URL to release memory.
+   */
+  revokeObjectUrl() {
+    this._objectUrl && typeof URL < "u" && typeof URL.revokeObjectURL == "function" && (URL.revokeObjectURL(this._objectUrl), this._objectUrl = null);
+  }
+  /**
+   * Triggers a browser download or writes out the audio file.
+   */
+  save(e) {
+    const t = this.mimeType.includes("mpeg") || this.mimeType.includes("mp3") ? ".mp3" : ".wav", i = `speech${t}`, s = e ? e.includes(".") ? e : `${e}${t}` : i;
+    if (typeof document < "u") {
+      const n = this.toObjectUrl(), r = document.createElement("a");
+      r.style.display = "none", r.href = n, r.download = s, document.body.appendChild(r), r.click(), setTimeout(() => {
+        document.body.removeChild(r);
+      }, 100);
+      return;
+    }
+    try {
+      const n = globalThis.require ? globalThis.require("fs") : null;
+      if (n) {
+        const r = this.rawBuffer ? Buffer.from(this.rawBuffer) : Buffer.from(this.toWav());
+        n.writeFileSync(s, r);
+      }
+    } catch (n) {
+      console.warn(`[TTSAudio] Unable to save file ${s}:`, n);
+    }
+  }
+  /**
+   * Plays the audio through Retiam's [[AudioManager]] on the dedicated voiceover bus
+   * with automatic BGM ducking and timeline synchronization.
+   */
+  async play(e, t = {}) {
+    let i;
+    return e && (typeof e.playVoiceover == "function" ? i = e : e.audio && typeof e.audio.playVoiceover == "function" && (i = e.audio)), i ? i.playVoiceover(this, t) : (console.warn("[TTSAudio] No active AudioManager provided to play(). Creating standalone audio playback."), this._playStandalone(t));
+  }
+  /**
+   * Standalone playback fallback if no Retiam scene/AudioManager is provided.
+   */
+  _playStandalone(e) {
+    return new Promise((t) => {
+      if (typeof Audio > "u") {
+        t(this.durationMs);
+        return;
+      }
+      const i = new Audio(this.toObjectUrl());
+      i.volume = Math.max(0, Math.min(1, e.volume ?? 1)), i.onended = () => {
+        const s = e.padEndMs ?? 100;
+        setTimeout(() => t(this.durationMs + s), s);
+      }, i.onerror = () => {
+        t(this.durationMs);
+      }, i.play().catch(() => {
+        t(this.durationMs);
+      });
+    });
+  }
+}
+class T {
+  maxSize;
+  cache = /* @__PURE__ */ new Map();
+  constructor(e = 128) {
+    this.maxSize = Math.max(1, e);
+  }
+  static createKey(e, t, i, s) {
+    return JSON.stringify([t, i, e, s]);
+  }
+  get(e, t, i, s = "") {
+    const n = T.createKey(e, t, i, s), r = this.cache.get(n);
+    if (r)
+      return this.cache.delete(n), this.cache.set(n, r), r;
+  }
+  set(e, t, i, s, n = "") {
+    const r = T.createKey(e, t, i, n);
+    if (this.cache.has(r))
+      this.cache.get(r) !== s && this.cache.get(r)?.revokeObjectUrl(), this.cache.delete(r);
+    else if (this.cache.size >= this.maxSize) {
+      const a = this.cache.keys().next().value;
+      a && (this.cache.get(a)?.revokeObjectUrl(), this.cache.delete(a));
+    }
+    this.cache.set(r, s);
+  }
+  has(e, t, i, s = "") {
+    return this.cache.has(T.createKey(e, t, i, s));
+  }
+  clear() {
+    for (const e of this.cache.values())
+      e.revokeObjectUrl();
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+}
+class j {
+  name = "msedge-tts";
+  _config;
+  _cache;
+  _isBrowser;
+  _nodeClients = [];
+  constructor(e = {}) {
+    this._isBrowser = typeof window < "u" && typeof window.document < "u", this._config = {
+      cacheAudio: e.cacheAudio !== !1,
+      maxCacheSize: e.maxCacheSize ?? 128,
+      msedgeEndpoint: e.msedgeEndpoint || "/api/tts/msedge"
+    }, this._cache = new T(this._config.maxCacheSize);
+  }
+  /**
+   * Microsoft Edge TTS is cloud-hosted and always ready immediately without local weight loading.
+   */
+  get isReady() {
+    return !0;
+  }
+  /**
+   * Initializes provider configuration. No weight downloading required.
+   */
+  async init(e) {
+    e?.msedgeEndpoint && (this._config.msedgeEndpoint = e.msedgeEndpoint), e?.cacheAudio !== void 0 && (this._config.cacheAudio = e.cacheAudio);
+  }
+  /**
+   * Synthesizes text into high-fidelity speech audio using Microsoft Edge neural voices.
+   */
+  async synthesize(e, t = {}) {
+    const i = e.trim(), s = t.voice || U, n = Math.max(0.25, Math.min(4, t.speed ?? 1)), r = JSON.stringify({ pitch: t.pitch, volume: t.volume, displayText: t.displayText });
+    if (!i)
+      return new M({
+        text: "",
+        samples: new Float32Array(0),
+        sampleRate: 24e3,
+        voice: s,
+        speed: n
+      });
+    if (this._config.cacheAudio) {
+      const o = this._cache.get(i, s, n, r);
+      if (o)
+        return o;
+    }
+    const a = this._isBrowser ? await this._synthesizeBrowser(i, s, n, t) : await this._synthesizeNode(i, s, n, t);
+    return this._config.cacheAudio && this._cache.set(i, s, n, a, r), a;
+  }
+  /**
+   * Node.js execution: directly calls the msedge-tts package in-process.
+   */
+  async _synthesizeNode(e, t, i, s) {
+    const { MsEdgeTTS: n, OUTPUT_FORMAT: r } = await import("msedge-tts");
+    z(n);
+    const a = new n(), o = Math.round((i - 1) * 100), f = o >= 0 ? `+${o}%` : `${o}%`;
+    await a.setMetadata(t, r.AUDIO_24KHZ_96KBITRATE_MONO_MP3, {
+      wordBoundaryEnabled: !0,
+      sentenceBoundaryEnabled: !0
+    });
+    const d = {
+      rate: f
+    };
+    if (s.pitch !== void 0 && (d.pitch = s.pitch), s.volume !== void 0 && s.volume !== null) {
+      if (typeof s.volume == "number")
+        d.volume = s.volume <= 1 && s.volume > 0 ? Math.round(s.volume * 100) : Math.round(s.volume);
+      else if (typeof s.volume == "string") {
+        const u = parseFloat(s.volume);
+        !isNaN(u) && !s.volume.includes("%") && !s.volume.startsWith("+") && !s.volume.startsWith("-") ? d.volume = u <= 1 && u > 0 ? Math.round(u * 100) : Math.round(u) : d.volume = s.volume;
+      }
+    }
+    const { audioStream: h, metadataStream: c } = a.toStream(e, d), y = [], w = [];
+    c && c.on("data", (u) => {
+      try {
+        const S = u.toString(), _ = JSON.parse(S);
+        if (Array.isArray(_?.Metadata)) {
+          for (const b of _.Metadata)
+            if (b.Type === "WordBoundary" && b.Data) {
+              const x = (b.Data.Offset || 0) / 1e4, E = (b.Data.Duration || 0) / 1e4, k = b.Data.text?.Text || "";
+              w.push({
+                text: k,
+                offsetMs: x,
+                durationMs: E,
+                boundaryType: "WordBoundary"
+              });
+            }
+        }
+      } catch {
+      }
+    }), await new Promise((u, S) => {
+      h.on("data", (_) => {
+        y.push(_);
+      }), h.on("end", () => {
+        u();
+      }), h.on("error", (_) => {
+        S(_);
+      });
+    });
+    const v = Buffer.concat(y), m = v.buffer.slice(
+      v.byteOffset,
+      v.byteOffset + v.byteLength
+    ), p = C(new Uint8Array(m));
+    return new M({
+      text: s.displayText ?? e,
+      rawBuffer: m,
+      mimeType: "audio/mpeg",
+      samples: new Float32Array(p.totalSamples),
+      sampleRate: p.sampleRate,
+      duration: p.durationSec,
+      durationMs: p.durationMs,
+      voice: t,
+      speed: i,
+      wordBoundaries: w.length > 0 ? w : void 0
+    });
+  }
+  /**
+   * Browser execution: invokes the Vite development server proxy endpoint.
+   */
+  async _synthesizeBrowser(e, t, i, s) {
+    const n = `${this._config.msedgeEndpoint}/synthesize`, r = await fetch(n, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        text: e,
+        voice: t,
+        speed: i,
+        pitch: s.pitch,
+        volume: s.volume
+      })
+    });
+    if (!r.ok)
+      throw new Error(`[MsEdgeTTSProvider] Synthesis failed: HTTP ${r.status} ${r.statusText}`);
+    const a = r.headers.get("X-Audio-Duration-Ms"), o = r.headers.get("X-Word-Boundaries");
+    let f;
+    if (o)
+      try {
+        f = JSON.parse(decodeURIComponent(o));
+      } catch {
+      }
+    const d = await r.arrayBuffer();
+    let h = new Float32Array(0), c = 24e3, y = a ? parseFloat(a) : 0;
+    const w = window.AudioContext || window.webkitAudioContext;
+    if (w) {
+      const v = !!window.__retiam_audio_context, m = window.__retiam_audio_context || new w();
+      try {
+        const p = await m.decodeAudioData(d.slice(0));
+        h = p.getChannelData(0), c = p.sampleRate, y || (y = p.duration * 1e3);
+      } catch (p) {
+        console.warn("[MsEdgeTTSProvider] AudioContext decode deferred, using raw MP3 buffer:", p);
+      } finally {
+        !v && m && typeof m.close == "function" && m.close().catch(() => {
+        });
+      }
+    }
+    if (h.length === 0 || !y) {
+      const v = C(new Uint8Array(d));
+      c = v.sampleRate, y || (y = v.durationMs);
+    }
+    return new M({
+      text: s.displayText ?? e,
+      rawBuffer: d,
+      mimeType: "audio/mpeg",
+      samples: h,
+      sampleRate: c,
+      duration: y / 1e3,
+      durationMs: y,
+      voice: t,
+      speed: i,
+      wordBoundaries: f
+    });
+  }
+  /**
+   * Progressively streams synthesized speech sentence by sentence.
+   */
+  async *stream(e, t = {}) {
+    const i = t.voice || U, s = Math.max(0.25, Math.min(4, t.speed ?? 1)), n = t.splitPattern || /([.!?;]+(?:\s+|$))/g, r = [], a = e.split(n);
+    for (let d = 0; d < a.length; d += 2) {
+      const h = (a[d] + (a[d + 1] || "")).trim();
+      h.length > 0 && r.push(h);
+    }
+    r.length === 0 && r.push(e.trim());
+    let o = 0, f = 0;
+    for (const d of r) {
+      const h = await this.synthesize(d, {
+        ...t,
+        voice: i,
+        speed: s
+      });
+      yield {
+        text: d,
+        phonemes: "",
+        audio: h,
+        chunkIndex: o++,
+        startTimeMs: f
+      }, f += h.durationMs;
+    }
+  }
+  /**
+   * Returns curated Microsoft Edge neural voices immediately.
+   */
+  getVoices() {
+    return O();
+  }
+  /**
+   * Fetches the complete live catalog of all 320+ Microsoft Edge neural voices.
+   */
+  async fetchVoices() {
+    if (this._isBrowser)
+      try {
+        const e = await fetch(`${this._config.msedgeEndpoint}/voices`);
+        if (e.ok) {
+          const t = await e.json();
+          if (Array.isArray(t))
+            return I(t), t;
+        }
+      } catch {
+      }
+    return V();
+  }
+  /**
+   * Clears cached utterances.
+   */
+  clearCache() {
+    this._cache.clear();
+  }
+  /**
+   * Disposes resources and releases cache.
+   */
+  async dispose() {
+    this.clearCache();
+    for (const e of this._nodeClients)
+      try {
+        e.close();
+      } catch {
+      }
+    this._nodeClients = [];
+  }
+}
+class R {
+  _provider;
+  _config;
+  constructor(e = {}, t) {
+    this._config = e, this._provider = t ?? new j(e);
+  }
+  /** The active speech provider. */
+  get provider() {
+    return this._provider;
+  }
+  /** Whether the active provider is ready. */
+  get isReady() {
+    return this._provider.isReady;
+  }
+  /** Replaces the active provider instance. */
+  setProvider(e) {
+    this._provider = e;
+  }
+  /** Initializes the active provider. */
+  async init(e) {
+    e && (this._config = e), await this._provider.init(e ?? this._config);
+  }
+  /** Synthesizes text with the active provider. */
+  async synthesize(e, t = {}) {
+    return this._provider.synthesize(e, t);
+  }
+  /** Streams synthesized audio sentence by sentence. */
+  async *stream(e, t = {}) {
+    yield* this._provider.stream(e, t);
+  }
+  /** Synthesizes and plays speech through a Scene or AudioManager. */
+  async speak(e, t, i = {}) {
+    const s = await this.synthesize(t, i), n = await s.play(e, i);
+    return { audio: s, durationMs: n };
+  }
+  /** Returns voices exposed by the active provider. */
+  getVoices() {
+    return this._provider.getVoices();
+  }
+  /** Finds a voice by ID, display name, or partial match. */
+  findVoice(e) {
+    const t = e.toLowerCase();
+    return this._provider.getVoices().find(
+      (i) => i.id.toLowerCase() === t || i.name.toLowerCase() === t || i.id.toLowerCase().includes(t) || i.name.toLowerCase().includes(t)
+    ) ?? (this._provider.name === "msedge-tts" ? D(e) : void 0);
+  }
+  /** Releases provider resources and cached audio. */
+  async dispose() {
+    await this._provider.dispose();
+  }
+}
+let B = null;
+function g() {
+  return B || (B = new R()), B;
+}
+class W {
+  /** Replaces the global client configuration and restores the built-in provider. */
+  static configure(e) {
+    B = new R(e);
+  }
+  /** Initializes the global speech provider. */
+  static async init(e) {
+    await g().init(e);
+  }
+  /** Replaces the global provider instance. */
+  static setProvider(e) {
+    g().setProvider(e);
+  }
+  /** Active global provider. */
+  static get provider() {
+    return g().provider;
+  }
+  /** Synthesizes text to speech. */
+  static async synthesize(e, t) {
+    return g().synthesize(e, t);
+  }
+  /** Legacy synthesis alias; follows the active provider. */
+  static async msedge(e, t) {
+    return g().synthesize(e, t);
+  }
+  /** Streams synthesized speech sentence by sentence. */
+  static async *stream(e, t) {
+    yield* g().stream(e, t);
+  }
+  /** Synthesizes and plays speech through a Scene or AudioManager. */
+  static async speak(e, t, i) {
+    return g().speak(e, t, i);
+  }
+  /** Returns the active provider's voices. */
+  static getVoices() {
+    return g().getVoices();
+  }
+  /** Finds a voice exposed by the active provider. */
+  static findVoice(e) {
+    return g().findVoice(e);
+  }
+  /** Recommended default voice. */
+  static DEFAULT_VOICE = U;
+  /** Explicit provider-specific alias for the recommended default voice. */
+  static DEFAULT_MSEDGE_VOICE = U;
+}
+function P(l, e, t, i) {
+  if (l !== void 0 && (!Number.isFinite(l) || l < e || l > t))
+    throw new Error(`[ElevenLabsTTSProvider] ${i} must be between ${e} and ${t}.`);
+}
+function L(l = {}, e) {
+  for (const t of ["stability", "similarityBoost", "style"]) P(l[t], 0, 1, t);
+  if (P(e ?? l.speed, 0.7, 1.2, "speed"), l.useSpeakerBoost !== void 0 && typeof l.useSpeakerBoost != "boolean")
+    throw new Error("[ElevenLabsTTSProvider] useSpeakerBoost must be a boolean.");
+  return {
+    stability: l.stability,
+    similarity_boost: l.similarityBoost,
+    style: l.style,
+    use_speaker_boost: l.useSpeakerBoost,
+    speed: e ?? l.speed
+  };
+}
+function F(l, e) {
+  if (!l) return;
+  const { characters: t, character_start_times_seconds: i, character_end_times_seconds: s } = l;
+  if (!Array.isArray(t) || !Array.isArray(i) || !Array.isArray(s) || t.length !== i.length || i.length !== s.length)
+    throw new Error("[ElevenLabsTTSProvider] Invalid character alignment.");
+  let n = "";
+  const r = [];
+  for (let c = 0; c < t.length; c++) {
+    if (typeof t[c] != "string" || !Number.isFinite(i[c]) || !Number.isFinite(s[c]) || i[c] < 0 || s[c] < i[c])
+      throw new Error("[ElevenLabsTTSProvider] Invalid character timestamps.");
+    r.push({ index: n.length, end: n.length + t[c].length, startMs: i[c] * 1e3, endMs: s[c] * 1e3 }), n += t[c];
+  }
+  const a = e === void 0 ? [] : [...n.matchAll(/\[[^\]]+\]|<[^>]+>/g)].filter((c) => !e.includes(c[0])).map((c) => ({ start: c.index, end: c.index + c[0].length })), o = [...new Intl.Segmenter(void 0, { granularity: "word" }).segment(n)], f = [];
+  let d = 0, h = 0;
+  for (const c of o) {
+    if (!c.isWordLike || a.some((u) => c.index >= u.start && c.index < u.end)) continue;
+    const y = c.index, w = n.slice(y + c.segment.length).match(/^[^\p{L}\p{N}\s\[<]*/u)?.[0] ?? "", v = y + c.segment.length + w.length;
+    for (; h < r.length && r[h].end <= y; ) h++;
+    if (h >= r.length) continue;
+    const m = Math.max(d, r[h].startMs);
+    let p = m;
+    for (let u = h; u < r.length && r[u].index < v; u++) p = Math.max(p, r[u].endMs);
+    f.push({ text: n.slice(y, v), offsetMs: m, durationMs: p - m, boundaryType: "WordBoundary" }), d = p;
+  }
+  return f.length ? f : void 0;
+}
+class K {
+  name = "elevenlabs";
+  #e = {};
+  _ready = !1;
+  _revision = 0;
+  _voices = [];
+  _cache = new T();
+  _pending = /* @__PURE__ */ new Map();
+  _controllers = /* @__PURE__ */ new Set();
+  get isReady() {
+    return this._ready;
+  }
+  /** Validates and stores configuration locally. Does not spend credits or fetch voices. */
+  async init(e = {}) {
+    const t = {
+      modelId: "eleven_multilingual_v2",
+      baseUrl: "https://api.elevenlabs.io",
+      outputFormat: "mp3_44100_128",
+      timeoutMs: 9e4,
+      ...this.#e,
+      ...e,
+      voiceSettings: { ...this.#e.voiceSettings, ...e.voiceSettings }
+    };
+    if (!t.apiKey?.trim()) throw new Error("[ElevenLabsTTSProvider] Supply apiKey to provider.init().");
+    const i = new URL(t.baseUrl);
+    if (!["https:", "http:"].includes(i.protocol) || i.search || i.hash || i.username || i.password)
+      throw new Error("[ElevenLabsTTSProvider] baseUrl must be an HTTP(S) URL without credentials, query, or fragment.");
+    if (!/^mp3_(22050_32|24000_48|44100_(32|64|96|128|192))$/.test(t.outputFormat))
+      throw new Error("[ElevenLabsTTSProvider] outputFormat must be a supported MP3 format.");
+    if (!Number.isFinite(t.timeoutMs) || t.timeoutMs <= 0) throw new Error("[ElevenLabsTTSProvider] timeoutMs must be positive.");
+    if (t.maxCacheSize !== void 0 && (!Number.isSafeInteger(t.maxCacheSize) || t.maxCacheSize < 1))
+      throw new Error("[ElevenLabsTTSProvider] maxCacheSize must be a positive integer.");
+    L(t.voiceSettings), this._reset(), this.#e = { ...t, apiKey: t.apiKey.trim(), baseUrl: t.baseUrl.replace(/\/+$/, "") }, this._cache = new T(t.maxCacheSize), this._ready = !0;
+  }
+  async synthesize(e, t = {}) {
+    this._assertReady();
+    const i = e.trim(), s = t.voice ?? this.#e.voiceId;
+    if (!s?.trim()) throw new Error("[ElevenLabsTTSProvider] Supply voiceId in init() or voice in synthesis options.");
+    if (t.pitch !== void 0 && ![0, "0", "+0Hz", "0Hz", "+0%", "0%", "+0st", "0st"].includes(t.pitch))
+      throw new Error("[ElevenLabsTTSProvider] Pitch is not supported; choose a voice or delivery tag instead.");
+    const n = { ...this.#e, ...t.elevenlabs }, r = { ...this.#e.voiceSettings, ...t.elevenlabs?.voiceSettings }, a = t.speed ?? r.speed ?? 1, o = L(r, a);
+    if (n.seed !== void 0 && (!Number.isInteger(n.seed) || n.seed < 0 || n.seed > 4294967295))
+      throw new Error("[ElevenLabsTTSProvider] seed must be an integer from 0 to 4294967295.");
+    if (!i) return new M({ text: t.displayText ?? "", voice: s, speed: a });
+    const f = {
+      text: i,
+      model_id: n.modelId,
+      voice_settings: o,
+      language_code: n.languageCode,
+      seed: n.seed,
+      previous_text: n.previousText,
+      next_text: n.nextText,
+      apply_text_normalization: n.applyTextNormalization,
+      pronunciation_dictionary_locators: n.pronunciationDictionaries?.map((m) => ({ pronunciation_dictionary_id: m.id, version_id: m.versionId }))
+    }, d = JSON.stringify({ body: f, output: this.#e.outputFormat, displayText: t.displayText }), h = this.#e.cacheAudio !== !1 ? this._cache.get(i, s, a, d) : void 0;
+    if (h) return h;
+    const c = JSON.stringify([s, d]), y = this._pending.get(c);
+    if (y) return y;
+    const w = this._revision, v = (async () => {
+      const m = await this._request(`/v1/text-to-speech/${encodeURIComponent(s)}/with-timestamps?output_format=${this.#e.outputFormat}`, {
+        method: "POST",
+        body: JSON.stringify(f)
+      });
+      if (w !== this._revision) throw new Error("[ElevenLabsTTSProvider] Provider changed during synthesis.");
+      if (typeof m.audio_base64 != "string" || !m.audio_base64) throw new Error("[ElevenLabsTTSProvider] API returned empty audio.");
+      let p;
+      try {
+        p = Uint8Array.from(atob(m.audio_base64), (x) => x.charCodeAt(0));
+      } catch {
+        throw new Error("[ElevenLabsTTSProvider] API returned invalid base64 audio.");
+      }
+      const u = C(p);
+      if (!p.length || !u.frameCount) throw new Error("[ElevenLabsTTSProvider] API did not return valid MP3 audio.");
+      const S = F(m.normalized_alignment?.characters?.length ? m.normalized_alignment : m.alignment, t.displayText), _ = S?.reduce((x, E) => Math.max(x, E.offsetMs + E.durationMs), u.durationMs) ?? u.durationMs, b = new M({
+        text: t.displayText ?? i,
+        voice: s,
+        speed: a,
+        rawBuffer: p.buffer,
+        mimeType: "audio/mpeg",
+        sampleRate: u.sampleRate,
+        durationMs: _,
+        wordBoundaries: S
+        // Leave PCM empty: playback decodes rawBuffer using the active AudioContext.
+      });
+      return this.#e.cacheAudio !== !1 && this._cache.set(i, s, a, b, d), b;
+    })();
+    this._pending.set(c, v);
+    try {
+      return await v;
+    } finally {
+      this._pending.get(c) === v && this._pending.delete(c);
+    }
+  }
+  /** Sentence-sized synthesis, matching Retiam's stream contract (not byte streaming). */
+  async *stream(e, t = {}) {
+    this._assertReady();
+    const i = [];
+    if (t.displayText !== void 0) i.push(e);
+    else {
+      const r = t.splitPattern ?? /[.!?;]+(?:\s+|$)/gu, a = new RegExp(r.source, r.flags.includes("g") ? r.flags : r.flags + "g");
+      let o = 0;
+      for (const f of e.matchAll(a)) {
+        if (!f[0].length) continue;
+        const d = f.index + f[0].length;
+        i.push(e.slice(o, d)), o = d;
+      }
+      i.push(e.slice(o));
+    }
+    const s = i.map((r) => r.trim()).filter(Boolean);
+    let n = 0;
+    for (const [r, a] of s.entries()) {
+      const o = await this.synthesize(a, {
+        ...t,
+        elevenlabs: {
+          ...t.elevenlabs,
+          previousText: t.elevenlabs?.previousText ?? (r ? s.slice(0, r).join(" ") : this.#e.previousText),
+          nextText: t.elevenlabs?.nextText ?? (r < s.length - 1 ? s.slice(r + 1).join(" ") : this.#e.nextText)
+        }
+      });
+      yield { text: o.text, phonemes: "", audio: o, chunkIndex: r, startTimeMs: n }, n += o.durationMs;
+    }
+  }
+  getVoices() {
+    return this._voices.map((e) => ({ ...e }));
+  }
+  /** Fetches the authenticated, paginated voice catalog explicitly. */
+  async fetchVoices() {
+    this._assertReady();
+    const e = this._revision, t = [], i = /* @__PURE__ */ new Set();
+    let s;
+    do {
+      const n = new URLSearchParams({ page_size: "100", include_total_count: "false" });
+      s && n.set("next_page_token", s);
+      const r = await this._request(`/v2/voices?${n}`);
+      if (e !== this._revision) throw new Error("[ElevenLabsTTSProvider] Provider changed while fetching voices.");
+      if (!Array.isArray(r.voices)) throw new Error("[ElevenLabsTTSProvider] Invalid voice catalog.");
+      for (const a of r.voices) {
+        if (typeof a.voice_id != "string" || typeof a.name != "string") continue;
+        const o = a.labels?.gender?.toLowerCase();
+        t.push({
+          id: a.voice_id,
+          name: a.name,
+          language: a.labels?.language ?? a.verified_languages?.[0]?.language ?? "und",
+          gender: o === "female" ? "Female" : o === "male" ? "Male" : "Unknown",
+          traits: a.description,
+          provider: "elevenlabs"
+        });
+      }
+      if (s = r.has_more ? r.next_page_token : void 0, r.has_more && (typeof s != "string" || !s || i.has(s)))
+        throw new Error("[ElevenLabsTTSProvider] Invalid voice catalog pagination.");
+      s && i.add(s);
+    } while (s);
+    return this._voices = [...new Map(t.map((n) => [n.id, n])).values()], this.getVoices();
+  }
+  clearCache() {
+    this._cache.clear();
+  }
+  async dispose() {
+    this._reset(), this.#e = {};
+  }
+  _assertReady() {
+    if (!this._ready) throw new Error("[ElevenLabsTTSProvider] Call provider.init({ apiKey, voiceId }) before synthesis.");
+  }
+  _reset() {
+    this._revision++, this._ready = !1;
+    for (const e of this._controllers) e.abort();
+    this._controllers.clear(), this._pending.clear(), this._voices = [], this.clearCache();
+  }
+  async _request(e, t = {}) {
+    const i = new AbortController();
+    this._controllers.add(i);
+    const s = setTimeout(() => i.abort(), this.#e.timeoutMs), n = this.#e.apiKey;
+    try {
+      const r = await fetch(`${this.#e.baseUrl}${e}`, {
+        ...t,
+        signal: i.signal,
+        headers: { "Content-Type": "application/json", "xi-api-key": n }
+      });
+      if (!r.ok) {
+        let a = r.statusText;
+        try {
+          const o = await r.json();
+          a = typeof o.detail == "string" ? o.detail : o.detail?.message ?? a;
+        } catch {
+        }
+        throw new Error(`HTTP ${r.status}: ${a}`);
+      }
+      return await r.json();
+    } catch (r) {
+      const a = i.signal.aborted ? "Request aborted or timed out." : r.message;
+      throw new Error(`[ElevenLabsTTSProvider] ${String(a).split(n).join("[redacted]")}`);
+    } finally {
+      clearTimeout(s), this._controllers.delete(i);
+    }
+  }
+}
+export {
+  U as DEFAULT_MSEDGE_VOICE,
+  K as ElevenLabsTTSProvider,
+  q as MSEDGE_VOICES,
+  j as MsEdgeTTSProvider,
+  W as TTS,
+  M as TTSAudio,
+  T as TTSCache,
+  R as TTSClient,
+  $ as encodeWAV,
+  V as fetchRemoteMsEdgeVoices,
+  D as findMsEdgeVoice,
+  O as getAvailableMsEdgeVoices,
+  G as getMsEdgeVoicesByLanguage,
+  C as parseMp3Metadata,
+  I as setDynamicMsEdgeVoices
+};