@andresaya/edge-tts 1.8.1 → 1.9.0

package/dist/browser/edge-tts.umd.js

@@ -23,26 +23,38 @@ var EdgeTTSModule = (() => {
   // src/browser/EdgeTTS.browser.ts
   var EdgeTTS_browser_exports = {};
   __export(EdgeTTS_browser_exports, {
-    EdgeTTS: () => EdgeTTS
+    EdgeTTS: () => EdgeTTS,
+    EdgeTTSError: () => EdgeTTSError,
+    toSRT: () => toSRT,
+    toVTT: () => toVTT
   });
 
+  // src/core/crypto.ts
+  var impl;
+  function webCrypto() {
+    const crypto = impl ?? globalThis.crypto;
+    if (!crypto) throw new Error("Web Crypto is not available in this environment");
+    return crypto;
+  }
+
   // src/config/constants.ts
   var Constants = {
     TRUSTED_CLIENT_TOKEN: "6A5AA1D4EAFF4E9FB37E23D68491D6F4",
     BASE_URL: "https://speech.platform.bing.com/consumer/speech/synthesize/readaloud",
-    WSS_URL: "wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1",
+    // NOTE: token goes as Ocp-Apim-Subscription-Key here; Edge user agents only.
+    WSS_URL: "wss://api.msedgeservices.com/tts/cognitiveservices/websocket/v1",
     VOICES_URL: "https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list",
-    CHROMIUM_FULL_VERSION: "143.0.3650.75",
-    CHROMIUM_MAJOR_VERSION: "143",
-    VERSION_MS_GEC: "1-143.0.3650",
+    CHROMIUM_FULL_VERSION: "155.0.0.0",
+    CHROMIUM_MAJOR_VERSION: "155",
+    VERSION_MS_GEC: "1-155.0.4283.45",
     token32() {
       const bytes = new Uint8Array(16);
-      crypto.getRandomValues(bytes);
+      webCrypto().getRandomValues(bytes);
       return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
     },
     getBaseHeaders() {
       return {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36 Edg/155.0.0.0",
         "Accept-Encoding": "gzip, deflate, br, zstd",
         "Accept-Language": "en-US,en;q=0.9",
         "Cookie": "MUID=" + this.token32()
@@ -52,13 +64,12 @@ var EdgeTTSModule = (() => {
       "Pragma": "no-cache",
       "Cache-Control": "no-cache",
       "Origin": "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold",
-      "Sec-WebSocket-Protocol": "synthesize",
-      "Sec-WebSocket-Version": "13",
-      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.3650.75 Safari/537.36 Edg/143.0.3650.75"
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36 Edg/155.0.0.0"
     },
     VOICE_HEADERS: {
-      "Sec-CH-UA": '" Not;A Brand";v="99", "Microsoft Edge";v="143", "Chromium";v="143"',
+      "Sec-CH-UA": '"Microsoft Edge";v="155", "Chromium";v="155", "Not(A:Brand";v="24"',
       "Sec-CH-UA-Mobile": "?0",
+      "Sec-CH-UA-Platform": '"Windows"',
       "Accept": "*/*",
       "Sec-Fetch-Site": "none",
       "Sec-Fetch-Mode": "cors",
@@ -72,73 +83,489 @@ var EdgeTTSModule = (() => {
     }
   };
 
-  // src/browser/EdgeTTS.browser.ts
-  var EdgeTTS = class {
-    constructor() {
+  // src/core/clock.ts
+  var skewMs = 0;
+  function now() {
+    return Date.now() + skewMs;
+  }
+
+  // src/core/errors.ts
+  var EdgeTTSError = class extends Error {
+    constructor(message, code, options = {}) {
+      super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+      __publicField(this, "code");
+      __publicField(this, "status");
+      this.name = "EdgeTTSError";
+      this.code = code;
+      if (options.status !== void 0) this.status = options.status;
+    }
+  };
+
+  // src/core/protocol.ts
+  var DEFAULT_OUTPUT_FORMAT = "audio-24khz-48kbitrate-mono-mp3";
+  var decoder = new TextDecoder();
+  function buildSynthesisUrl(base, token, secMsGec, version, connectionId) {
+    return `${base}?Ocp-Apim-Subscription-Key=${token}&Sec-MS-GEC=${secMsGec}&Sec-MS-GEC-Version=${version}&ConnectionId=${connectionId}`;
+  }
+  function buildConfigMessage(timestamp2, outputFormat) {
+    return `X-Timestamp:${timestamp2}\r
+Content-Type:application/json; charset=utf-8\r
+Path:speech.config\r
+\r
+{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":true,"wordBoundaryEnabled":true},"outputFormat":"${outputFormat}"}}}}`;
+  }
+  function buildSSMLMessage(requestId, timestamp2, ssml) {
+    return `X-RequestId:${requestId}\r
+Content-Type:application/ssml+xml\r
+X-Timestamp:${timestamp2}\r
+Path:ssml\r
+\r
+${ssml}`;
+  }
+  function escapeXML(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  function buildSSML(text, voice, pitch, rate, volume) {
+    return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">
+                    <voice name="${voice}">
+                        <prosody pitch="${pitch}" rate="${rate}" volume="${volume}">
+                            ${escapeXML(text)}
+                        </prosody>
+                    </voice>
+                </speak>`;
+  }
+  function headerPath(head) {
+    return /Path:([^\r\n]*)/i.exec(head)?.[1]?.trim() ?? "";
+  }
+  function parseTextFrame(text) {
+    const split = text.indexOf("\r\n\r\n");
+    if (split === -1) return { path: headerPath(text), body: "" };
+    return { path: headerPath(text.slice(0, split)), body: text.slice(split + 4) };
+  }
+  function parseBinaryFrame(data) {
+    if (data.length < 2) return { path: "", body: new Uint8Array(0) };
+    const headerLength = data[0] << 8 | data[1];
+    return {
+      path: headerPath(decoder.decode(data.subarray(2, 2 + headerLength))),
+      body: data.slice(2 + headerLength)
+    };
+  }
+  function parseMetadata(body) {
+    let metadata;
+    try {
+      metadata = JSON.parse(body);
+    } catch {
+      return [];
+    }
+    if (!Array.isArray(metadata?.Metadata)) return [];
+    const boundaries = [];
+    for (const item of metadata.Metadata) {
+      if (item?.Type !== "WordBoundary" && item?.Type !== "SentenceBoundary") continue;
+      boundaries.push({
+        type: item.Type,
+        offset: item.Data.Offset,
+        duration: item.Data.Duration,
+        text: item.Data.text?.Text
+      });
+    }
+    return boundaries;
+  }
+  var OPENING_PUNCTUATION = `\xBF\xA1\xAB"'\u201C\u2018([`;
+  function sentenceTextRestorer(source) {
+    let cursor = 0;
+    return (text) => {
+      const index = text ? source.indexOf(text, cursor) : -1;
+      if (index === -1) return text;
+      let start = index;
+      while (start > cursor && OPENING_PUNCTUATION.includes(source[start - 1])) start--;
+      cursor = index + text.length;
+      return source.slice(start, cursor);
+    };
+  }
+  async function generateSecMsGec(trustedClientToken, nowMs) {
+    const ticks = Math.floor(nowMs / 1e3) + 11644473600;
+    const rounded = ticks - ticks % 300;
+    const windowsTicks = rounded * 1e7;
+    const data = new TextEncoder().encode(`${windowsTicks}${trustedClientToken}`);
+    const hashBuffer = await webCrypto().subtle.digest("SHA-256", data);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+  }
+  function generateUUID() {
+    return "xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  function fileExtension(format) {
+    if (format.includes("mp3")) return "mp3";
+    if (format.includes("opus") && format.includes("webm")) return "webm";
+    if (format.includes("opus") && format.includes("ogg")) return "ogg";
+    if (format.includes("wav") || format.includes("riff")) return "wav";
+    if (format.includes("pcm") && format.includes("raw")) return "pcm";
+    if (format.includes("alaw")) return "alaw";
+    if (format.includes("mulaw")) return "mulaw";
+    if (format.includes("truesilk")) return "silk";
+    if (format.includes("g722")) return "g722";
+    if (format.includes("amr")) return "amr";
+    return "audio";
+  }
+  function estimateDuration(bytes, outputFormat) {
+    const kbps = Number(/(\d+)kbitrate/.exec(outputFormat)?.[1] ?? 48);
+    return bytes * 8 / (kbps * 1e3);
+  }
+  function concatChunks(chunks) {
+    const result = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  function normalizeVoices(data) {
+    const out = [];
+    for (const v of data || []) {
+      const short = v?.ShortName || "";
+      const locale = v?.Locale || "";
+      let base = short.replace(/^[a-z]{2}-[A-Z]{2}-/, "");
+      base = base.replace(/NeuralHD$/, "").replace(/Neural$/, "").trim();
+      const mix = `${v?.Name || ""} ${short}`;
+      const voiceType = v?.VoiceType || (/NeuralHD/i.test(mix) ? "NeuralHD" : "Neural");
+      const localeName = v?.LocaleName || (locale || null);
+      let display = v?.DisplayName || v?.FriendlyName || base || short;
+      display = display.replace(/^Microsoft\s+/i, "");
+      display = display.split(" - ")[0].trim();
+      display = display.replace(/\s*Online\s*\(Natural\)\s*/i, " ");
+      display = display.replace(/\s*Online\s*/i, " ");
+      display = display.replace(/\s+/g, " ").trim();
+      const tag = v?.VoiceTag && typeof v.VoiceTag === "object" ? v.VoiceTag : {};
+      const tailored = Array.isArray(tag.TailoredScenarios) ? tag.TailoredScenarios : Array.isArray(tag.ContentCategories) ? tag.ContentCategories : [];
+      const personalities = Array.isArray(tag.VoicePersonalities) ? tag.VoicePersonalities : [];
+      out.push({
+        Name: short || (v?.Name || ""),
+        DisplayName: display,
+        LocalName: display,
+        ShortName: short || (v?.Name || ""),
+        Gender: v?.Gender ?? null,
+        Locale: locale || null,
+        LocaleName: localeName,
+        SecondaryLocaleList: Array.isArray(v?.SecondaryLocaleList) ? v.SecondaryLocaleList : [],
+        VoiceType: voiceType,
+        VoiceTag: {
+          TailoredScenarios: tailored,
+          VoicePersonalities: personalities
+        },
+        FriendlyName: `${display} (${voiceType}) - ${localeName}`
+      });
+    }
+    return out;
+  }
+
+  // src/core/session.ts
+  var CONNECTING = 0;
+  var OPEN = 1;
+  function abortReason(signal) {
+    if (signal.reason !== void 0) return signal.reason;
+    const error = new Error("This operation was aborted");
+    error.name = "AbortError";
+    return error;
+  }
+  function toBytes(data) {
+    if (data instanceof ArrayBuffer) return new Uint8Array(data);
+    if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return new Uint8Array(0);
+  }
+  function runSession(open, options) {
+    return new Promise((resolve, reject) => {
+      if (options.signal?.aborted) {
+        reject(abortReason(options.signal));
+        return;
+      }
+      const socket = open();
+      socket.binaryType = "arraybuffer";
+      let settled = false;
+      let opened = false;
+      let timer;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onAbort);
+        if (error === void 0) {
+          resolve();
+          return;
+        }
+        if (socket.readyState === CONNECTING || socket.readyState === OPEN) socket.close();
+        reject(error);
+      };
+      const arm = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+          finish(new EdgeTTSError("WebSocket inactivity timeout - no response from server", "TIMEOUT"));
+        }, options.timeout);
+      };
+      const onAbort = () => finish(abortReason(options.signal));
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      arm();
+      socket.onopen = () => {
+        if (settled) return;
+        opened = true;
+        arm();
+        socket.send(options.configMessage);
+        socket.send(options.ssmlMessage);
+      };
+      socket.onmessage = (event) => {
+        if (settled) return;
+        arm();
+        if (typeof event.data === "string") {
+          const frame2 = parseTextFrame(event.data);
+          if (frame2.path === "audio.metadata") {
+            for (const boundary of parseMetadata(frame2.body)) options.onBoundary(boundary);
+          } else if (frame2.path === "turn.end") {
+            socket.close();
+          }
+          return;
+        }
+        const frame = parseBinaryFrame(toBytes(event.data));
+        if (frame.path === "audio") options.onAudio(frame.body);
+      };
+      socket.onerror = (event) => finish(options.toError(event, opened));
+      socket.onclose = () => finish();
+    });
+  }
+
+  // src/core/subtitles.ts
+  function timestamp(ticks, separator) {
+    const total = Math.max(0, Math.round(ticks / 1e4));
+    const ms = total % 1e3;
+    const s = Math.floor(total / 1e3) % 60;
+    const m = Math.floor(total / 6e4) % 60;
+    const h = Math.floor(total / 36e5);
+    const pad = (n, width = 2) => String(n).padStart(width, "0");
+    return `${pad(h)}:${pad(m)}:${pad(s)}${separator}${pad(ms, 3)}`;
+  }
+  function toSRT(cues) {
+    return cues.map((cue, i) => `${i + 1}
+${timestamp(cue.offset, ",")} --> ${timestamp(cue.offset + cue.duration, ",")}
+${cue.text}
+`).join("\n");
+  }
+  function toVTT(cues) {
+    const body = cues.map((cue) => `${timestamp(cue.offset, ".")} --> ${timestamp(cue.offset + cue.duration, ".")}
+${cue.text}
+`).join("\n");
+    return `WEBVTT
+
+${body}`;
+  }
+
+  // src/core/base.ts
+  var DEFAULT_TIMEOUT = 3e4;
+  var DEFAULT_VOICES_CACHE_TTL = 10 * 6e4;
+  var NO_AUDIO_MESSAGE = "The service returned no audio. Voices are locale specific, so a voice cannot read text written in another script. Check that the voice matches the language of the text.";
+  function noAudioMessage(outputFormat) {
+    const supported = Object.values(Constants.OUTPUT_FORMAT);
+    if (supported.includes(outputFormat)) return NO_AUDIO_MESSAGE;
+    return `${NO_AUDIO_MESSAGE} The output format "${outputFormat}" may also be the cause: the service is known to support ${supported.join(", ")}.`;
+  }
+  function collect(text, words, sentences) {
+    const restore = sentenceTextRestorer(text);
+    return (boundary) => {
+      if (boundary.type === "WordBoundary") words.push(boundary);
+      else sentences.push({ ...boundary, text: restore(boundary.text) });
+    };
+  }
+  var EdgeTTSCore = class {
+    constructor(options = {}) {
       __publicField(this, "audio_stream", []);
-      __publicField(this, "ws");
+      __publicField(this, "output_format", DEFAULT_OUTPUT_FORMAT);
+      __publicField(this, "word_boundaries", []);
+      __publicField(this, "sentence_boundaries", []);
+      __publicField(this, "options");
+      __publicField(this, "voicesCache");
+      this.options = { ...options };
+    }
+    async recoverHandshake() {
+      return false;
+    }
+    signature() {
+      return generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN, now());
     }
     async normalizeVoices(data) {
-      const out = [];
-      for (const v of data || []) {
-        const short = v?.ShortName || "";
-        const locale = v?.Locale || "";
-        let base = short.replace(/^[a-z]{2}-[A-Z]{2}-/, "");
-        base = base.replace(/NeuralHD$/, "").replace(/Neural$/, "").trim();
-        const mix = `${v?.Name || ""} ${short}`;
-        const voiceType = v?.VoiceType || (/NeuralHD/i.test(mix) ? "NeuralHD" : "Neural");
-        const localeName = v?.LocaleName || (locale || null);
-        let display = v?.DisplayName || v?.FriendlyName || base || short;
-        display = display.replace(/^Microsoft\s+/i, "");
-        display = display.split(" - ")[0].trim();
-        display = display.replace(/\s*Online\s*\(Natural\)\s*/i, " ");
-        display = display.replace(/\s*Online\s*/i, " ");
-        display = display.replace(/\s+/g, " ").trim();
-        const tag = v?.VoiceTag && typeof v.VoiceTag === "object" ? v.VoiceTag : {};
-        const tailored = Array.isArray(tag.TailoredScenarios) ? tag.TailoredScenarios : Array.isArray(tag.ContentCategories) ? tag.ContentCategories : [];
-        const personalities = Array.isArray(tag.VoicePersonalities) ? tag.VoicePersonalities : [];
-        out.push({
-          Name: short || (v?.Name || ""),
-          DisplayName: display,
-          LocalName: display,
-          ShortName: short || (v?.Name || ""),
-          Gender: v?.Gender ?? null,
-          Locale: locale || null,
-          LocaleName: localeName,
-          SecondaryLocaleList: Array.isArray(v?.SecondaryLocaleList) ? v.SecondaryLocaleList : [],
-          VoiceType: voiceType,
-          VoiceTag: {
-            TailoredScenarios: tailored,
-            VoicePersonalities: personalities
-          },
-          FriendlyName: `${display} (${voiceType}) - ${localeName}`
-        });
-      }
-      return out;
+      return normalizeVoices(data);
     }
     async getVoices() {
-      const secMsGEC = await this.generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN);
-      const response = await fetch(
-        `${Constants.VOICES_URL}?TrustedClientToken=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${Constants.VERSION_MS_GEC}`,
-        { headers: Constants.getBaseHeaders() }
-      );
-      const data = await response.json();
-      return this.normalizeVoices(data.voices || []);
+      if (this.voicesCache && this.voicesCache.expires > Date.now()) {
+        return JSON.parse(JSON.stringify(this.voicesCache.voices));
+      }
+      const secMsGEC = await this.signature();
+      const url = `${this.options.voicesUrl ?? Constants.VOICES_URL}?TrustedClientToken=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${this.options.secMsGecVersion ?? Constants.VERSION_MS_GEC}`;
+      const voices = await this.normalizeVoices(await this.requestVoices(url));
+      const ttl = this.options.voicesCacheTtl ?? DEFAULT_VOICES_CACHE_TTL;
+      if (ttl > 0) {
+        this.voicesCache = { expires: Date.now() + ttl, voices: JSON.parse(JSON.stringify(voices)) };
+      }
+      return voices;
     }
     async getVoicesByLanguage(locale) {
       const voices = await this.getVoices();
-      return voices.filter((voice) => voice.Locale.startsWith(locale));
+      return voices.filter((voice) => voice.Locale?.startsWith(locale));
     }
     async getVoicesByGender(gender) {
       const voices = await this.getVoices();
       return voices.filter((voice) => voice.Gender === gender);
     }
-    generateUUID() {
-      return "xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === "x" ? r : r & 3 | 8;
-        return v.toString(16);
-      });
+    async synthesize(text, voice = this.defaultVoice, options = {}) {
+      const audio = [];
+      const words = [];
+      const sentences = [];
+      this.audio_stream = audio;
+      this.word_boundaries = words;
+      this.sentence_boundaries = sentences;
+      this.output_format = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+      await this.run(text, voice, options, (chunk) => audio.push(chunk), collect(text, words, sentences));
+    }
+    async *synthesizeStream(text, voice = this.defaultVoice, options = {}) {
+      const audio = [];
+      const words = [];
+      const sentences = [];
+      this.audio_stream = audio;
+      this.word_boundaries = words;
+      this.sentence_boundaries = sentences;
+      this.output_format = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+      const controller = new AbortController();
+      const forwardAbort = () => controller.abort(abortReason(options.signal));
+      if (options.signal?.aborted) forwardAbort();
+      else options.signal?.addEventListener("abort", forwardAbort, { once: true });
+      const queue = [];
+      let wake = null;
+      let done = false;
+      let failure;
+      const notify = () => {
+        wake?.();
+        wake = null;
+      };
+      this.run(text, voice, { ...options, signal: controller.signal }, (chunk) => {
+        audio.push(chunk);
+        queue.push(chunk);
+        notify();
+      }, collect(text, words, sentences)).then(
+        () => {
+          done = true;
+          notify();
+        },
+        (error) => {
+          failure = error;
+          done = true;
+          notify();
+        }
+      );
+      try {
+        while (!done || queue.length > 0) {
+          if (queue.length === 0) {
+            await new Promise((resolve) => wake = resolve);
+            continue;
+          }
+          yield queue.shift();
+        }
+        if (failure !== void 0) throw failure;
+      } finally {
+        options.signal?.removeEventListener("abort", forwardAbort);
+        if (!done) controller.abort();
+      }
+    }
+    async generate(text, voice = this.defaultVoice, options = {}) {
+      const chunks = [];
+      const words = [];
+      const sentences = [];
+      await this.run(text, voice, options, (chunk) => chunks.push(chunk), collect(text, words, sentences));
+      const audio = concatChunks(chunks);
+      const outputFormat = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+      if (audio.length === 0) throw new EdgeTTSError(noAudioMessage(outputFormat), "NO_AUDIO");
+      return {
+        audio,
+        format: fileExtension(outputFormat),
+        outputFormat,
+        wordBoundaries: words,
+        sentenceBoundaries: sentences,
+        duration: estimateDuration(audio.length, outputFormat)
+      };
+    }
+    getWordBoundaries() {
+      return this.word_boundaries;
+    }
+    getSentenceBoundaries() {
+      return this.sentence_boundaries;
+    }
+    toSRT() {
+      return toSRT(this.sentence_boundaries.length > 0 ? this.sentence_boundaries : this.word_boundaries);
+    }
+    toVTT() {
+      return toVTT(this.sentence_boundaries.length > 0 ? this.sentence_boundaries : this.word_boundaries);
+    }
+    async run(text, voice, options, onAudio, onBoundary) {
+      const ssml = this.buildSSML(text, voice, options);
+      const outputFormat = options.outputFormat || DEFAULT_OUTPUT_FORMAT;
+      const attempt = async () => {
+        const requestId = generateUUID();
+        const url = buildSynthesisUrl(
+          this.options.wssUrl ?? Constants.WSS_URL,
+          Constants.TRUSTED_CLIENT_TOKEN,
+          await this.signature(),
+          this.options.secMsGecVersion ?? Constants.VERSION_MS_GEC,
+          requestId
+        );
+        await runSession(() => this.openSocket(url), {
+          configMessage: buildConfigMessage(this.timestamp(), outputFormat),
+          ssmlMessage: buildSSMLMessage(requestId, this.timestamp(), ssml),
+          timeout: options.timeout ?? this.options.timeout ?? DEFAULT_TIMEOUT,
+          signal: options.signal,
+          onAudio,
+          onBoundary,
+          toError: (event, opened) => this.socketError(event, opened)
+        });
+      };
+      try {
+        await attempt();
+      } catch (error) {
+        if (!(error instanceof EdgeTTSError && error.code === "HANDSHAKE")) throw error;
+        if (!await this.recoverHandshake()) throw error;
+        await attempt();
+      }
+    }
+  };
+
+  // src/browser/EdgeTTS.browser.ts
+  var EdgeTTS = class extends EdgeTTSCore {
+    constructor(options = {}) {
+      super(options);
+      __publicField(this, "defaultVoice", "en-US-JennyNeural");
+      __publicField(this, "ws");
+    }
+    openSocket(url) {
+      this.ws = new WebSocket(url);
+      return this.ws;
+    }
+    async requestVoices(url) {
+      const response = await fetch(url, { headers: Constants.getBaseHeaders() });
+      if (!response.ok) {
+        throw new EdgeTTSError(`Voice list request failed with status ${response.status}`, "VOICES", { status: response.status });
+      }
+      const data = await response.json();
+      return Array.isArray(data) ? data : data?.voices || [];
+    }
+    buildSSML(text, voice, options) {
+      const pitch = this.validatePitch(options.pitch ?? 0);
+      const rate = this.validateRate(options.rate ?? 0);
+      const volume = this.validateVolume(options.volume ?? 0);
+      return buildSSML(text, voice, pitch, rate, volume);
+    }
+    timestamp() {
+      return (/* @__PURE__ */ new Date()).toUTCString();
+    }
+    socketError(_event, opened) {
+      return new EdgeTTSError("WebSocket error", opened ? "NETWORK" : "HANDSHAKE");
     }
     validatePitch(pitch) {
       if (typeof pitch === "number") {
@@ -164,248 +591,13 @@ var EdgeTTSModule = (() => {
       }
       return `${volumeValue}%`;
     }
-    escapeXML(text) {
-      return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-    }
-    getSSML(content, voice, options = {}) {
-      const pitch = this.validatePitch(options.pitch ?? 0);
-      const rate = this.validateRate(options.rate ?? 0);
-      const volume = this.validateVolume(options.volume ?? 0);
-      const escapedText = this.escapeXML(content);
-      return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">
-                    <voice name="${voice}">
-                        <prosody pitch="${pitch}" rate="${rate}" volume="${volume}">
-                            ${escapedText}
-                        </prosody>
-                    </voice>
-                </speak>`;
-    }
-    nowRFC1123() {
-      return (/* @__PURE__ */ new Date()).toUTCString();
-    }
-    parseRFC1123(rfcStr) {
-      return new Date(rfcStr);
-    }
-    buildTTSConfigMessage() {
-      const timestamp = this.nowRFC1123();
-      return `X-Timestamp:${timestamp}\r
-Content-Type:application/json; charset=utf-8\r
-Path:speech.config\r
-\r
-{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}`;
-    }
-    async synthesize(text, voice = "en-US-JennyNeural", options = {}) {
-      const secMsGEC = await this.generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN);
-      return new Promise((resolve, reject) => {
-        this.audio_stream = [];
-        const reqId = this.generateUUID();
-        const url = `${Constants.WSS_URL}?TrustedClientToken=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
-        this.ws = new WebSocket(url);
-        const SSML_text = this.getSSML(text, voice, options);
-        let timedOut = false;
-        let inactivityTimeout;
-        const resetInactivityTimeout = () => {
-          clearTimeout(inactivityTimeout);
-          inactivityTimeout = window.setTimeout(() => {
-            timedOut = true;
-            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-              this.ws.close();
-            }
-            reject(new Error("WebSocket inactivity timeout - no response from server"));
-          }, 3e4);
-        };
-        this.ws.onopen = () => {
-          resetInactivityTimeout();
-          const message = this.buildTTSConfigMessage();
-          this.ws.send(message);
-          const timestamp = this.nowRFC1123();
-          const speechMessage = `X-RequestId:${reqId}\r
-Content-Type:application/ssml+xml\r
-X-Timestamp:${timestamp}\r
-Path:ssml\r
-\r
-${SSML_text}`;
-          this.ws.send(speechMessage);
-        };
-        this.ws.onmessage = (event) => {
-          resetInactivityTimeout();
-          if (typeof event.data === "string") {
-            if (event.data.includes("Path:turn.end")) {
-              this.ws?.close();
-            }
-          } else {
-            const reader = new FileReader();
-            reader.onload = () => {
-              const arrayBuffer = reader.result;
-              const uint8Array = new Uint8Array(arrayBuffer);
-              this.processAudioData(uint8Array);
-            };
-            reader.readAsArrayBuffer(event.data);
-          }
-        };
-        this.ws.onerror = (err) => {
-          clearTimeout(inactivityTimeout);
-          if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            this.ws.close();
-          }
-          reject(new Error("WebSocket error"));
-        };
-        this.ws.onclose = () => {
-          clearTimeout(inactivityTimeout);
-          if (!timedOut) {
-            resolve();
-          }
-        };
-      });
-    }
-    async *synthesizeStream(text, voice = "en-US-JennyNeural", options = {}) {
-      this.audio_stream = [];
-      const reqId = this.generateUUID();
-      const secMsGEC = await this.generateSecMsGec(Constants.TRUSTED_CLIENT_TOKEN);
-      const url = `${Constants.WSS_URL}?TrustedClientToken=${Constants.TRUSTED_CLIENT_TOKEN}&Sec-MS-GEC=${secMsGEC}&Sec-MS-GEC-Version=${Constants.VERSION_MS_GEC}&ConnectionId=${reqId}`;
-      this.ws = new WebSocket(url);
-      const SSML_text = this.getSSML(text, voice, options);
-      const queue = [];
-      let done = false;
-      let error = null;
-      let notify = null;
-      const push = (chunk) => {
-        queue.push(chunk);
-        if (notify) {
-          notify();
-          notify = null;
-        }
-      };
-      let timedOut = false;
-      let inactivityTimeout;
-      const resetInactivityTimeout = () => {
-        clearTimeout(inactivityTimeout);
-        inactivityTimeout = window.setTimeout(() => {
-          timedOut = true;
-          error = new Error("WebSocket inactivity timeout - no response from server");
-          done = true;
-          if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            this.ws.close();
-          }
-          if (notify) {
-            notify();
-            notify = null;
-          }
-        }, 3e4);
-      };
-      this.ws.onopen = () => {
-        resetInactivityTimeout();
-        const message = this.buildTTSConfigMessage();
-        this.ws.send(message);
-        const timestamp = this.nowRFC1123();
-        const speechMessage = `X-RequestId:${reqId}\r
-Content-Type:application/ssml+xml\r
-X-Timestamp:${timestamp}\r
-Path:ssml\r
-\r
-${SSML_text}`;
-        this.ws.send(speechMessage);
-      };
-      this.ws.onmessage = (event) => {
-        resetInactivityTimeout();
-        if (typeof event.data === "string") {
-          if (event.data.includes("Path:turn.end")) {
-            this.ws?.close();
-          }
-        } else {
-          const reader = new FileReader();
-          reader.onload = () => {
-            const arrayBuffer = reader.result;
-            const uint8Array = new Uint8Array(arrayBuffer);
-            const needle = new TextEncoder().encode("Path:audio\r\n");
-            const audioStartIndex = this.indexOf(uint8Array, needle);
-            if (audioStartIndex !== -1) {
-              const audioChunk = uint8Array.slice(audioStartIndex + needle.length);
-              this.audio_stream.push(audioChunk);
-              push(audioChunk);
-            }
-          };
-          reader.readAsArrayBuffer(event.data);
-        }
-      };
-      this.ws.onerror = (err) => {
-        clearTimeout(inactivityTimeout);
-        error = new Error("WebSocket error");
-        done = true;
-        if (notify) {
-          notify();
-          notify = null;
-        }
-      };
-      this.ws.onclose = () => {
-        clearTimeout(inactivityTimeout);
-        done = true;
-        if (notify) {
-          notify();
-          notify = null;
-        }
-      };
-      while (!done || queue.length > 0) {
-        if (queue.length === 0) {
-          await new Promise((resolve) => notify = resolve);
-          continue;
-        }
-        const chunk = queue.shift();
-        if (chunk) {
-          yield chunk;
-        }
-      }
-      if (error) {
-        throw error;
-      }
-    }
-    processAudioData(buffer) {
-      const needle = new TextEncoder().encode("Path:audio\r\n");
-      const audioStartIndex = this.indexOf(buffer, needle);
-      if (audioStartIndex !== -1) {
-        const audioChunk = buffer.slice(audioStartIndex + needle.length);
-        this.audio_stream.push(audioChunk);
-      }
-    }
-    indexOf(arr, subarr) {
-      for (let i = 0; i <= arr.length - subarr.length; i++) {
-        let match = true;
-        for (let j = 0; j < subarr.length; j++) {
-          if (arr[i + j] !== subarr[j]) {
-            match = false;
-            break;
-          }
-        }
-        if (match) return i;
-      }
-      return -1;
-    }
-    async generateSecMsGec(trustedClientToken) {
-      const now = this.nowRFC1123();
-      const fixedDate = this.parseRFC1123(now);
-      const ticks = Math.floor(fixedDate.getTime() / 1e3) + 11644473600;
-      const rounded = ticks - ticks % 300;
-      const windowsTicks = rounded * 1e7;
-      const encoder = new TextEncoder();
-      const data = encoder.encode(`${windowsTicks}${trustedClientToken}`);
-      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-      return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
-    }
     getAudioData() {
       if (this.audio_stream.length === 0) {
-        throw new Error("No audio data available");
-      }
-      const totalLength = this.audio_stream.reduce((acc, chunk) => acc + chunk.length, 0);
-      if (totalLength === 0) {
-        throw new Error(
-          "The service returned no audio. Voices are locale specific, so a voice cannot read text written in another script. Check that the voice matches the language of the text."
-        );
+        throw new EdgeTTSError("No audio data available", "NO_AUDIO");
       }
-      const result = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of this.audio_stream) {
-        result.set(chunk, offset);
-        offset += chunk.length;
+      const result = concatChunks(this.audio_stream);
+      if (result.length === 0) {
+        throw new EdgeTTSError(noAudioMessage(this.output_format), "NO_AUDIO");
       }
       return result;
     }