ssml-builder-js 2.16.0 → 2.18.0

package/dist/index.mjs

@@ -18,12 +18,12 @@ import {
   validateAzureSsmlChunks,
   validateSsml,
   validateSsmlStructureIntegrity
-} from "./chunk-NKLZGITR.mjs";
+} from "./chunk-2SYLELUT.mjs";
 import {
   createAzureUrlValidatorRunner as createAzureUrlValidatorRunner2,
   getSsmlSourceMap as getSsmlSourceMap2,
   validateAzureSsml as validateAzureSsml2
-} from "./chunk-HI74FTKY.mjs";
+} from "./chunk-5AZWURHW.mjs";
 import {
   __privateAdd,
   __privateGet,
@@ -32,7 +32,7 @@ import {
 
 // packages/azure-tts-client/src/errors.ts
 var AzureTtsError = class extends Error {
-  constructor(status, statusText, responseBody, requestId) {
+  constructor(status, statusText, responseBody, requestId, responseHeaders) {
     super(`Azure TTS request failed: ${status} ${statusText}`);
     this.kind = "azure-api-error";
     this.name = "AzureTtsError";
@@ -40,8 +40,37 @@ var AzureTtsError = class extends Error {
     this.statusText = statusText;
     this.responseBody = responseBody;
     this.requestId = requestId;
+    const value = responseHeaders instanceof Headers ? responseHeaders.get("retry-after") : responseHeaders?.["retry-after"] ?? responseHeaders?.["Retry-After"];
+    const seconds = value ? Number(value.trim()) : NaN;
+    const date = value ? Date.parse(value) : NaN;
+    if (Number.isFinite(seconds) && seconds >= 0) this.retryAfterMs = seconds * 1e3;
+    else if (Number.isFinite(date)) this.retryAfterMs = Math.max(0, date - Date.now());
   }
 };
+function getRetryAfterDelayMs(error) {
+  if (error instanceof AzureTtsError && error.retryAfterMs !== void 0) return error.retryAfterMs;
+  if (!error || typeof error !== "object") return void 0;
+  const candidate = error;
+  if (typeof candidate.retryAfterMs === "number" && candidate.retryAfterMs >= 0) return candidate.retryAfterMs;
+  const headers = candidate.headers ?? candidate.response?.headers;
+  if (headers instanceof Headers) {
+    const value = headers.get("retry-after");
+    if (!value) return void 0;
+    const seconds = Number(value.trim());
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : void 0;
+  }
+  if (headers && typeof headers === "object") {
+    const value = headers["retry-after"] ?? headers["Retry-After"];
+    if (typeof value !== "string") return void 0;
+    const seconds = Number(value.trim());
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : void 0;
+  }
+  return void 0;
+}
 var AzureTtsSdkError = class extends AzureTtsError {
   constructor(errorDetails) {
     super(0, "Speech SDK", errorDetails, null);
@@ -151,6 +180,9 @@ var OUTPUT_FORMATS = {
 function resolveMimeType(outputFormat) {
   if (/(?:wav|wave|riff)/i.test(outputFormat)) return "audio/wav";
   if (/(?:mp3|mpeg)/i.test(outputFormat)) return "audio/mpeg";
+  if (/mulaw|mu-law/i.test(outputFormat)) return "audio/basic";
+  if (/alaw|a-law/i.test(outputFormat)) return "audio/alaw";
+  if (/siren/i.test(outputFormat)) return "audio/siren";
   if (/ogg/i.test(outputFormat)) return "audio/ogg";
   if (/webm/i.test(outputFormat)) return "audio/webm";
   if (/raw/i.test(outputFormat)) return "audio/L16";
@@ -179,6 +211,27 @@ function createSpeechConfig(config) {
 }
 
 // packages/azure-tts-client/src/synthesis.ts
+function computeChunkFingerprint(ssml, outputFormat = DEFAULT_OUTPUT_FORMAT) {
+  const readAttribute = (name) => {
+    const pattern = new RegExp(`(?:${name})\\s*=\\s*[\\"']([^\\"']*)`, "gi");
+    return [...ssml.matchAll(pattern)].map((match) => match[1] ?? "").join("|");
+  };
+  const payload = JSON.stringify({
+    ssml,
+    outputFormat,
+    voice: readAttribute("(?:name|voice)"),
+    language: readAttribute("(?:xml:lang|lang)"),
+    rate: readAttribute("rate"),
+    pitch: readAttribute("pitch")
+  });
+  let hash = 0xcbf29ce484222325n;
+  const mask = 0xffffffffffffffffn;
+  for (let index = 0; index < payload.length; index += 1) {
+    hash ^= BigInt(payload.charCodeAt(index));
+    hash = hash * 0x100000001b3n & mask;
+  }
+  return `fnv1a64-${hash.toString(16).padStart(16, "0")}`;
+}
 function ascii(bytes, offset, value) {
   return [...value].every((character, index) => bytes[offset + index] === character.charCodeAt(0));
 }
@@ -218,9 +271,11 @@ 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 formatSampleRate(format) {
+  const match = /(?:^|-)(\d+)(khz|hz)(?:-|$)/i.exec(format);
+  if (!match?.[1] || !match[2]) return 0;
+  const value = Number(match[1]);
+  return match[2].toLowerCase() === "khz" ? value * 1e3 : value;
 }
 function formatChannels(format, fallback) {
   if (/stereo|2ch|dual/i.test(format)) return 2;
@@ -228,11 +283,13 @@ function formatChannels(format, fallback) {
   return fallback;
 }
 function formatAudioSpecification(format) {
-  const sampleRate = formatNumber(format, /(\d+)(?:khz|kHz|hz|Hz)/, 0);
+  const sampleRate = formatSampleRate(format);
   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";
+  const codec = /mp3|mpeg/i.test(format) ? "mp3" : /opus/i.test(format) ? "opus" : /silk/i.test(format) ? "silk" : /mulaw|mu-law/i.test(format) ? "mulaw" : /alaw|a-law/i.test(format) ? "alaw" : /siren/i.test(format) ? "siren" : /pcm/i.test(format) ? "pcm" : "unknown";
+  const bitDepthMatch = /(\d+)bit/i.exec(format);
+  const container = /(?:wav|wave|riff)/i.test(format) ? "riff-wave" : /mp3|mpeg/i.test(format) ? "mp3-raw" : /ogg/i.test(format) ? "ogg" : /webm/i.test(format) ? "webm" : /raw/i.test(format) ? "raw" : void 0;
   return {
     format,
     mimeType: resolveMimeType(format),
@@ -240,7 +297,10 @@ function formatAudioSpecification(format) {
     sampleRate,
     channels,
     ...bitrate ? { bitrate } : {},
-    isCompressed: codec === "mp3" || codec === "opus" || codec === "silk"
+    ...bitDepthMatch?.[1] ? { bitDepth: Number(bitDepthMatch[1]) } : {},
+    ...container ? { container } : {},
+    isVbr: /vbr/i.test(format),
+    isCompressed: codec !== "pcm" && codec !== "unknown"
   };
 }
 function parseMp3Specification(buffer, format) {
@@ -275,6 +335,8 @@ function parseMp3Specification(buffer, format) {
       sampleRate,
       channels: (bytes[index + 3] ?? 0) >> 6 === 3 ? 1 : 2,
       bitrate: bitrateKbps * 1e3,
+      container: "mp3-raw",
+      isVbr: false,
       isCompressed: true
     };
   }
@@ -289,24 +351,43 @@ function inspectAudioSpecification(buffer, format) {
     const channels = view.getUint16(2, true);
     const bitsPerSample = parsed.format.byteLength >= 16 ? view.getUint16(14, true) : 0;
     const formatCode = view.getUint16(0, true);
+    const namedCodec = formatAudioSpecification(format).codec;
+    const codec = formatCode === 1 ? "pcm" : formatCode === 6 ? "alaw" : formatCode === 7 ? "mulaw" : namedCodec === "siren" ? "siren" : "unknown";
     return {
       format,
       mimeType: "audio/wav",
-      codec: formatCode === 1 ? "pcm" : "unknown",
+      codec,
       sampleRate,
       channels,
       ...sampleRate && channels && bitsPerSample ? { bitrate: sampleRate * channels * bitsPerSample } : {},
-      isCompressed: formatCode !== 1
+      bitDepth: bitsPerSample,
+      container: "riff-wave",
+      isVbr: false,
+      isCompressed: codec !== "pcm" && codec !== "unknown"
     };
   }
   if (isMp3Format(format)) return parseMp3Specification(buffer, format) ?? formatAudioSpecification(format);
-  return formatAudioSpecification(format);
+  const specification = formatAudioSpecification(format);
+  if (specification.container === "raw") validateRawAudioBuffer(buffer, specification);
+  return specification;
+}
+function validateRawAudioBuffer(buffer, specification) {
+  if (specification.sampleRate <= 0 || specification.channels <= 0 || specification.bitDepth === void 0) {
+    throw new Error(`RAW audio format "${specification.format}" does not define a complete audio specification.`);
+  }
+  if (specification.codec === "siren" || specification.codec === "silk") return;
+  const bytesPerFrame = specification.channels * Math.ceil(specification.bitDepth / 8);
+  if (bytesPerFrame <= 0 || buffer.byteLength % bytesPerFrame !== 0) {
+    throw new Error(
+      `RAW audio buffer size ${buffer.byteLength} is not aligned to ${bytesPerFrame}-byte audio frames for "${specification.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
+    (spec) => spec.sampleRate !== first.sampleRate || spec.channels !== first.channels || spec.codec !== first.codec || first.bitrate !== void 0 && spec.bitrate !== void 0 && spec.bitrate !== first.bitrate || first.bitDepth !== void 0 && spec.bitDepth !== void 0 && spec.bitDepth !== first.bitDepth || first.container !== void 0 && spec.container !== void 0 && spec.container !== first.container || first.isVbr !== void 0 && spec.isVbr !== void 0 && spec.isVbr !== first.isVbr
   );
   if (mismatch)
     throw new AudioFormatMismatchError(
@@ -389,6 +470,30 @@ function isWavFormat(format) {
 function isRawFormat(format) {
   return /^raw(?:-|$)/i.test(format);
 }
+function validateMergedAudioBuffer(merged, format, buffers, inputSpecs, outputMimeType) {
+  if (!(merged instanceof ArrayBuffer) || merged.byteLength === 0) {
+    throw new MergeError("The custom audio merger returned an empty or invalid audio buffer.");
+  }
+  const specification = inspectAudioSpecification(merged, format);
+  if (!outputMimeType.trim()) throw new MergeError("The custom audio merger output MIME type cannot be empty.");
+  const firstInput = inputSpecs[0];
+  if (firstInput && (specification.sampleRate !== firstInput.sampleRate || specification.channels !== firstInput.channels || specification.codec !== firstInput.codec || firstInput.bitDepth !== void 0 && specification.bitDepth !== firstInput.bitDepth)) {
+    throw new AudioFormatMismatchError("The custom audio merger returned an incompatible audio stream.", [
+      ...inputSpecs,
+      specification
+    ]);
+  }
+  if (isRawFormat(format)) {
+    const expectedSize = buffers.reduce((total, input) => total + input.byteLength, 0);
+    if (merged.byteLength !== expectedSize) {
+      throw new MergeError(
+        `The custom audio merger returned ${merged.byteLength} bytes; ${expectedSize} were expected.`
+      );
+    }
+    validateRawAudioBuffer(merged, specification);
+  }
+  return specification;
+}
 function resolveMergeAudioFormat(format) {
   if (isWavFormat(format)) return "wav";
   if (isMp3Format(format)) return "mp3";
@@ -441,7 +546,7 @@ function closeSpeechResources(speechConfig, synthesizer) {
   }
 }
 var ticksToMilliseconds = (ticks) => Math.max(0, ticks) / 1e4;
-async function synthesizeSsml(ssml, config) {
+async function synthesizeSsmlOnce(ssml, config) {
   if (config.signal?.aborted) {
     throw new SynthesisCancelledError();
   }
@@ -509,9 +614,7 @@ async function synthesizeSsml(ssml, config) {
         };
       }
       if (sourceSegments.length === 0 && !config.sourceTextRange && !config.sourceNodePath) {
-        const unmapped = { mappingStatus: "unmapped" };
-        Object.defineProperty(unmapped, "mappingStatus", { value: "unmapped", enumerable: false });
-        return unmapped;
+        return { mappingStatus: "unmapped" };
       }
       const value = text ?? "";
       let localStart = Number.isFinite(offsetHint) && (offsetHint ?? 0) >= 0 ? offsetHint : -1;
@@ -573,6 +676,13 @@ async function synthesizeSsml(ssml, config) {
         rejectWithError(err);
         return;
       }
+      let audioSpec;
+      try {
+        audioSpec = inspectAudioSpecification(result.audioData, config.outputFormat ?? DEFAULT_OUTPUT_FORMAT);
+      } catch (error) {
+        rejectWithError(error);
+        return;
+      }
       settled = true;
       cleanup();
       closeResources();
@@ -593,8 +703,13 @@ async function synthesizeSsml(ssml, config) {
           ...config.sourceNodePath ? { sourceNodePath: [...config.sourceNodePath] } : {},
           ...requestId ? { requestId } : {}
         };
-        if (event.mappingStatus === "unmapped")
+        if (event.mappingStatus === "unmapped") {
           Object.defineProperty(mapped, "mappingStatus", { value: "unmapped", enumerable: false });
+          Object.defineProperty(mapped, "toJSON", {
+            value: () => ({ ...mapped, mappingStatus: "unmapped" }),
+            enumerable: false
+          });
+        }
         return mapped;
       };
       const sourceBoundaries = boundaries.map((boundary) => addSourceMetadata(boundary));
@@ -603,8 +718,8 @@ async function synthesizeSsml(ssml, config) {
       resolve({
         audioData: result.audioData,
         durationMs,
-        audioSpec: inspectAudioSpecification(result.audioData, config.outputFormat ?? DEFAULT_OUTPUT_FORMAT),
-        mimeType: resolveMimeType(config.outputFormat ?? DEFAULT_OUTPUT_FORMAT),
+        audioSpec,
+        mimeType: config.outputMimeType ?? resolveMimeType(config.outputFormat ?? DEFAULT_OUTPUT_FORMAT),
         ...config.sourceTextRange ? { textRange: { ...config.sourceTextRange } } : {},
         ...requestId ? { requestId } : {},
         ...sourceBoundaries.length > 0 ? { boundaries: sourceBoundaries, wordBoundary: sourceBoundaries, wordBoundaries: sourceBoundaries } : {},
@@ -617,10 +732,11 @@ async function synthesizeSsml(ssml, config) {
         abortHandler = () => rejectWithError(new SynthesisCancelledError());
         config.signal.addEventListener("abort", abortHandler, { once: true });
       }
-      if (config.timeoutMs !== void 0 && config.timeoutMs > 0) {
+      const timeoutMs = config.timeouts?.perChunkMs ?? config.timeouts?.totalJobMs ?? config.timeoutMs;
+      if (timeoutMs !== void 0 && timeoutMs > 0) {
         timeout = setTimeout(
-          () => rejectWithError(new SynthesisTimeoutError(`Speech synthesis timed out after ${config.timeoutMs} ms.`)),
-          config.timeoutMs
+          () => rejectWithError(new SynthesisTimeoutError(`Speech synthesis timed out after ${timeoutMs} ms.`)),
+          timeoutMs
         );
       }
       synthesizer.speakSsmlAsync(ssml, cb, rejectWithError);
@@ -639,7 +755,9 @@ function isRetryableSynthesisError(error) {
   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) {
+function retryDelay(options, retryAttempt, error) {
+  const retryAfterMs = getRetryAfterDelayMs(error);
+  if (retryAfterMs !== void 0) return retryAfterMs;
   const base = Math.min(options.maxDelayMs, options.initialDelayMs * 2 ** Math.max(0, retryAttempt - 1));
   return Math.floor(Math.random() * (base + 1));
 }
@@ -667,32 +785,102 @@ async function waitForRetry(delayMs, signal) {
     }
   });
 }
-async function synthesizeWithRetry(ssml, config, retryOptions, onRetry) {
+async function synthesizeWithRetry(ssml, config, retryOptions, onRetry, deadlineAtMs) {
   const options = retryOptions ? {
     maxRetries: Math.max(0, Math.floor(retryOptions.maxRetries)),
     initialDelayMs: Math.max(0, retryOptions.initialDelayMs),
-    maxDelayMs: Math.max(0, retryOptions.maxDelayMs)
+    maxDelayMs: Math.max(0, retryOptions.maxDelayMs),
+    shouldRetry: retryOptions.shouldRetry
   } : void 0;
   let attempt = 0;
   while (true) {
     if (config.signal?.aborted) throw new SynthesisCancelledError();
     try {
-      return await synthesizeSsml(ssml, config);
+      return await synthesizeSsmlOnce(ssml, config);
     } catch (error) {
-      if (!options || attempt >= options.maxRetries || !isRetryableSynthesisError(error)) throw error;
+      if (!options || attempt >= options.maxRetries || !(options.shouldRetry?.(error, attempt + 1) ?? isRetryableSynthesisError(error)))
+        throw error;
       attempt += 1;
-      const delayMs = retryDelay(options, attempt);
+      const delayMs = retryDelay(options, attempt, error);
+      const remainingMs = deadlineAtMs === void 0 ? void 0 : Math.max(0, deadlineAtMs - Date.now());
+      if (getRetryAfterDelayMs(error) !== void 0 && (delayMs > options.maxDelayMs || remainingMs !== void 0 && delayMs > remainingMs)) {
+        throw new SynthesisTimeoutError(
+          remainingMs === void 0 ? `Retry-After exceeded maxDelayMs (${options.maxDelayMs} ms).` : `Retry-After exceeded the remaining total job timeout (${remainingMs} ms).`
+        );
+      }
       onRetry(attempt, delayMs);
-      await waitForRetry(delayMs, config.signal);
+      await waitForRetry(Math.min(delayMs, remainingMs ?? delayMs), config.signal);
     }
   }
 }
+async function synthesizeSsml(ssml, config) {
+  const totalJobMs = config.timeouts?.totalJobMs;
+  const deadlineAtMs = totalJobMs !== void 0 && totalJobMs > 0 ? Date.now() + totalJobMs : void 0;
+  if (!config.retryOptions) return synthesizeSsmlOnce(ssml, config);
+  return synthesizeWithRetry(ssml, config, config.retryOptions, () => void 0, deadlineAtMs);
+}
+function createAbortScope(parent, timeoutMs) {
+  const controller = new AbortController();
+  let didTimeout = false;
+  const onAbort = () => controller.abort();
+  if (parent?.aborted) controller.abort();
+  parent?.addEventListener("abort", onAbort, { once: true });
+  const timer = timeoutMs !== void 0 && timeoutMs > 0 ? setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, timeoutMs) : void 0;
+  return {
+    signal: controller.signal,
+    timedOut: () => didTimeout,
+    dispose: () => {
+      if (timer) clearTimeout(timer);
+      parent?.removeEventListener("abort", onAbort);
+    },
+    abort: () => controller.abort()
+  };
+}
+async function synthesizeChunkWithTimeout(ssml, config, retryOptions, timeoutMs, onRetry, deadlineAtMs) {
+  const scope = createAbortScope(config.signal, timeoutMs);
+  try {
+    return await synthesizeWithRetry(ssml, { ...config, signal: scope.signal }, retryOptions, onRetry, deadlineAtMs);
+  } catch (error) {
+    if (scope.timedOut()) throw new SynthesisTimeoutError(`Speech synthesis timed out after ${timeoutMs} ms.`);
+    throw error;
+  } finally {
+    scope.dispose();
+  }
+}
 async function synthesizeSsmlChunks(chunks, config) {
-  const results = new Array(chunks.length);
   const totalChunks = chunks.length;
+  const inputs = chunks.map((chunk) => typeof chunk === "string" ? { ssml: chunk } : chunk);
+  const fingerprints = inputs.map(
+    (chunk) => computeChunkFingerprint(chunk.ssml, config.outputFormat ?? DEFAULT_OUTPUT_FORMAT)
+  );
+  const results = new Array(totalChunks);
+  const cachedChunks = new Map((config.resumeChunks ?? []).map((chunk) => [chunk.chunkIndex, chunk]));
+  const invalidCachedIndices = /* @__PURE__ */ new Set();
+  const chunkStates = inputs.map((_chunk, chunkIndex) => ({
+    chunkIndex,
+    status: "pending",
+    canResume: true
+  }));
+  for (const [index, cached] of cachedChunks) {
+    if (index < 0 || index >= totalChunks) continue;
+    const isValid = config.resumeValidation === "disabled" || cached.fingerprint === fingerprints[index];
+    if (isValid) {
+      results[index] = { ...cached };
+      chunkStates[index] = { chunkIndex: index, status: "succeeded", canResume: true, result: results[index] };
+    } else {
+      invalidCachedIndices.add(index);
+    }
+  }
+  const requestedIndices = config.resumeChunkIndices ? new Set(config.resumeChunkIndices.filter((index) => index >= 0 && index < totalChunks)) : void 0;
+  const shouldSynthesize = (index) => (!cachedChunks.has(index) || invalidCachedIndices.has(index)) && (requestedIndices === void 0 || requestedIndices.has(index) || invalidCachedIndices.has(index));
+  const jobStartedAt = Date.now();
+  const jobDeadlineAt = config.timeouts?.totalJobMs !== void 0 && config.timeouts.totalJobMs > 0 ? jobStartedAt + config.timeouts.totalJobMs : void 0;
+  const scope = createAbortScope(config.signal, config.timeouts?.totalJobMs);
   const report = (event) => config.onProgress?.(event);
-  for (const [index, chunk] of chunks.entries()) {
-    const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
+  for (const [index, input] of inputs.entries()) {
     report({
       currentChunk: index,
       totalChunks,
@@ -703,15 +891,18 @@ async function synthesizeSsmlChunks(chunks, config) {
       durationMs: 0
     });
   }
-  let completed = 0;
+  let completed = [...results].filter((result) => result !== void 0).length;
   let nextIndex = 0;
   const concurrency = resolveConcurrency(config.concurrency, chunks.length);
+  let firstError;
+  const failedIndices = /* @__PURE__ */ new Set();
   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;
+      if (!shouldSynthesize(index)) continue;
+      if (firstError && config.cancelOnFailure !== false) return;
+      const input = inputs[index];
       report({
         currentChunk: completed,
         totalChunks,
@@ -723,10 +914,11 @@ async function synthesizeSsmlChunks(chunks, config) {
       });
       const startedAt = Date.now();
       try {
-        const result = await synthesizeWithRetry(
+        const result = await synthesizeChunkWithTimeout(
           input.ssml,
           {
             ...config,
+            signal: scope.signal,
             ...input.originalTextRange ? { sourceTextRange: input.originalTextRange } : {},
             ...input.sourceNodePath ?? config.sourceNodePath ? { sourceNodePath: [...input.sourceNodePath ?? config.sourceNodePath ?? []] } : {},
             ...input.sourceTextSegments ? { sourceTextSegments: input.sourceTextSegments } : {},
@@ -735,6 +927,7 @@ async function synthesizeSsmlChunks(chunks, config) {
             onProgress: void 0
           },
           config.retryOptions,
+          config.timeouts?.chunkWithRetriesMs ?? config.timeouts?.perChunkMs ?? config.timeoutMs,
           (retryAttempt, nextRetryDelayMs) => report({
             currentChunk: completed,
             totalChunks,
@@ -746,9 +939,11 @@ async function synthesizeSsmlChunks(chunks, config) {
             retryAttempt,
             nextRetryDelayMs,
             isRetrying: true
-          })
+          }),
+          jobDeadlineAt
         );
         results[index] = result;
+        chunkStates[index] = { chunkIndex: index, status: "succeeded", canResume: true, result };
         completed += 1;
         report({
           currentChunk: completed,
@@ -760,6 +955,16 @@ async function synthesizeSsmlChunks(chunks, config) {
           durationMs: Date.now() - startedAt
         });
       } catch (error) {
+        const wasCancelled = firstError !== void 0 || scope.signal.aborted && !scope.timedOut();
+        firstError ?? (firstError = scope.timedOut() ? new SynthesisTimeoutError(`Speech synthesis timed out after ${config.timeouts?.totalJobMs} ms.`) : error);
+        if (!wasCancelled) failedIndices.add(index);
+        chunkStates[index] = {
+          chunkIndex: index,
+          status: wasCancelled ? "cancelled" : "failed",
+          isOriginalFailure: !wasCancelled,
+          canResume: true,
+          error
+        };
         report({
           currentChunk: completed,
           totalChunks,
@@ -770,16 +975,49 @@ async function synthesizeSsmlChunks(chunks, config) {
           durationMs: Date.now() - startedAt,
           error
         });
-        throw error;
+        if (config.cancelOnFailure !== false) scope.abort();
+        return;
       }
     }
   };
-  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
-  });
+  try {
+    await Promise.all(Array.from({ length: Math.min(concurrency, chunks.length) }, () => worker()));
+    if (firstError) throw firstError;
+    const orderedResults = results.filter((result) => result !== void 0);
+    return await mergeSynthesisResults(orderedResults, {
+      format: config.outputFormat ?? DEFAULT_OUTPUT_FORMAT,
+      signal: scope.signal,
+      customMerger: config.customMerger,
+      outputMimeType: config.outputMimeType,
+      postMergeValidator: config.postMergeValidator
+    });
+  } catch (error) {
+    if (firstError && config.cancelOnFailure !== false) {
+      for (const [chunkIndex, state] of chunkStates.entries()) {
+        if (state.status === "pending" && shouldSynthesize(chunkIndex)) {
+          chunkStates[chunkIndex] = { chunkIndex, status: "cancelled", isOriginalFailure: false, canResume: true };
+        }
+      }
+    }
+    const synthesizedChunks = results.flatMap(
+      (result, chunkIndex) => result ? [{ ...result, chunkIndex, fingerprint: fingerprints[chunkIndex] ?? "" }] : []
+    );
+    const partial = {
+      synthesizedChunks,
+      completedChunks: synthesizedChunks,
+      pendingChunkIndices: chunkStates.flatMap(
+        (state) => state.status === "pending" || state.status === "cancelled" || state.status === "failed" ? [state.chunkIndex] : []
+      ),
+      failedChunkIndices: [...failedIndices],
+      cancelledChunkIndices: chunkStates.filter((state) => state.status === "cancelled").map((state) => state.chunkIndex),
+      chunkStates,
+      totalChunks
+    };
+    if (error && typeof error === "object") error.partialResult = partial;
+    throw error;
+  } finally {
+    scope.dispose();
+  }
 }
 function createMergedResult(results, audioData, format, audioSpec, outputMimeType) {
   const boundaries = [];
@@ -870,16 +1108,26 @@ function mergeSynthesisResults(results, options) {
       })
     ).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,
+      const mergedSpec = validateMergedAudioBuffer(
         merged,
         format,
-        inspectAudioSpecification(merged, format),
-        resolvedOptions.outputMimeType
+        buffers,
+        inputSpecs,
+        resolvedOptions.outputMimeType ?? resolveMimeType(format)
       );
+      const result = createMergedResult(results, merged, format, mergedSpec, resolvedOptions.outputMimeType);
+      return Promise.resolve(
+        resolvedOptions.postMergeValidator?.(result, {
+          format,
+          outputMimeType: resolvedOptions.outputMimeType ?? resolveMimeType(format),
+          inputSpecs,
+          signal
+        })
+      ).then((valid) => {
+        if (valid === false) throw new MergeError("The post-merge validator rejected the merged audio.");
+        return result;
+      });
     }).catch((error) => {
       if (error instanceof UnsupportedMergeFormatError || isAudioFormatMismatch(error) || error instanceof MergeError)
         throw error;
@@ -887,13 +1135,28 @@ function mergeSynthesisResults(results, options) {
     });
   }
   try {
-    return createMergedResult(
+    const result = createMergedResult(
       results,
       mergeAudioBuffers(buffers, { format }),
       format,
       inputSpecs[0],
       resolvedOptions.outputMimeType
     );
+    if (resolvedOptions.postMergeValidator) {
+      const validation = resolvedOptions.postMergeValidator(result, {
+        format,
+        outputMimeType: resolvedOptions.outputMimeType ?? resolveMimeType(format),
+        inputSpecs,
+        signal
+      });
+      if (validation instanceof Promise)
+        return validation.then((valid) => {
+          if (valid === false) throw new MergeError("The post-merge validator rejected the merged audio.");
+          return result;
+        });
+      if (validation === false) throw new MergeError("The post-merge validator rejected the merged audio.");
+    }
+    return result;
   } catch (error) {
     if (error instanceof UnsupportedMergeFormatError || isAudioFormatMismatch(error) || error instanceof MergeError)
       throw error;
@@ -914,8 +1177,52 @@ var ChunkValidationError = class extends Error {
     this.diagnostics = diagnostics;
   }
 };
-function failure(error) {
-  return { ok: false, success: false, status: error.kind, error };
+var BatchChunkValidationError = class extends ChunkValidationError {
+  constructor(chunkDiagnostics) {
+    const first = chunkDiagnostics[0];
+    super(first?.chunkIndex ?? -1, first?.diagnostics ?? []);
+    this.name = "BatchChunkValidationError";
+    this.message = `SSML validation failed for ${chunkDiagnostics.length} chunk(s); the Azure Speech API was not called.`;
+    this.chunkDiagnostics = chunkDiagnostics;
+    this.totalErrorCount = chunkDiagnostics.reduce((total, chunk) => total + chunk.diagnostics.length, 0);
+    this.errorCount = this.totalErrorCount;
+    this.totalErrors = this.totalErrorCount;
+  }
+};
+function failure(error, partialResult) {
+  return {
+    ok: false,
+    success: false,
+    status: error.kind,
+    error,
+    ...partialResult ? { partialResult } : {}
+  };
+}
+function partialResultFrom(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const partial = error.partialResult;
+  if (!partial || typeof partial !== "object") return void 0;
+  return partial;
+}
+function createSafeAbortScope(parent, timeoutMs) {
+  const controller = new AbortController();
+  let didTimeout = false;
+  const onAbort = () => controller.abort();
+  if (parent?.aborted) controller.abort();
+  parent?.addEventListener("abort", onAbort, { once: true });
+  const timer = timeoutMs !== void 0 && timeoutMs > 0 ? setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, timeoutMs) : void 0;
+  return {
+    signal: controller.signal,
+    timedOut: () => didTimeout,
+    dispose: () => {
+      if (timer) clearTimeout(timer);
+      parent?.removeEventListener("abort", onAbort);
+    },
+    abort: () => controller.abort()
+  };
 }
 function isRetryable(error) {
   if (error instanceof Error && /cancel|abort|tim(?:e|ed) ?out/i.test(error.message)) return false;
@@ -930,16 +1237,20 @@ function delayForRetry(options, attempt) {
   const base = Math.min(maxDelay, Math.max(0, options.initialDelayMs) * 2 ** Math.max(0, attempt - 1));
   return Math.floor(Math.random() * (base + 1));
 }
+function retryDelayForError(options, attempt, error) {
+  return getRetryAfterDelayMs(error) ?? delayForRetry(options, attempt);
+}
 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) {
+async function retryableSynthesis(synthesize, options, signal, onRetry, deadlineAtMs) {
   const retry = options ? {
     maxRetries: Math.max(0, Math.floor(options.maxRetries)),
     initialDelayMs: options.initialDelayMs,
-    maxDelayMs: options.maxDelayMs
+    maxDelayMs: options.maxDelayMs,
+    shouldRetry: options.shouldRetry
   } : void 0;
   let attempt = 0;
   while (true) {
@@ -947,9 +1258,15 @@ async function retryableSynthesis(synthesize, options, signal, onRetry) {
     try {
       return await synthesize();
     } catch (error) {
-      if (!retry || attempt >= retry.maxRetries || !isRetryable(error)) throw error;
+      if (!retry || attempt >= retry.maxRetries || !(retry.shouldRetry?.(error, attempt + 1) ?? isRetryable(error)))
+        throw error;
       attempt += 1;
-      const delayMs = delayForRetry(retry, attempt);
+      const delayMs = retryDelayForError(retry, attempt, error);
+      const retryAfterMs = getRetryAfterDelayMs(error);
+      const remainingMs = deadlineAtMs === void 0 ? void 0 : Math.max(0, deadlineAtMs - Date.now());
+      if (retryAfterMs !== void 0 && (retryAfterMs > retry.maxDelayMs || remainingMs !== void 0 && retryAfterMs > remainingMs)) {
+        throw new Error("Speech synthesis timed out because Retry-After exceeded the available retry budget.");
+      }
       onRetry(attempt, delayMs);
       if (delayMs > 0)
         await new Promise((resolve, reject) => {
@@ -973,7 +1290,7 @@ function sharedValidationOptions(options, signal) {
   const runner = createAzureUrlValidatorRunner2(validator, {
     ...options.urlValidation ?? {},
     ...options.urlValidatorConcurrency !== void 0 ? { concurrency: options.urlValidatorConcurrency } : {},
-    ...options.urlValidatorTimeoutMs !== void 0 ? { timeoutMs: options.urlValidatorTimeoutMs } : {},
+    ...options.timeouts?.urlValidationMs !== void 0 ? { timeoutMs: options.timeouts.urlValidationMs } : options.urlValidatorTimeoutMs !== void 0 ? { timeoutMs: options.urlValidatorTimeoutMs } : {},
     ...signal ? { signal } : {},
     ...options.urlValidatorCache ? { cache: options.urlValidatorCache } : {}
   });
@@ -997,20 +1314,31 @@ async function synthesizeSsmlSafe(client, ssml, options = {}) {
       diagnostics: errors
     });
   }
+  const jobScope = options.timeouts?.totalJobMs !== void 0 ? createSafeAbortScope(options.signal, options.timeouts.totalJobMs) : void 0;
   try {
     return {
       ok: true,
       success: true,
       status: "success",
-      value: await client.synthesizeSsml(ssml, { signal: options.signal })
+      value: await client.synthesizeSsml(ssml, {
+        signal: jobScope?.signal ?? options.signal,
+        timeoutMs: options.timeouts?.perChunkMs,
+        timeouts: options.timeouts
+      })
     };
   } catch (error) {
+    if (jobScope?.timedOut()) return failure(toSynthesisError(new Error("Speech synthesis timed out.")));
     const synthesisError = toSynthesisError(error);
     return failure(synthesisError);
+  } finally {
+    jobScope?.dispose();
   }
 }
 async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
-  const validationOptions = sharedValidationOptions(options.validation ?? options, options.signal);
+  const validationOptions = sharedValidationOptions(
+    { ...options.validation ?? options, timeouts: options.timeouts },
+    options.signal
+  );
   if (options.signal?.aborted) {
     const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
     return failure(error);
@@ -1044,16 +1372,17 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
       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);
+  const chunkDiagnostics = validations.map((diagnostics, chunkIndex) => ({ chunkIndex, diagnostics })).filter((entry) => entry.diagnostics.length > 0);
+  if (chunkDiagnostics.length > 0) {
+    const error = new BatchChunkValidationError(chunkDiagnostics);
+    for (const entry of chunkDiagnostics) pending(entry.chunkIndex, "failed", error);
     return failure(error);
   }
+  let fallbackJobScope;
   try {
     if (client.synthesizeChunks) {
       const normalizedChunks = chunks.map((chunk) => {
@@ -1065,20 +1394,57 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
         outputFormat: options.outputFormat,
         signal: options.signal,
         timeoutMs: options.timeoutMs,
+        timeouts: options.timeouts,
         sourceNodePath: options.sourceNodePath,
         concurrency: options.concurrency,
-        retryOptions: options.retryOptions
+        retryOptions: options.retryOptions,
+        cancelOnFailure: options.cancelOnFailure,
+        resumeChunks: options.resumeChunks,
+        resumeChunkIndices: options.resumeChunkIndices,
+        customMerger: options.customMerger,
+        outputMimeType: options.outputMimeType,
+        postMergeValidator: options.postMergeValidator,
+        resumeValidation: options.resumeValidation
       });
       return { ok: true, success: true, status: "success", value };
     }
+    const inputs = chunks.map((chunk) => typeof chunk === "string" ? { ssml: chunk } : chunk);
+    const fingerprints = inputs.map((chunk) => computeChunkFingerprint(chunk.ssml, options.outputFormat));
     const results = new Array(chunks.length);
-    let completed = 0;
+    const chunkStates = inputs.map((_chunk, chunkIndex) => ({
+      chunkIndex,
+      status: "pending",
+      canResume: true
+    }));
+    const cachedChunks = new Map((options.resumeChunks ?? []).map((chunk) => [chunk.chunkIndex, chunk]));
+    const invalidCachedIndices = /* @__PURE__ */ new Set();
+    for (const [index, cached] of cachedChunks) {
+      if (index < 0 || index >= chunks.length) continue;
+      if (options.resumeValidation === "disabled" || cached.fingerprint === fingerprints[index]) {
+        results[index] = cached;
+        chunkStates[index] = { chunkIndex: index, status: "succeeded", canResume: true, result: cached };
+      } else invalidCachedIndices.add(index);
+    }
+    const requestedIndices = options.resumeChunkIndices ? new Set(options.resumeChunkIndices.filter((index) => index >= 0 && index < chunks.length)) : void 0;
+    const shouldSynthesize = (index) => (!cachedChunks.has(index) || invalidCachedIndices.has(index)) && (requestedIndices === void 0 || requestedIndices.has(index) || invalidCachedIndices.has(index));
+    const jobStartedAt = Date.now();
+    const jobDeadlineAt = options.timeouts?.totalJobMs !== void 0 && options.timeouts.totalJobMs > 0 ? jobStartedAt + options.timeouts.totalJobMs : void 0;
+    const jobScope = chunks.length > 1 || options.timeouts?.totalJobMs !== void 0 ? createSafeAbortScope(options.signal, options.timeouts?.totalJobMs) : void 0;
+    fallbackJobScope = jobScope;
+    const failedIndices = /* @__PURE__ */ new Set();
+    let firstError;
+    let completed = [...results].filter((result) => result !== void 0).length;
     let nextIndex = 0;
     const concurrency = resolveConcurrency2(options.concurrency, chunks.length);
     const worker = async () => {
       while (true) {
         const index = nextIndex++;
         if (index >= chunks.length) return;
+        if (!shouldSynthesize(index)) continue;
+        if (firstError && options.cancelOnFailure !== false) {
+          chunkStates[index] = { chunkIndex: index, status: "cancelled", isOriginalFailure: false, canResume: true };
+          return;
+        }
         const chunk = chunks[index];
         const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
         const sourceNodePath = input.sourceNodePath;
@@ -1086,28 +1452,41 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
         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
-            })
-          );
+          const chunkTimeout = options.timeouts?.chunkWithRetriesMs ?? options.timeouts?.perChunkMs;
+          const chunkScope = chunkTimeout !== void 0 || jobScope ? createSafeAbortScope(jobScope?.signal ?? options.signal, chunkTimeout ?? options.timeoutMs) : void 0;
+          const chunkSignal = chunkScope?.signal ?? options.signal;
+          let result;
+          try {
+            result = await retryableSynthesis(
+              () => client.synthesizeSsml(input.ssml, {
+                outputFormat: options.outputFormat,
+                signal: chunkSignal,
+                timeoutMs: options.timeouts?.perChunkMs ?? options.timeoutMs,
+                sourceNodePath: input.sourceNodePath ?? options.sourceNodePath
+              }),
+              options.retryOptions,
+              chunkSignal,
+              (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
+              }),
+              jobDeadlineAt
+            );
+          } catch (error) {
+            if (chunkScope?.timedOut())
+              throw new Error(`Speech synthesis timed out after ${chunkTimeout ?? options.timeoutMs} ms.`);
+            throw error;
+          } finally {
+            chunkScope?.dispose();
+          }
           results[index] = {
             ...result,
             ...input.originalTextRange ? { textRange: { ...input.originalTextRange } } : {},
@@ -1151,6 +1530,7 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
               }))
             } : {}
           };
+          chunkStates[index] = { chunkIndex: index, status: "succeeded", canResume: true, result: results[index] };
           completed += 1;
           options.onProgress?.({
             currentChunk: completed,
@@ -1162,6 +1542,16 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
             durationMs: Date.now() - startedAt
           });
         } catch (error) {
+          const wasCancelled = firstError !== void 0 || Boolean(jobScope?.signal.aborted && !jobScope?.timedOut());
+          firstError ?? (firstError = error);
+          if (!wasCancelled) failedIndices.add(index);
+          chunkStates[index] = {
+            chunkIndex: index,
+            status: wasCancelled ? "cancelled" : "failed",
+            isOriginalFailure: !wasCancelled,
+            canResume: true,
+            error
+          };
           options.onProgress?.({
             currentChunk: completed,
             totalChunks: chunks.length,
@@ -1172,24 +1562,55 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
             durationMs: Date.now() - startedAt,
             error
           });
-          throw error;
+          if (options.cancelOnFailure !== false) jobScope?.abort();
+          return;
         }
       }
     };
     await Promise.all(Array.from({ length: Math.min(concurrency, chunks.length) }, () => worker()));
+    if (firstError && options.cancelOnFailure !== false) {
+      for (const [chunkIndex, state] of chunkStates.entries()) {
+        if (state.status === "pending" && shouldSynthesize(chunkIndex)) {
+          chunkStates[chunkIndex] = { chunkIndex, status: "cancelled", isOriginalFailure: false, canResume: true };
+        }
+      }
+    }
+    if (failedIndices.size > 0) {
+      const error = firstError ?? new Error("One or more SSML chunks failed to synthesize.");
+      const synthesizedChunks = results.flatMap(
+        (result, chunkIndex) => result ? [{ ...result, chunkIndex, fingerprint: fingerprints[chunkIndex] ?? "" }] : []
+      );
+      error.partialResult = {
+        synthesizedChunks,
+        completedChunks: synthesizedChunks,
+        pendingChunkIndices: chunkStates.flatMap(
+          (state) => state.status === "pending" || state.status === "cancelled" || state.status === "failed" ? [state.chunkIndex] : []
+        ),
+        failedChunkIndices: [...failedIndices],
+        cancelledChunkIndices: chunkStates.filter((state) => state.status === "cancelled").map((state) => state.chunkIndex),
+        chunkStates,
+        totalChunks: chunks.length
+      };
+      throw error;
+    }
     const orderedResults = results.filter((result) => result !== void 0);
     return {
       ok: true,
       success: true,
       status: "success",
-      value: mergeSynthesisResults(orderedResults, {
+      value: await mergeSynthesisResults(orderedResults, {
         format: options.outputFormat ?? "audio-16khz-128kbitrate-mono-mp3",
-        signal: options.signal
+        signal: jobScope?.signal ?? options.signal,
+        customMerger: options.customMerger,
+        outputMimeType: options.outputMimeType,
+        postMergeValidator: options.postMergeValidator
       })
     };
   } catch (error) {
     const synthesisError = toSynthesisError(error);
-    return failure(synthesisError);
+    return failure(synthesisError, partialResultFrom(error));
+  } finally {
+    fallbackJobScope?.dispose();
   }
 }
 function withValidationSignal(options, signal) {
@@ -1210,14 +1631,23 @@ var AzureTtsClient = class {
     __privateSet(this, _options, options);
   }
   async synthesize(ssml) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
+    const { region, subscriptionKey, outputFormat, signal, timeoutMs, timeouts } = __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);
-    const config = { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs };
+    const config = {
+      endpoint,
+      region,
+      subscriptionKey,
+      outputFormat,
+      signal,
+      timeoutMs,
+      timeouts,
+      retryOptions: __privateGet(this, _options).retryOptions
+    };
     return synthesizeSpeech(ssml, config);
   }
   async synthesizeSsml(ssml, options = {}) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
+    const { region, subscriptionKey, outputFormat, signal, timeoutMs, timeouts } = __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, {
@@ -1227,13 +1657,20 @@ var AzureTtsClient = class {
       outputFormat: options.outputFormat ?? outputFormat,
       signal: options.signal ?? signal,
       timeoutMs: options.timeoutMs ?? timeoutMs,
+      timeouts: options.timeouts ?? timeouts,
       sourceNodePath: options.sourceNodePath,
       sourceTextSegments: options.sourceTextSegments,
-      sourceMarkers: options.sourceMarkers
+      sourceMarkers: options.sourceMarkers,
+      retryOptions: options.retryOptions ?? __privateGet(this, _options).retryOptions,
+      cancelOnFailure: options.cancelOnFailure ?? __privateGet(this, _options).cancelOnFailure,
+      customMerger: options.customMerger ?? __privateGet(this, _options).customMerger,
+      outputMimeType: options.outputMimeType ?? __privateGet(this, _options).outputMimeType,
+      postMergeValidator: options.postMergeValidator ?? __privateGet(this, _options).postMergeValidator,
+      resumeValidation: options.resumeValidation ?? __privateGet(this, _options).resumeValidation
     });
   }
   async synthesizeChunks(chunks, options = {}) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
+    const { region, subscriptionKey, outputFormat, signal, timeoutMs, timeouts } = __privateGet(this, _options);
     const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
     return synthesizeSsmlChunks(chunks, {
       endpoint,
@@ -1242,10 +1679,18 @@ var AzureTtsClient = class {
       outputFormat: options.outputFormat ?? outputFormat,
       signal: options.signal ?? signal,
       timeoutMs: options.timeoutMs ?? timeoutMs,
+      timeouts: options.timeouts ?? timeouts,
       sourceNodePath: options.sourceNodePath,
       onProgress: options.onProgress ?? __privateGet(this, _options).onProgress,
       concurrency: options.concurrency ?? __privateGet(this, _options).concurrency,
-      retryOptions: options.retryOptions ?? __privateGet(this, _options).retryOptions
+      retryOptions: options.retryOptions ?? __privateGet(this, _options).retryOptions,
+      cancelOnFailure: options.cancelOnFailure ?? __privateGet(this, _options).cancelOnFailure,
+      resumeChunks: options.resumeChunks,
+      resumeChunkIndices: options.resumeChunkIndices,
+      customMerger: options.customMerger ?? __privateGet(this, _options).customMerger,
+      outputMimeType: options.outputMimeType ?? __privateGet(this, _options).outputMimeType,
+      postMergeValidator: options.postMergeValidator ?? __privateGet(this, _options).postMergeValidator,
+      resumeValidation: options.resumeValidation ?? __privateGet(this, _options).resumeValidation
     });
   }
   async synthesizeSsmlSafe(ssml, options = {}) {
@@ -1257,6 +1702,7 @@ var AzureTtsClient = class {
       outputFormat: options.outputFormat ?? __privateGet(this, _options).outputFormat,
       signal: options.signal ?? __privateGet(this, _options).signal,
       timeoutMs: options.timeoutMs ?? __privateGet(this, _options).timeoutMs,
+      timeouts: options.timeouts ?? __privateGet(this, _options).timeouts,
       onProgress: options.onProgress ?? __privateGet(this, _options).onProgress,
       concurrency: options.concurrency ?? __privateGet(this, _options).concurrency,
       retryOptions: options.retryOptions ?? __privateGet(this, _options).retryOptions
@@ -1350,7 +1796,9 @@ async function fetchAzureVoiceCatalog(options) {
       voiceCount: sortedVoices.length,
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       apiVersion: AZURE_VOICE_API_VERSION,
-      regions
+      regions,
+      expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3).toISOString(),
+      regionDiffs: {}
     }
   };
 }
@@ -1359,6 +1807,7 @@ export {
   AzureTtsClient,
   AzureTtsError,
   AzureTtsSdkError,
+  BatchChunkValidationError,
   ChunkValidationError,
   DEFAULT_OUTPUT_FORMAT,
   MergeError,
@@ -1369,6 +1818,7 @@ export {
   buildPartialSsml,
   buildSsml,
   canMergeAudioFormat,
+  computeChunkFingerprint,
   createAzureUrlValidatorRunner,
   extractSsmlText,
   extractSsmlTranslatableText,
@@ -1376,6 +1826,7 @@ export {
   fromPlainTextToSsml,
   getAzureVoiceCatalogMetadata,
   getBuiltInVoiceCatalogMetadata,
+  getRetryAfterDelayMs,
   getSsmlSourceMap,
   inspectAudioSpecification,
   isValidAzureAudioDuration,