@ssml-builder-js/azure-tts-client 2.14.0 → 2.16.0

package/dist/index.js

@@ -37,16 +37,23 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AudioFormatMismatchError: () => AudioFormatMismatchError,
   AzureTtsClient: () => AzureTtsClient,
   AzureTtsError: () => AzureTtsError,
   AzureTtsSdkError: () => AzureTtsSdkError,
   ChunkValidationError: () => ChunkValidationError,
+  DEFAULT_OUTPUT_FORMAT: () => DEFAULT_OUTPUT_FORMAT,
+  MergeError: () => MergeError,
+  SynthesisCancelledError: () => SynthesisCancelledError,
+  SynthesisTimeoutError: () => SynthesisTimeoutError,
   UnsupportedMergeFormatError: () => UnsupportedMergeFormatError,
   canMergeAudioFormat: () => canMergeAudioFormat,
   fetchAzureVoiceCatalog: () => fetchAzureVoiceCatalog,
+  inspectAudioSpecification: () => inspectAudioSpecification,
   mergeAudioBuffers: () => mergeAudioBuffers,
   mergeSynthesisResults: () => mergeSynthesisResults,
   resolveMergeAudioFormat: () => resolveMergeAudioFormat,
+  resolveMimeType: () => resolveMimeType,
   synthesizeSpeech: () => synthesizeSpeech,
   synthesizeSsml: () => synthesizeSsml,
   synthesizeSsmlChunks: () => synthesizeSsmlChunks,
@@ -59,6 +66,7 @@ module.exports = __toCommonJS(index_exports);
 var AzureTtsError = class extends Error {
   constructor(status, statusText, responseBody, requestId) {
     super(`Azure TTS request failed: ${status} ${statusText}`);
+    this.kind = "azure-api-error";
     this.name = "AzureTtsError";
     this.status = status;
     this.statusText = statusText;
@@ -74,13 +82,52 @@ var AzureTtsSdkError = class extends AzureTtsError {
     this.errorDetails = errorDetails;
   }
 };
+var SynthesisCancelledError = class extends Error {
+  constructor(message = "Speech synthesis was cancelled.") {
+    super(message);
+    this.kind = "cancelled";
+    this.name = "SynthesisCancelledError";
+  }
+};
+var SynthesisTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.kind = "timeout";
+    this.name = "SynthesisTimeoutError";
+  }
+};
+var MergeError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.kind = "merge-error";
+    this.name = "MergeError";
+    this.cause = cause;
+  }
+};
+var AudioFormatMismatchError = class extends Error {
+  constructor(message, inputSpecs = []) {
+    super(message);
+    this.kind = "audio-format-mismatch";
+    this.name = "AudioFormatMismatchError";
+    this.inputSpecs = inputSpecs;
+  }
+};
 var UnsupportedMergeFormatError = class extends Error {
   constructor(format) {
     super(`Audio format "${format}" cannot be safely concatenated; container re-multiplexing is required.`);
+    this.kind = "unsupported-format-error";
     this.name = "UnsupportedMergeFormatError";
     this.format = format;
   }
 };
+function toSynthesisError(error) {
+  if (error instanceof AzureTtsError || error instanceof MergeError || error instanceof AudioFormatMismatchError || error instanceof UnsupportedMergeFormatError || error instanceof SynthesisCancelledError || error instanceof SynthesisTimeoutError)
+    return error;
+  const message = error instanceof Error ? error.message : String(error);
+  if (/cancel|abort/i.test(message)) return new SynthesisCancelledError(message);
+  if (/tim(?:e|ed) ?out/i.test(message)) return new SynthesisTimeoutError(message);
+  return createSpeechSdkError(error);
+}
 function createSpeechSdkError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return new AzureTtsSdkError(message);
@@ -88,9 +135,7 @@ function createSpeechSdkError(error) {
 
 // src/synthesis.ts
 var SpeechSDK2 = __toESM(require("microsoft-cognitiveservices-speech-sdk"));
-
-// src/speechConfig.ts
-var import_microsoft_cognitiveservices_speech_sdk = require("microsoft-cognitiveservices-speech-sdk");
+var import_ssml_core = require("@ssml-builder-js/ssml-core");
 
 // src/outputFormats.ts
 var SpeechSDK = __toESM(require("microsoft-cognitiveservices-speech-sdk"));
@@ -136,6 +181,14 @@ var OUTPUT_FORMATS = {
   "amr-wb-16000hz": SpeechSDK.SpeechSynthesisOutputFormat.AmrWb16000Hz,
   "g722-16khz-64kbps": SpeechSDK.SpeechSynthesisOutputFormat.G72216Khz64Kbps
 };
+function resolveMimeType(outputFormat) {
+  if (/(?:wav|wave|riff)/i.test(outputFormat)) return "audio/wav";
+  if (/(?:mp3|mpeg)/i.test(outputFormat)) return "audio/mpeg";
+  if (/ogg/i.test(outputFormat)) return "audio/ogg";
+  if (/webm/i.test(outputFormat)) return "audio/webm";
+  if (/raw/i.test(outputFormat)) return "audio/L16";
+  return "application/octet-stream";
+}
 function resolveOutputFormat(outputFormat) {
   const resolvedFormat = OUTPUT_FORMATS[outputFormat];
   if (resolvedFormat === void 0) {
@@ -145,6 +198,7 @@ function resolveOutputFormat(outputFormat) {
 }
 
 // src/speechConfig.ts
+var import_microsoft_cognitiveservices_speech_sdk = require("microsoft-cognitiveservices-speech-sdk");
 function resolveEndpoint(config) {
   const endpoint = config.endpoint?.trim() || "https://{region}.tts.speech.microsoft.com/cognitiveservices/v1";
   return endpoint.replace(/\{region\}/g, encodeURIComponent(config.region));
@@ -197,6 +251,105 @@ function parseWav(buffer) {
   }
   return { chunks, data, format };
 }
+function formatNumber(format, pattern, fallback) {
+  const match = pattern.exec(format);
+  return match?.[1] ? Number(match[1]) : fallback;
+}
+function formatChannels(format, fallback) {
+  if (/stereo|2ch|dual/i.test(format)) return 2;
+  if (/mono|1ch/i.test(format)) return 1;
+  return fallback;
+}
+function formatAudioSpecification(format) {
+  const sampleRate = formatNumber(format, /(\d+)(?:khz|kHz|hz|Hz)/, 0);
+  const channels = formatChannels(format, 0);
+  const bitrateMatch = /(\d+)(?:kbitrate|kbps|kbits?)/i.exec(format);
+  const bitrate = bitrateMatch?.[1] ? Number(bitrateMatch[1]) * 1e3 : void 0;
+  const codec = /mp3|mpeg/i.test(format) ? "mp3" : /opus/i.test(format) ? "opus" : /silk/i.test(format) ? "silk" : /pcm|mulaw|alaw|siren/i.test(format) ? "pcm" : "unknown";
+  return {
+    format,
+    mimeType: resolveMimeType(format),
+    codec,
+    sampleRate,
+    channels,
+    ...bitrate ? { bitrate } : {},
+    isCompressed: codec === "mp3" || codec === "opus" || codec === "silk"
+  };
+}
+function parseMp3Specification(buffer, format) {
+  const bytes = stripMp3Tags(buffer);
+  const bitrates = [
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0],
+    [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0]
+  ];
+  const sampleRates = [
+    [44100, 48e3, 32e3],
+    [22050, 24e3, 16e3],
+    [11025, 12e3, 8e3]
+  ];
+  for (let index = 0; index + 4 <= bytes.length; index += 1) {
+    if (bytes[index] !== 255 || (bytes[index + 1] ?? 0) < 224) continue;
+    const header = bytes[index + 1] ?? 0;
+    const versionBits = header >> 3 & 3;
+    const layer = header >> 1 & 3;
+    const bitrateIndex = (bytes[index + 2] ?? 0) >> 4;
+    const sampleIndex = (bytes[index + 2] ?? 0) >> 2 & 3;
+    if (versionBits === 1 || layer !== 1 || bitrateIndex === 0 || bitrateIndex === 15 || sampleIndex === 3) continue;
+    const versionIndex = versionBits === 3 ? 0 : versionBits === 2 ? 1 : 2;
+    const bitrateTable = versionBits === 3 ? bitrates[1] : bitrates[2];
+    const sampleRate = sampleRates[versionIndex]?.[sampleIndex] ?? 0;
+    const bitrateKbps = bitrateTable?.[bitrateIndex] ?? 0;
+    if (!sampleRate || !bitrateKbps) continue;
+    return {
+      format,
+      mimeType: "audio/mpeg",
+      codec: "mp3",
+      sampleRate,
+      channels: (bytes[index + 3] ?? 0) >> 6 === 3 ? 1 : 2,
+      bitrate: bitrateKbps * 1e3,
+      isCompressed: true
+    };
+  }
+  return void 0;
+}
+function inspectAudioSpecification(buffer, format) {
+  if (isWavFormat(format) || ascii(new Uint8Array(buffer), 0, "RIFF")) {
+    const parsed = parseWav(buffer);
+    if (parsed.format.byteLength < 16) throw new Error("Invalid WAV fmt chunk.");
+    const view = new DataView(parsed.format.buffer, parsed.format.byteOffset, parsed.format.byteLength);
+    const sampleRate = view.getUint32(4, true);
+    const channels = view.getUint16(2, true);
+    const bitsPerSample = parsed.format.byteLength >= 16 ? view.getUint16(14, true) : 0;
+    const formatCode = view.getUint16(0, true);
+    return {
+      format,
+      mimeType: "audio/wav",
+      codec: formatCode === 1 ? "pcm" : "unknown",
+      sampleRate,
+      channels,
+      ...sampleRate && channels && bitsPerSample ? { bitrate: sampleRate * channels * bitsPerSample } : {},
+      isCompressed: formatCode !== 1
+    };
+  }
+  if (isMp3Format(format)) return parseMp3Specification(buffer, format) ?? formatAudioSpecification(format);
+  return formatAudioSpecification(format);
+}
+function validateAudioSpecifications(specs) {
+  const first = specs[0];
+  if (!first) return;
+  const mismatch = specs.find(
+    (spec) => spec.sampleRate !== first.sampleRate || spec.channels !== first.channels || first.bitrate !== void 0 && spec.bitrate !== void 0 && spec.bitrate !== first.bitrate
+  );
+  if (mismatch)
+    throw new AudioFormatMismatchError(
+      `Audio chunks have incompatible specifications: ${first.sampleRate}Hz/${first.channels}ch versus ${mismatch.sampleRate}Hz/${mismatch.channels}ch.`,
+      specs
+    );
+}
+function isAudioFormatMismatch(error) {
+  return error instanceof AudioFormatMismatchError || error !== null && typeof error === "object" && "kind" in error && error.kind === "audio-format-mismatch";
+}
 function writeUint32(target, offset, value) {
   new DataView(target.buffer).setUint32(offset, value, true);
 }
@@ -278,28 +431,37 @@ function resolveMergeAudioFormat(format) {
 function canMergeAudioFormat(format) {
   return resolveMergeAudioFormat(format) !== void 0;
 }
-function mergeAudioBuffers(buffers, format) {
-  if (isWavFormat(format)) return mergeWavBuffers(buffers);
-  if (isMp3Format(format)) {
-    const parts = buffers.map(stripMp3Tags);
-    const output = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
-    let offset = 0;
-    for (const part of parts) {
-      output.set(part, offset);
-      offset += part.byteLength;
+function mergeAudioBuffers(buffers, options) {
+  const format = typeof options === "string" ? options : options?.format;
+  if (!format) throw new UnsupportedMergeFormatError("");
+  try {
+    validateAudioSpecifications(buffers.map((buffer) => inspectAudioSpecification(buffer, format)));
+    if (isWavFormat(format)) return mergeWavBuffers(buffers);
+    if (isMp3Format(format)) {
+      const parts = buffers.map(stripMp3Tags);
+      const output = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
+      let offset = 0;
+      for (const part of parts) {
+        output.set(part, offset);
+        offset += part.byteLength;
+      }
+      return output.buffer;
     }
-    return output.buffer;
-  }
-  if (isRawFormat(format)) {
-    const output = new Uint8Array(buffers.reduce((total, buffer) => total + buffer.byteLength, 0));
-    let offset = 0;
-    for (const buffer of buffers) {
-      output.set(new Uint8Array(buffer), offset);
-      offset += buffer.byteLength;
+    if (isRawFormat(format)) {
+      const output = new Uint8Array(buffers.reduce((total, buffer) => total + buffer.byteLength, 0));
+      let offset = 0;
+      for (const buffer of buffers) {
+        output.set(new Uint8Array(buffer), offset);
+        offset += buffer.byteLength;
+      }
+      return output.buffer;
     }
-    return output.buffer;
+    throw new UnsupportedMergeFormatError(format);
+  } catch (error) {
+    if (error instanceof UnsupportedMergeFormatError || isAudioFormatMismatch(error) || error instanceof MergeError)
+      throw error;
+    throw new MergeError(`Audio buffers could not be merged for format "${format}".`, error);
   }
-  throw new UnsupportedMergeFormatError(format);
 }
 function closeSpeechResources(speechConfig, synthesizer) {
   try {
@@ -314,7 +476,7 @@ function closeSpeechResources(speechConfig, synthesizer) {
 var ticksToMilliseconds = (ticks) => Math.max(0, ticks) / 1e4;
 async function synthesizeSsml(ssml, config) {
   if (config.signal?.aborted) {
-    throw createSpeechSdkError("Speech synthesis was cancelled.");
+    throw new SynthesisCancelledError();
   }
   const speechConfig = createSpeechConfig(config);
   const synthesizer = new SpeechSDK2.SpeechSynthesizer(speechConfig, null);
@@ -337,23 +499,104 @@ async function synthesizeSsml(ssml, config) {
       settled = true;
       cleanup();
       closeResources();
-      reject(createSpeechSdkError(error));
+      reject(toSynthesisError(error));
     };
     const boundaries = [];
     const visemes = [];
     const bookmarks = [];
+    let sourceEventCursor = 0;
+    let generatedSourceMap;
+    if (!config.sourceTextSegments && !config.sourceMarkers) {
+      try {
+        generatedSourceMap = (0, import_ssml_core.getSsmlSourceMap)(ssml);
+      } catch {
+        generatedSourceMap = void 0;
+      }
+    }
+    const sourceBaseOffset = config.sourceTextRange?.start ?? 0;
+    const sourceSegments = config.sourceTextSegments ?? generatedSourceMap?.segments.map((segment) => ({
+      ...segment,
+      range: {
+        start: segment.range.start + sourceBaseOffset,
+        end: segment.range.end + sourceBaseOffset
+      },
+      sourceNodePath: [...segment.sourceNodePath]
+    })) ?? [];
+    const sourceMarkers = config.sourceMarkers ?? generatedSourceMap?.markers.map((marker) => ({
+      ...marker,
+      originalTextRange: {
+        start: marker.originalTextRange.start + sourceBaseOffset,
+        end: marker.originalTextRange.end + sourceBaseOffset
+      },
+      sourceNodePath: [...marker.sourceNodePath]
+    })) ?? [];
+    const sourceText = sourceSegments.map((segment) => segment.text).join("");
+    const mapSourceEvent = (text, offsetHint, markerName) => {
+      const marker = markerName ? sourceMarkers.find((candidate) => candidate.name === markerName) : void 0;
+      if (marker) {
+        return {
+          originalTextRange: { ...marker.originalTextRange },
+          sourceNodePath: [...marker.sourceNodePath],
+          textRange: { ...marker.originalTextRange },
+          mappingStatus: "exact"
+        };
+      }
+      if (sourceSegments.length === 0 && !config.sourceTextRange && !config.sourceNodePath) {
+        const unmapped = { mappingStatus: "unmapped" };
+        Object.defineProperty(unmapped, "mappingStatus", { value: "unmapped", enumerable: false });
+        return unmapped;
+      }
+      const value = text ?? "";
+      let localStart = Number.isFinite(offsetHint) && (offsetHint ?? 0) >= 0 ? offsetHint : -1;
+      let mappingStatus = "exact";
+      if (value && localStart >= 0 && sourceText.slice(localStart, localStart + value.length) !== value) {
+        localStart = -1;
+        mappingStatus = "fallback";
+      }
+      if (localStart < 0 || localStart > sourceText.length) {
+        localStart = value ? sourceText.indexOf(value, sourceEventCursor) : sourceEventCursor;
+        if (localStart < 0) localStart = value ? sourceText.indexOf(value) : sourceEventCursor;
+        mappingStatus = "fallback";
+      }
+      localStart = Math.max(0, localStart);
+      const localEnd = Math.min(sourceText.length, localStart + value.length);
+      sourceEventCursor = Math.max(sourceEventCursor, localEnd);
+      const baseStart = config.sourceTextRange?.start ?? sourceSegments[0]?.range.start ?? 0;
+      const fallbackRange = { start: baseStart + localStart, end: baseStart + localEnd };
+      const segment = sourceSegments.find(({ range }) => range.start <= fallbackRange.start && range.end > fallbackRange.start) ?? sourceSegments.find(({ range }) => range.end > fallbackRange.start) ?? (value.length === 0 ? sourceSegments.find(({ range }) => range.start <= fallbackRange.start && range.end >= fallbackRange.start) : void 0);
+      return {
+        originalTextRange: { ...fallbackRange },
+        textRange: { ...fallbackRange },
+        ...segment ? { sourceNodePath: [...segment.sourceNodePath] } : config.sourceNodePath ? { sourceNodePath: [...config.sourceNodePath] } : {},
+        mappingStatus: segment || config.sourceTextRange || config.sourceNodePath ? mappingStatus : "unmapped"
+      };
+    };
     synthesizer.wordBoundary = (_sender, event) => {
       boundaries.push({
         text: event.text,
         audioOffsetMs: ticksToMilliseconds(event.audioOffset),
-        durationMs: ticksToMilliseconds(event.duration)
+        durationMs: ticksToMilliseconds(event.duration),
+        ...mapSourceEvent(
+          event.text,
+          event.textOffset
+        )
       });
     };
     synthesizer.visemeReceived = (_sender, event) => {
-      visemes.push({ visemeId: event.visemeId, audioOffsetMs: ticksToMilliseconds(event.audioOffset) });
+      const eventWithOffset = event;
+      visemes.push({
+        visemeId: event.visemeId,
+        audioOffsetMs: ticksToMilliseconds(event.audioOffset),
+        ...mapSourceEvent(void 0, eventWithOffset.textOffset)
+      });
     };
     synthesizer.bookmarkReached = (_sender, event) => {
-      bookmarks.push({ name: event.text, audioOffsetMs: ticksToMilliseconds(event.audioOffset) });
+      const eventWithOffset = event;
+      bookmarks.push({
+        name: event.text,
+        audioOffsetMs: ticksToMilliseconds(event.audioOffset),
+        ...mapSourceEvent(void 0, eventWithOffset.textOffset, event.text)
+      });
     };
     const cb = (result) => {
       if (settled) return;
@@ -374,20 +617,27 @@ async function synthesizeSsml(ssml, config) {
       );
       const durationMs = result.audioDuration ? ticksToMilliseconds(result.audioDuration) : eventDurationMs;
       const requestId = result.resultId;
-      const addSourceMetadata = (event) => ({
-        ...event,
-        ...config.sourceTextRange ? { textRange: { ...config.sourceTextRange } } : {},
-        ...config.sourceTextRange ? { originalTextRange: { ...config.sourceTextRange } } : {},
-        ...config.chunkIndex !== void 0 ? { chunkIndex: config.chunkIndex } : {},
-        ...config.sourceNodePath ? { sourceNodePath: [...config.sourceNodePath] } : {},
-        ...requestId ? { requestId } : {}
-      });
+      const addSourceMetadata = (event) => {
+        const mapped = {
+          ...event,
+          ...config.sourceTextRange && !("textRange" in event) ? { textRange: { ...config.sourceTextRange } } : {},
+          ...config.sourceTextRange && !("originalTextRange" in event) ? { originalTextRange: { ...config.sourceTextRange } } : {},
+          ...config.chunkIndex !== void 0 ? { chunkIndex: config.chunkIndex } : {},
+          ...config.sourceNodePath ? { sourceNodePath: [...config.sourceNodePath] } : {},
+          ...requestId ? { requestId } : {}
+        };
+        if (event.mappingStatus === "unmapped")
+          Object.defineProperty(mapped, "mappingStatus", { value: "unmapped", enumerable: false });
+        return mapped;
+      };
       const sourceBoundaries = boundaries.map((boundary) => addSourceMetadata(boundary));
       const sourceVisemes = visemes.map((viseme) => addSourceMetadata(viseme));
       const sourceBookmarks = bookmarks.map((bookmark) => addSourceMetadata(bookmark));
       resolve({
         audioData: result.audioData,
         durationMs,
+        audioSpec: inspectAudioSpecification(result.audioData, config.outputFormat ?? DEFAULT_OUTPUT_FORMAT),
+        mimeType: resolveMimeType(config.outputFormat ?? DEFAULT_OUTPUT_FORMAT),
         ...config.sourceTextRange ? { textRange: { ...config.sourceTextRange } } : {},
         ...requestId ? { requestId } : {},
         ...sourceBoundaries.length > 0 ? { boundaries: sourceBoundaries, wordBoundary: sourceBoundaries, wordBoundaries: sourceBoundaries } : {},
@@ -397,12 +647,12 @@ async function synthesizeSsml(ssml, config) {
     };
     try {
       if (config.signal) {
-        abortHandler = () => rejectWithError("Speech synthesis was cancelled.");
+        abortHandler = () => rejectWithError(new SynthesisCancelledError());
         config.signal.addEventListener("abort", abortHandler, { once: true });
       }
       if (config.timeoutMs !== void 0 && config.timeoutMs > 0) {
         timeout = setTimeout(
-          () => rejectWithError(`Speech synthesis timed out after ${config.timeoutMs} ms.`),
+          () => rejectWithError(new SynthesisTimeoutError(`Speech synthesis timed out after ${config.timeoutMs} ms.`)),
           config.timeoutMs
         );
       }
@@ -412,8 +662,66 @@ async function synthesizeSsml(ssml, config) {
     }
   });
 }
+function isRetryableSynthesisError(error) {
+  if (error instanceof SynthesisCancelledError || error instanceof SynthesisTimeoutError) return false;
+  if (error instanceof AzureTtsError && error.status !== 0)
+    return error.status === 429 || error.status >= 500 && error.status < 600;
+  const message = error instanceof Error ? error.message : String(error);
+  if (/\b4\d{2}\b/.test(message)) return false;
+  const status = error && typeof error === "object" && "status" in error ? error.status : void 0;
+  if (typeof status === "number") return status === 429 || status >= 500 && status < 600;
+  return /network|connection|connect|socket|fetch failed|econn|etimedout|temporar|transient|unavailable/i.test(message);
+}
+function retryDelay(options, retryAttempt) {
+  const base = Math.min(options.maxDelayMs, options.initialDelayMs * 2 ** Math.max(0, retryAttempt - 1));
+  return Math.floor(Math.random() * (base + 1));
+}
+function resolveConcurrency(value, total) {
+  if (value === void 0) return 1;
+  if (value === Infinity) return Math.max(1, total);
+  return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : 1;
+}
+async function waitForRetry(delayMs, signal) {
+  if (signal?.aborted) throw new SynthesisCancelledError();
+  if (delayMs <= 0) return;
+  await new Promise((resolve, reject) => {
+    let timer;
+    const abort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      reject(new SynthesisCancelledError());
+    };
+    timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, delayMs);
+    if (signal) {
+      signal.addEventListener("abort", abort, { once: true });
+    }
+  });
+}
+async function synthesizeWithRetry(ssml, config, retryOptions, onRetry) {
+  const options = retryOptions ? {
+    maxRetries: Math.max(0, Math.floor(retryOptions.maxRetries)),
+    initialDelayMs: Math.max(0, retryOptions.initialDelayMs),
+    maxDelayMs: Math.max(0, retryOptions.maxDelayMs)
+  } : void 0;
+  let attempt = 0;
+  while (true) {
+    if (config.signal?.aborted) throw new SynthesisCancelledError();
+    try {
+      return await synthesizeSsml(ssml, config);
+    } catch (error) {
+      if (!options || attempt >= options.maxRetries || !isRetryableSynthesisError(error)) throw error;
+      attempt += 1;
+      const delayMs = retryDelay(options, attempt);
+      onRetry(attempt, delayMs);
+      await waitForRetry(delayMs, config.signal);
+    }
+  }
+}
 async function synthesizeSsmlChunks(chunks, config) {
-  const results = [];
+  const results = new Array(chunks.length);
   const totalChunks = chunks.length;
   const report = (event) => config.onProgress?.(event);
   for (const [index, chunk] of chunks.entries()) {
@@ -428,71 +736,90 @@ async function synthesizeSsmlChunks(chunks, config) {
       durationMs: 0
     });
   }
-  for (const [index, chunk] of chunks.entries()) {
-    const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
-    report({
-      currentChunk: index,
-      totalChunks,
-      percent: totalChunks === 0 ? 100 : Math.round(index / totalChunks * 100),
-      chunkIndex: index,
-      originalTextRange: input.originalTextRange,
-      status: "synthesizing",
-      durationMs: 0
-    });
-    const startedAt = Date.now();
-    try {
-      const result = await synthesizeSsml(input.ssml, {
-        ...config,
-        ...input.originalTextRange ? { sourceTextRange: input.originalTextRange } : {},
-        ...input.sourceNodePath ? { sourceNodePath: input.sourceNodePath } : {},
-        chunkIndex: index,
-        onProgress: void 0
-      });
-      results.push(result);
-      report({
-        currentChunk: index + 1,
-        totalChunks,
-        percent: totalChunks === 0 ? 100 : Math.round((index + 1) / totalChunks * 100),
-        chunkIndex: index,
-        originalTextRange: input.originalTextRange,
-        status: "success",
-        durationMs: Date.now() - startedAt
-      });
-    } catch (error) {
+  let completed = 0;
+  let nextIndex = 0;
+  const concurrency = resolveConcurrency(config.concurrency, chunks.length);
+  const worker = async () => {
+    while (true) {
+      const index = nextIndex++;
+      if (index >= chunks.length) return;
+      const chunk = chunks[index];
+      const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
       report({
-        currentChunk: index,
+        currentChunk: completed,
         totalChunks,
-        percent: totalChunks === 0 ? 100 : Math.round(index / totalChunks * 100),
+        percent: totalChunks === 0 ? 100 : Math.round(completed / totalChunks * 100),
         chunkIndex: index,
         originalTextRange: input.originalTextRange,
-        status: "failed",
-        durationMs: Date.now() - startedAt,
-        error
+        status: "synthesizing",
+        durationMs: 0
       });
-      throw error;
-    }
-  }
-  return mergeSynthesisResults(results, config.outputFormat ?? "audio-16khz-128kbitrate-mono-mp3");
-}
-function mergeSynthesisResults(results, format) {
-  const audioData = format ? new Uint8Array(
-    mergeAudioBuffers(
-      results.map((result) => result.audioData),
-      format
-    )
-  ) : new Uint8Array(results.reduce((total, result) => total + result.audioData.byteLength, 0));
-  if (!format) {
-    let offset = 0;
-    for (const result of results) {
-      audioData.set(new Uint8Array(result.audioData), offset);
-      offset += result.audioData.byteLength;
+      const startedAt = Date.now();
+      try {
+        const result = await synthesizeWithRetry(
+          input.ssml,
+          {
+            ...config,
+            ...input.originalTextRange ? { sourceTextRange: input.originalTextRange } : {},
+            ...input.sourceNodePath ?? config.sourceNodePath ? { sourceNodePath: [...input.sourceNodePath ?? config.sourceNodePath ?? []] } : {},
+            ...input.sourceTextSegments ? { sourceTextSegments: input.sourceTextSegments } : {},
+            ...input.sourceMarkers ? { sourceMarkers: input.sourceMarkers } : {},
+            chunkIndex: index,
+            onProgress: void 0
+          },
+          config.retryOptions,
+          (retryAttempt, nextRetryDelayMs) => report({
+            currentChunk: completed,
+            totalChunks,
+            percent: totalChunks === 0 ? 100 : Math.round(completed / totalChunks * 100),
+            chunkIndex: index,
+            originalTextRange: input.originalTextRange,
+            status: "synthesizing",
+            durationMs: Date.now() - startedAt,
+            retryAttempt,
+            nextRetryDelayMs,
+            isRetrying: true
+          })
+        );
+        results[index] = result;
+        completed += 1;
+        report({
+          currentChunk: completed,
+          totalChunks,
+          percent: totalChunks === 0 ? 100 : Math.round(completed / totalChunks * 100),
+          chunkIndex: index,
+          originalTextRange: input.originalTextRange,
+          status: "success",
+          durationMs: Date.now() - startedAt
+        });
+      } catch (error) {
+        report({
+          currentChunk: completed,
+          totalChunks,
+          percent: totalChunks === 0 ? 100 : Math.round(completed / totalChunks * 100),
+          chunkIndex: index,
+          originalTextRange: input.originalTextRange,
+          status: "failed",
+          durationMs: Date.now() - startedAt,
+          error
+        });
+        throw error;
+      }
     }
-  }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, chunks.length) }, () => worker()));
+  const orderedResults = results.filter((result) => result !== void 0);
+  return mergeSynthesisResults(orderedResults, {
+    format: config.outputFormat ?? DEFAULT_OUTPUT_FORMAT,
+    signal: config.signal
+  });
+}
+function createMergedResult(results, audioData, format, audioSpec, outputMimeType) {
   const boundaries = [];
   const visemes = [];
   const bookmarks = [];
   let durationOffset = 0;
-  for (const result of results) {
+  for (const [resultIndex, result] of results.entries()) {
     const chunkBoundaries = result.boundaries && result.boundaries.length > 0 ? result.boundaries : result.wordBoundary ?? result.wordBoundaries ?? [];
     for (const boundary of chunkBoundaries) {
       const textRange = boundary.textRange ?? result.textRange;
@@ -502,11 +829,12 @@ function mergeSynthesisResults(results, format) {
         ...boundary,
         audioOffsetMs: boundary.audioOffsetMs + durationOffset,
         chunkAudioOffsetMs: boundary.chunkAudioOffsetMs ?? boundary.audioOffsetMs,
-        ...boundary.chunkIndex === void 0 ? { chunkIndex: results.indexOf(result) } : {},
+        ...boundary.chunkIndex === void 0 ? { chunkIndex: resultIndex } : {},
         ...boundary.sourceNodePath ? { sourceNodePath: [...boundary.sourceNodePath] } : {},
         ...originalTextRange ? { originalTextRange: { ...originalTextRange } } : {},
         ...textRange ? { textRange: { ...textRange } } : {},
-        ...requestId ? { requestId } : {}
+        ...requestId ? { requestId } : {},
+        mappingStatus: boundary.mappingStatus ?? "unmapped"
       });
     }
     for (const viseme of result.visemes ?? []) {
@@ -517,11 +845,12 @@ function mergeSynthesisResults(results, format) {
         ...viseme,
         audioOffsetMs: viseme.audioOffsetMs + durationOffset,
         chunkAudioOffsetMs: viseme.chunkAudioOffsetMs ?? viseme.audioOffsetMs,
-        ...viseme.chunkIndex === void 0 ? { chunkIndex: results.indexOf(result) } : {},
+        ...viseme.chunkIndex === void 0 ? { chunkIndex: resultIndex } : {},
         ...viseme.sourceNodePath ? { sourceNodePath: [...viseme.sourceNodePath] } : {},
         ...originalTextRange ? { originalTextRange: { ...originalTextRange } } : {},
         ...textRange ? { textRange: { ...textRange } } : {},
-        ...requestId ? { requestId } : {}
+        ...requestId ? { requestId } : {},
+        mappingStatus: viseme.mappingStatus ?? "unmapped"
       });
     }
     for (const bookmark of result.bookmarks ?? []) {
@@ -532,18 +861,22 @@ function mergeSynthesisResults(results, format) {
         ...bookmark,
         audioOffsetMs: bookmark.audioOffsetMs + durationOffset,
         chunkAudioOffsetMs: bookmark.chunkAudioOffsetMs ?? bookmark.audioOffsetMs,
-        ...bookmark.chunkIndex === void 0 ? { chunkIndex: results.indexOf(result) } : {},
+        ...bookmark.chunkIndex === void 0 ? { chunkIndex: resultIndex } : {},
         ...bookmark.sourceNodePath ? { sourceNodePath: [...bookmark.sourceNodePath] } : {},
         ...originalTextRange ? { originalTextRange: { ...originalTextRange } } : {},
         ...textRange ? { textRange: { ...textRange } } : {},
-        ...requestId ? { requestId } : {}
+        ...requestId ? { requestId } : {},
+        mappingStatus: bookmark.mappingStatus ?? "unmapped"
       });
     }
     durationOffset += Math.max(0, result.durationMs);
   }
   return {
-    audioData: audioData.buffer,
+    audioData,
     durationMs: durationOffset,
+    mimeType: resolveMimeType(format),
+    audioSpec: audioSpec ?? formatAudioSpecification(format),
+    ...outputMimeType ? { mimeType: outputMimeType } : {},
     ...boundaries.length > 0 ? { boundaries, wordBoundary: boundaries, wordBoundaries: boundaries } : {},
     ...visemes.length > 0 ? { visemes } : {},
     ...bookmarks.length > 0 ? { bookmarks } : {},
@@ -551,46 +884,171 @@ function mergeSynthesisResults(results, format) {
     ...results.length === 1 && results[0]?.textRange ? { textRange: { ...results[0].textRange } } : {}
   };
 }
+function mergeSynthesisResults(results, options) {
+  const resolvedOptions = typeof options === "string" ? { format: options } : options;
+  const format = resolvedOptions?.format;
+  if (!format) throw new UnsupportedMergeFormatError("");
+  const buffers = results.map((result) => result.audioData);
+  const inputSpecs = results.map((result) => result.audioSpec ?? inspectAudioSpecification(result.audioData, format));
+  validateAudioSpecifications(inputSpecs);
+  const signal = resolvedOptions.signal ?? new AbortController().signal;
+  if (signal.aborted) throw new SynthesisCancelledError();
+  if (resolvedOptions.customMerger) {
+    return Promise.resolve().then(
+      () => resolvedOptions.customMerger?.(buffers, {
+        format,
+        outputMimeType: resolvedOptions.outputMimeType ?? resolveMimeType(format),
+        inputSpecs,
+        signal
+      })
+    ).then((merged) => {
+      if (!merged) throw new MergeError("The custom audio merger returned no audio buffer.");
+      if (!(merged instanceof ArrayBuffer) || buffers.some((buffer) => buffer.byteLength > 0) && merged.byteLength === 0)
+        throw new MergeError("The custom audio merger returned an invalid audio buffer.");
+      if (signal.aborted) throw new SynthesisCancelledError();
+      return createMergedResult(
+        results,
+        merged,
+        format,
+        inspectAudioSpecification(merged, format),
+        resolvedOptions.outputMimeType
+      );
+    }).catch((error) => {
+      if (error instanceof UnsupportedMergeFormatError || isAudioFormatMismatch(error) || error instanceof MergeError)
+        throw error;
+      throw new MergeError(`Custom audio merger failed for format "${format}".`, error);
+    });
+  }
+  try {
+    return createMergedResult(
+      results,
+      mergeAudioBuffers(buffers, { format }),
+      format,
+      inputSpecs[0],
+      resolvedOptions.outputMimeType
+    );
+  } catch (error) {
+    if (error instanceof UnsupportedMergeFormatError || isAudioFormatMismatch(error) || error instanceof MergeError)
+      throw error;
+    throw new MergeError(`Audio buffers could not be merged for format "${format}".`, error);
+  }
+}
 async function synthesizeSpeech(ssml, config) {
   return (await synthesizeSsml(ssml, config)).audioData;
 }
 
 // src/safe.ts
-var import_ssml_core = require("@ssml-builder-js/ssml-core");
+var import_ssml_core2 = require("@ssml-builder-js/ssml-core");
 var ChunkValidationError = class extends Error {
   constructor(chunkIndex, diagnostics) {
     super(`SSML validation failed for chunk ${chunkIndex}; the Azure Speech API was not called.`);
-    this.kind = "chunk-validation";
+    this.kind = "validation-error";
     this.name = "ChunkValidationError";
     this.chunkIndex = chunkIndex;
     this.diagnostics = diagnostics;
   }
 };
+function failure(error) {
+  return { ok: false, success: false, status: error.kind, error };
+}
+function isRetryable(error) {
+  if (error instanceof Error && /cancel|abort|tim(?:e|ed) ?out/i.test(error.message)) return false;
+  const status = error && typeof error === "object" && "status" in error ? error.status : void 0;
+  if (typeof status === "number" && status !== 0) return status === 429 || status >= 500 && status < 600;
+  const message = error instanceof Error ? error.message : String(error);
+  if (/\b4\d{2}\b/.test(message)) return false;
+  return /network|connection|connect|socket|fetch failed|econn|etimedout|temporar|transient|unavailable/i.test(message);
+}
+function delayForRetry(options, attempt) {
+  const maxDelay = Math.max(0, options.maxDelayMs);
+  const base = Math.min(maxDelay, Math.max(0, options.initialDelayMs) * 2 ** Math.max(0, attempt - 1));
+  return Math.floor(Math.random() * (base + 1));
+}
+function resolveConcurrency2(value, total) {
+  if (value === void 0) return 1;
+  if (value === Infinity) return Math.max(1, total);
+  return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : 1;
+}
+async function retryableSynthesis(synthesize, options, signal, onRetry) {
+  const retry = options ? {
+    maxRetries: Math.max(0, Math.floor(options.maxRetries)),
+    initialDelayMs: options.initialDelayMs,
+    maxDelayMs: options.maxDelayMs
+  } : void 0;
+  let attempt = 0;
+  while (true) {
+    if (signal?.aborted) throw new Error("Speech synthesis was cancelled.");
+    try {
+      return await synthesize();
+    } catch (error) {
+      if (!retry || attempt >= retry.maxRetries || !isRetryable(error)) throw error;
+      attempt += 1;
+      const delayMs = delayForRetry(retry, attempt);
+      onRetry(attempt, delayMs);
+      if (delayMs > 0)
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+          }, delayMs);
+          const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            reject(new Error("Speech synthesis was cancelled."));
+          };
+          signal?.addEventListener("abort", abort, { once: true });
+        });
+    }
+  }
+}
+function sharedValidationOptions(options, signal) {
+  const validator = options.urlValidator ?? options.customUrlValidator;
+  if (!validator) return signal ? withValidationSignal(options, signal) : options;
+  const runner = (0, import_ssml_core2.createAzureUrlValidatorRunner)(validator, {
+    ...options.urlValidation ?? {},
+    ...options.urlValidatorConcurrency !== void 0 ? { concurrency: options.urlValidatorConcurrency } : {},
+    ...options.urlValidatorTimeoutMs !== void 0 ? { timeoutMs: options.urlValidatorTimeoutMs } : {},
+    ...signal ? { signal } : {},
+    ...options.urlValidatorCache ? { cache: options.urlValidatorCache } : {}
+  });
+  return {
+    ...withValidationSignal(options, signal),
+    urlValidatorRunner: runner
+  };
+}
 async function synthesizeSsmlSafe(client, ssml, options = {}) {
-  const validationOptions = options.validation ?? options;
-  const diagnostics = await Promise.resolve((0, import_ssml_core.validateAzureSsml)(ssml, validationOptions));
+  const validationOptions = sharedValidationOptions(options.validation ?? options, options.signal);
+  const diagnostics = await Promise.resolve((0, import_ssml_core2.validateAzureSsml)(ssml, validationOptions));
+  if (options.signal?.aborted) {
+    const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+    return failure(error);
+  }
   const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
   if (errors.length > 0) {
-    return {
-      ok: false,
-      success: false,
-      status: "validation-error",
-      error: {
-        kind: "validation",
-        message: "SSML validation failed; the Azure Speech API was not called.",
-        diagnostics: errors
-      }
-    };
+    return failure({
+      kind: "validation-error",
+      message: "SSML validation failed; the Azure Speech API was not called.",
+      diagnostics: errors
+    });
   }
   try {
-    return { ok: true, success: true, status: "success", value: await client.synthesizeSsml(ssml) };
+    return {
+      ok: true,
+      success: true,
+      status: "success",
+      value: await client.synthesizeSsml(ssml, { signal: options.signal })
+    };
   } catch (error) {
-    const azureError = error instanceof AzureTtsError ? error : createSpeechSdkError(error);
-    return { ok: false, success: false, status: "azure-api-error", error: azureError };
+    const synthesisError = toSynthesisError(error);
+    return failure(synthesisError);
   }
 }
 async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
-  const validationOptions = options.validation ?? options;
+  const validationOptions = sharedValidationOptions(options.validation ?? options, options.signal);
+  if (options.signal?.aborted) {
+    const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+    return failure(error);
+  }
   const pending = (index, status, error) => {
     options.onProgress?.({
       currentChunk: status === "success" ? index + 1 : index,
@@ -607,77 +1065,175 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
     pending(index, "pending");
   });
   const validations = await Promise.all(
-    chunks.map(async (chunk) => {
+    chunks.map(async (chunk, index) => {
       const ssml = typeof chunk === "string" ? chunk : chunk.ssml;
-      const diagnostics = await Promise.resolve((0, import_ssml_core.validateAzureSsml)(ssml, validationOptions));
+      const sourceNodePath = typeof chunk === "string" ? options.sourceNodePath : chunk.sourceNodePath ?? options.sourceNodePath;
+      const diagnostics = await Promise.resolve(
+        (0, import_ssml_core2.validateAzureSsml)(ssml, {
+          ...validationOptions,
+          ...sourceNodePath ? { sourceNodePath } : {},
+          chunkIndex: index
+        })
+      );
       return diagnostics.filter((diagnostic) => diagnostic.severity === "error");
     })
   );
   const firstInvalidIndex = validations.findIndex((diagnostics) => diagnostics.length > 0);
+  if (options.signal?.aborted) {
+    const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+    return failure(error);
+  }
   if (firstInvalidIndex >= 0) {
     const error = new ChunkValidationError(firstInvalidIndex, validations[firstInvalidIndex] ?? []);
     pending(firstInvalidIndex, "failed", error);
-    return { ok: false, success: false, status: "validation-error", error };
+    return failure(error);
   }
   try {
     if (client.synthesizeChunks) {
-      const value = await client.synthesizeChunks(chunks, { onProgress: options.onProgress });
+      const normalizedChunks = chunks.map((chunk) => {
+        if (typeof chunk === "string" || chunk.sourceNodePath || !options.sourceNodePath) return chunk;
+        return { ...chunk, sourceNodePath: [...options.sourceNodePath] };
+      });
+      const value = await client.synthesizeChunks(normalizedChunks, {
+        onProgress: options.onProgress,
+        outputFormat: options.outputFormat,
+        signal: options.signal,
+        timeoutMs: options.timeoutMs,
+        sourceNodePath: options.sourceNodePath,
+        concurrency: options.concurrency,
+        retryOptions: options.retryOptions
+      });
       return { ok: true, success: true, status: "success", value };
     }
-    const results = [];
-    for (const [index, chunk] of chunks.entries()) {
-      const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
-      const sourceNodePath = input.sourceNodePath;
-      pending(index, "synthesizing");
-      const startedAt = Date.now();
-      try {
-        const result = await client.synthesizeSsml(input.ssml);
-        results.push({
-          ...result,
-          ...input.originalTextRange ? { textRange: { ...input.originalTextRange } } : {},
-          ...sourceNodePath ? {
-            boundaries: result.boundaries?.map((event) => ({
-              ...event,
-              sourceNodePath: [...sourceNodePath]
-            })),
-            visemes: result.visemes?.map((event) => ({ ...event, sourceNodePath: [...sourceNodePath] })),
-            bookmarks: result.bookmarks?.map((event) => ({ ...event, sourceNodePath: [...sourceNodePath] }))
-          } : {}
-        });
-        options.onProgress?.({
-          currentChunk: index + 1,
-          totalChunks: chunks.length,
-          percent: chunks.length === 0 ? 100 : Math.round((index + 1) / chunks.length * 100),
-          chunkIndex: index,
-          originalTextRange: input.originalTextRange,
-          status: "success",
-          durationMs: Date.now() - startedAt
-        });
-      } catch (error) {
-        options.onProgress?.({
-          currentChunk: index,
-          totalChunks: chunks.length,
-          percent: chunks.length === 0 ? 100 : Math.round(index / chunks.length * 100),
-          chunkIndex: index,
-          originalTextRange: input.originalTextRange,
-          status: "failed",
-          durationMs: Date.now() - startedAt,
-          error
-        });
-        throw error;
+    const results = new Array(chunks.length);
+    let completed = 0;
+    let nextIndex = 0;
+    const concurrency = resolveConcurrency2(options.concurrency, chunks.length);
+    const worker = async () => {
+      while (true) {
+        const index = nextIndex++;
+        if (index >= chunks.length) return;
+        const chunk = chunks[index];
+        const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
+        const sourceNodePath = input.sourceNodePath;
+        const originalTextRange = input.originalTextRange;
+        pending(index, "synthesizing");
+        const startedAt = Date.now();
+        try {
+          const result = await retryableSynthesis(
+            () => client.synthesizeSsml(input.ssml, {
+              outputFormat: options.outputFormat,
+              signal: options.signal,
+              timeoutMs: options.timeoutMs,
+              sourceNodePath: input.sourceNodePath ?? options.sourceNodePath
+            }),
+            options.retryOptions,
+            options.signal,
+            (retryAttempt, nextRetryDelayMs) => options.onProgress?.({
+              currentChunk: completed,
+              totalChunks: chunks.length,
+              percent: chunks.length === 0 ? 100 : Math.round(completed / chunks.length * 100),
+              chunkIndex: index,
+              originalTextRange: input.originalTextRange,
+              status: "synthesizing",
+              durationMs: Date.now() - startedAt,
+              retryAttempt,
+              nextRetryDelayMs,
+              isRetrying: true
+            })
+          );
+          results[index] = {
+            ...result,
+            ...input.originalTextRange ? { textRange: { ...input.originalTextRange } } : {},
+            ...sourceNodePath ? {
+              boundaries: result.boundaries?.map((event) => ({
+                ...event,
+                sourceNodePath: [...sourceNodePath],
+                ...event.originalTextRange ? { originalTextRange: { ...event.originalTextRange } } : input.originalTextRange ? { originalTextRange: { ...input.originalTextRange } } : {}
+              })),
+              visemes: result.visemes?.map((event) => ({
+                ...event,
+                sourceNodePath: [...sourceNodePath],
+                ...event.originalTextRange ? { originalTextRange: { ...event.originalTextRange } } : input.originalTextRange ? { originalTextRange: { ...input.originalTextRange } } : {}
+              })),
+              bookmarks: result.bookmarks?.map((event) => ({
+                ...event,
+                sourceNodePath: [...sourceNodePath],
+                ...event.originalTextRange ? { originalTextRange: { ...event.originalTextRange } } : input.originalTextRange ? { originalTextRange: { ...input.originalTextRange } } : {}
+              }))
+            } : {},
+            ...originalTextRange ? {
+              boundaries: result.boundaries?.map((event) => ({
+                ...event,
+                originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+              })),
+              wordBoundary: result.wordBoundary?.map((event) => ({
+                ...event,
+                originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+              })),
+              wordBoundaries: result.wordBoundaries?.map((event) => ({
+                ...event,
+                originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+              })),
+              visemes: result.visemes?.map((event) => ({
+                ...event,
+                originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+              })),
+              bookmarks: result.bookmarks?.map((event) => ({
+                ...event,
+                originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+              }))
+            } : {}
+          };
+          completed += 1;
+          options.onProgress?.({
+            currentChunk: completed,
+            totalChunks: chunks.length,
+            percent: chunks.length === 0 ? 100 : Math.round(completed / chunks.length * 100),
+            chunkIndex: index,
+            originalTextRange: input.originalTextRange,
+            status: "success",
+            durationMs: Date.now() - startedAt
+          });
+        } catch (error) {
+          options.onProgress?.({
+            currentChunk: completed,
+            totalChunks: chunks.length,
+            percent: chunks.length === 0 ? 100 : Math.round(index / chunks.length * 100),
+            chunkIndex: index,
+            originalTextRange: input.originalTextRange,
+            status: "failed",
+            durationMs: Date.now() - startedAt,
+            error
+          });
+          throw error;
+        }
       }
-    }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, chunks.length) }, () => worker()));
+    const orderedResults = results.filter((result) => result !== void 0);
     return {
       ok: true,
       success: true,
       status: "success",
-      value: mergeSynthesisResults(results, options.outputFormat)
+      value: mergeSynthesisResults(orderedResults, {
+        format: options.outputFormat ?? "audio-16khz-128kbitrate-mono-mp3",
+        signal: options.signal
+      })
     };
   } catch (error) {
-    const azureError = error instanceof AzureTtsError ? error : createSpeechSdkError(error);
-    return { ok: false, success: false, status: "azure-api-error", error: azureError };
+    const synthesisError = toSynthesisError(error);
+    return failure(synthesisError);
   }
 }
+function withValidationSignal(options, signal) {
+  if (!signal) return options;
+  return {
+    ...options,
+    urlValidatorSignal: signal,
+    urlValidation: { ...options.urlValidation ?? {}, signal }
+  };
+}
 
 // src/client.ts
 var ENDPOINT_TEMPLATE = "https://{region}.tts.speech.microsoft.com/cognitiveservices/v1";
@@ -694,11 +1250,21 @@ var AzureTtsClient = class {
     const config = { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs };
     return synthesizeSpeech(ssml, config);
   }
-  async synthesizeSsml(ssml) {
+  async synthesizeSsml(ssml, options = {}) {
     const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
     const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
     __privateGet(this, _options).logger?.debug?.("Using Azure TTS endpoint:", endpoint);
-    return synthesizeSsml(ssml, { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs });
+    return synthesizeSsml(ssml, {
+      endpoint,
+      region,
+      subscriptionKey,
+      outputFormat: options.outputFormat ?? outputFormat,
+      signal: options.signal ?? signal,
+      timeoutMs: options.timeoutMs ?? timeoutMs,
+      sourceNodePath: options.sourceNodePath,
+      sourceTextSegments: options.sourceTextSegments,
+      sourceMarkers: options.sourceMarkers
+    });
   }
   async synthesizeChunks(chunks, options = {}) {
     const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
@@ -707,10 +1273,13 @@ var AzureTtsClient = class {
       endpoint,
       region,
       subscriptionKey,
-      outputFormat,
-      signal,
-      timeoutMs,
-      onProgress: options.onProgress ?? __privateGet(this, _options).onProgress
+      outputFormat: options.outputFormat ?? outputFormat,
+      signal: options.signal ?? signal,
+      timeoutMs: options.timeoutMs ?? timeoutMs,
+      sourceNodePath: options.sourceNodePath,
+      onProgress: options.onProgress ?? __privateGet(this, _options).onProgress,
+      concurrency: options.concurrency ?? __privateGet(this, _options).concurrency,
+      retryOptions: options.retryOptions ?? __privateGet(this, _options).retryOptions
     });
   }
   async synthesizeSsmlSafe(ssml, options = {}) {
@@ -720,7 +1289,11 @@ var AzureTtsClient = class {
     return synthesizeSsmlChunksSafe(this, chunks, {
       ...options,
       outputFormat: options.outputFormat ?? __privateGet(this, _options).outputFormat,
-      onProgress: options.onProgress ?? __privateGet(this, _options).onProgress
+      signal: options.signal ?? __privateGet(this, _options).signal,
+      timeoutMs: options.timeoutMs ?? __privateGet(this, _options).timeoutMs,
+      onProgress: options.onProgress ?? __privateGet(this, _options).onProgress,
+      concurrency: options.concurrency ?? __privateGet(this, _options).concurrency,
+      retryOptions: options.retryOptions ?? __privateGet(this, _options).retryOptions
     });
   }
   async synthesizeSsmlChunksSafe(chunks, options = {}) {
@@ -817,16 +1390,23 @@ async function fetchAzureVoiceCatalog(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AudioFormatMismatchError,
   AzureTtsClient,
   AzureTtsError,
   AzureTtsSdkError,
   ChunkValidationError,
+  DEFAULT_OUTPUT_FORMAT,
+  MergeError,
+  SynthesisCancelledError,
+  SynthesisTimeoutError,
   UnsupportedMergeFormatError,
   canMergeAudioFormat,
   fetchAzureVoiceCatalog,
+  inspectAudioSpecification,
   mergeAudioBuffers,
   mergeSynthesisResults,
   resolveMergeAudioFormat,
+  resolveMimeType,
   synthesizeSpeech,
   synthesizeSsml,
   synthesizeSsmlChunks,