ssml-builder-js 2.18.0 → 2.19.1

package/dist/index.mjs

@@ -93,6 +93,15 @@ var SynthesisTimeoutError = class extends Error {
     this.name = "SynthesisTimeoutError";
   }
 };
+var IncompleteChunkSetError = class extends Error {
+  constructor(totalChunks, missingChunkIndices) {
+    super(`Cannot merge an incomplete chunk set; missing chunk indices: ${missingChunkIndices.join(", ")}.`);
+    this.kind = "incomplete-chunk-set";
+    this.name = "IncompleteChunkSetError";
+    this.totalChunks = totalChunks;
+    this.missingChunkIndices = [...missingChunkIndices];
+  }
+};
 var MergeError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -117,8 +126,32 @@ var UnsupportedMergeFormatError = class extends Error {
     this.format = format;
   }
 };
+function serializeChunkError(error, phase, isOriginalFailure) {
+  const message = error instanceof Error ? error.message : String(error);
+  const status = error instanceof AzureTtsError ? error.status : void 0;
+  const kind = error && typeof error === "object" && "kind" in error ? String(error.kind) : "";
+  const code = kind === "validation-error" ? "VALIDATION_ERROR" : kind === "timeout" || /tim(?:e|ed) ?out|deadline/i.test(message) ? "TIMEOUT" : kind === "cancelled" || /cancel|abort/i.test(message) ? "CANCELLED" : kind === "audio-format-mismatch" || kind === "unsupported-format-error" ? "FORMAT_MISMATCH" : kind === "merge-error" || phase === "merge" ? "MERGE_ERROR" : "AZURE_API_ERROR";
+  const details = {};
+  if (error instanceof AzureTtsError) {
+    details.statusText = error.statusText;
+    if (error.requestId) details.requestId = error.requestId;
+  }
+  if (error instanceof IncompleteChunkSetError) {
+    details.totalChunks = error.totalChunks;
+    details.missingChunkIndices = [...error.missingChunkIndices];
+  }
+  return {
+    code,
+    phase,
+    message,
+    isOriginalFailure,
+    isRetryable: code === "AZURE_API_ERROR" && (status === 429 || status !== void 0 && status >= 500 || /network|connection|connect|socket|fetch failed|econn|etimedout|temporar|transient|unavailable/i.test(message)),
+    ...status !== void 0 && status > 0 ? { httpStatus: status } : {},
+    ...Object.keys(details).length > 0 ? { details } : {}
+  };
+}
 function toSynthesisError(error) {
-  if (error instanceof AzureTtsError || error instanceof MergeError || error instanceof AudioFormatMismatchError || error instanceof UnsupportedMergeFormatError || error instanceof SynthesisCancelledError || error instanceof SynthesisTimeoutError)
+  if (error instanceof AzureTtsError || error instanceof MergeError || error instanceof AudioFormatMismatchError || error instanceof UnsupportedMergeFormatError || error instanceof SynthesisCancelledError || error instanceof SynthesisTimeoutError || error instanceof IncompleteChunkSetError)
     return error;
   const message = error instanceof Error ? error.message : String(error);
   if (/cancel|abort/i.test(message)) return new SynthesisCancelledError(message);
@@ -130,6 +163,55 @@ function createSpeechSdkError(error) {
   return new AzureTtsSdkError(message);
 }
 
+// packages/azure-tts-client/src/deadline.ts
+var _controller, _parent, _onParentAbort, _timer, _timedOut;
+var DeadlineController = class {
+  constructor(totalJobMs, parent) {
+    __privateAdd(this, _controller, new AbortController());
+    __privateAdd(this, _parent);
+    __privateAdd(this, _onParentAbort);
+    __privateAdd(this, _timer);
+    __privateAdd(this, _timedOut, false);
+    __privateSet(this, _parent, parent);
+    __privateSet(this, _onParentAbort, () => __privateGet(this, _controller).abort());
+    this.deadlineAtMs = totalJobMs !== void 0 && totalJobMs > 0 ? Date.now() + totalJobMs : void 0;
+    this.signal = this.deadlineAtMs === void 0 && parent ? parent : __privateGet(this, _controller).signal;
+    if (parent?.aborted) __privateGet(this, _controller).abort();
+    parent?.addEventListener("abort", __privateGet(this, _onParentAbort), { once: true });
+    if (this.deadlineAtMs !== void 0) {
+      __privateSet(this, _timer, setTimeout(
+        () => {
+          __privateSet(this, _timedOut, true);
+          __privateGet(this, _controller).abort();
+        },
+        Math.max(0, this.deadlineAtMs - Date.now())
+      ));
+    }
+  }
+  get timedOut() {
+    return __privateGet(this, _timedOut) || this.deadlineAtMs !== void 0 && this.remainingMs <= 0;
+  }
+  get remainingMs() {
+    return this.deadlineAtMs === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, this.deadlineAtMs - Date.now());
+  }
+  throwIfExpired() {
+    if (this.timedOut) throw new SynthesisTimeoutError("Speech synthesis exceeded the total job deadline.");
+    if (this.signal.aborted) throw new Error("Speech synthesis was cancelled.");
+  }
+  abort() {
+    __privateGet(this, _controller).abort();
+  }
+  dispose() {
+    if (__privateGet(this, _timer)) clearTimeout(__privateGet(this, _timer));
+    __privateGet(this, _parent)?.removeEventListener("abort", __privateGet(this, _onParentAbort));
+  }
+};
+_controller = new WeakMap();
+_parent = new WeakMap();
+_onParentAbort = new WeakMap();
+_timer = new WeakMap();
+_timedOut = new WeakMap();
+
 // packages/azure-tts-client/src/synthesis.ts
 import * as SpeechSDK2 from "microsoft-cognitiveservices-speech-sdk";
 
@@ -211,18 +293,23 @@ function createSpeechConfig(config) {
 }
 
 // packages/azure-tts-client/src/synthesis.ts
-function computeChunkFingerprint(ssml, outputFormat = DEFAULT_OUTPUT_FORMAT) {
+function computeChunkFingerprint(ssml, outputFormat = DEFAULT_OUTPUT_FORMAT, options = {}) {
   const readAttribute = (name) => {
     const pattern = new RegExp(`(?:${name})\\s*=\\s*[\\"']([^\\"']*)`, "gi");
     return [...ssml.matchAll(pattern)].map((match) => match[1] ?? "").join("|");
   };
+  const headers = Object.fromEntries(
+    Object.entries(options.customHeaders ?? {}).sort(([first], [second]) => first.localeCompare(second))
+  );
   const payload = JSON.stringify({
     ssml,
     outputFormat,
-    voice: readAttribute("(?:name|voice)"),
-    language: readAttribute("(?:xml:lang|lang)"),
-    rate: readAttribute("rate"),
-    pitch: readAttribute("pitch")
+    region: options.region ?? "",
+    endpoint: options.endpoint ?? "",
+    voice: options.voice ?? readAttribute("(?:name|voice)"),
+    lang: options.lang ?? readAttribute("(?:xml:lang|lang)"),
+    customHeaders: headers,
+    fingerprintSchemaVersion: options.fingerprintSchemaVersion ?? options.schemaVersion ?? "2"
   });
   let hash = 0xcbf29ce484222325n;
   const mask = 0xffffffffffffffffn;
@@ -342,6 +429,129 @@ function parseMp3Specification(buffer, format) {
   }
   return void 0;
 }
+function readEbmlVint(bytes, offset, preserveMarker) {
+  const first = bytes[offset];
+  if (first === void 0) throw new Error("Invalid EBML variable-length integer.");
+  let mask = 128;
+  let length = 1;
+  while (length <= 8 && (first & mask) === 0) {
+    mask >>= 1;
+    length += 1;
+  }
+  if (length > 8 || offset + length > bytes.byteLength) throw new Error("Truncated EBML variable-length integer.");
+  let value = preserveMarker ? first : first & mask - 1;
+  for (let index = 1; index < length; index += 1) value = value * 256 + (bytes[offset + index] ?? 0);
+  if (!preserveMarker && value === 2 ** (7 * length) - 1)
+    throw new Error("EBML unknown-size elements are not supported.");
+  return { value, length };
+}
+function readEbmlElement(bytes, offset) {
+  const id = readEbmlVint(bytes, offset, true);
+  const size = readEbmlVint(bytes, offset + id.length, false);
+  const dataStart = offset + id.length + size.length;
+  const dataEnd = dataStart + size.value;
+  if (dataEnd > bytes.byteLength) throw new Error("EBML element exceeds the audio buffer.");
+  return { id: id.value, dataStart, dataEnd };
+}
+function ebmlText(bytes, element) {
+  return new TextDecoder().decode(bytes.slice(element.dataStart, element.dataEnd));
+}
+function findEbmlElement(bytes, start, end, id) {
+  let offset = start;
+  while (offset < end) {
+    const element = readEbmlElement(bytes, offset);
+    if (element.id === id) return element;
+    offset = element.dataEnd;
+  }
+  if (offset !== end) throw new Error("Invalid EBML element boundary.");
+  return void 0;
+}
+function parseOggSpecification(buffer, format) {
+  const bytes = new Uint8Array(buffer);
+  let offset = 0;
+  let firstPayload;
+  let pages = 0;
+  while (offset < bytes.byteLength) {
+    if (offset + 27 > bytes.byteLength || !ascii(bytes, offset, "OggS")) throw new Error("Invalid Ogg page header.");
+    if (bytes[offset + 4] !== 0) throw new Error("Unsupported Ogg bitstream version.");
+    const segmentCount = bytes[offset + 26] ?? 0;
+    const lacingStart = offset + 27;
+    const payloadStart = lacingStart + segmentCount;
+    if (payloadStart > bytes.byteLength) throw new Error("Truncated Ogg segment table.");
+    const payloadLength = bytes.slice(lacingStart, payloadStart).reduce((total, value) => total + value, 0);
+    const pageEnd = payloadStart + payloadLength;
+    if (pageEnd > bytes.byteLength) throw new Error("Ogg page payload exceeds the audio buffer.");
+    if (pages === 0) firstPayload = bytes.slice(payloadStart, pageEnd);
+    offset = pageEnd;
+    pages += 1;
+  }
+  if (pages === 0 || !firstPayload || !ascii(firstPayload, 0, "OpusHead") || firstPayload.byteLength < 19)
+    throw new Error("Ogg audio must contain a valid OpusHead packet.");
+  const version = firstPayload[8];
+  const channels = firstPayload[9] ?? 0;
+  const sampleRate = new DataView(firstPayload.buffer, firstPayload.byteOffset, firstPayload.byteLength).getUint32(
+    12,
+    true
+  );
+  if (version !== 1 || channels <= 0 || sampleRate <= 0) throw new Error("Invalid Ogg OpusHead stream parameters.");
+  return {
+    format,
+    mimeType: "audio/ogg",
+    codec: "opus",
+    sampleRate,
+    channels,
+    container: "ogg",
+    isVbr: true,
+    isCompressed: true
+  };
+}
+function parseWebmSpecification(buffer, format) {
+  const bytes = new Uint8Array(buffer);
+  const ebml = readEbmlElement(bytes, 0);
+  if (ebml.id !== 440786851) throw new Error("WebM audio must begin with an EBML header.");
+  const docType = findEbmlElement(bytes, ebml.dataStart, ebml.dataEnd, 17026);
+  if (!docType || ebmlText(bytes, docType).toLowerCase() !== "webm") throw new Error("EBML DocType must be webm.");
+  const segment = readEbmlElement(bytes, ebml.dataEnd);
+  if (segment.id !== 408125543) throw new Error("WebM audio must contain a Segment element.");
+  const tracks = findEbmlElement(bytes, segment.dataStart, segment.dataEnd, 374648427);
+  if (!tracks) throw new Error("WebM audio must contain a Tracks element.");
+  let offset = tracks.dataStart;
+  let opusTrack;
+  while (offset < tracks.dataEnd) {
+    const track = readEbmlElement(bytes, offset);
+    if (track.id === 174) {
+      const codec = findEbmlElement(bytes, track.dataStart, track.dataEnd, 134);
+      const trackType = findEbmlElement(bytes, track.dataStart, track.dataEnd, 131);
+      if (codec && ebmlText(bytes, codec) === "A_OPUS" && trackType && bytes[trackType.dataStart] === 2) {
+        opusTrack = track;
+        break;
+      }
+    }
+    offset = track.dataEnd;
+  }
+  if (!opusTrack) throw new Error("WebM tracks do not define an Opus audio track.");
+  const audio = findEbmlElement(bytes, opusTrack.dataStart, opusTrack.dataEnd, 225);
+  const sampling = audio ? findEbmlElement(bytes, audio.dataStart, audio.dataEnd, 181) : void 0;
+  const channels = audio ? findEbmlElement(bytes, audio.dataStart, audio.dataEnd, 159) : void 0;
+  const sampleRate = sampling ? new DataView(
+    bytes.buffer,
+    bytes.byteOffset + sampling.dataStart,
+    sampling.dataEnd - sampling.dataStart
+  ).getFloat64(0, false) : 0;
+  const channelCount = channels ? bytes[channels.dataEnd - 1] ?? 0 : 0;
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0 || channelCount <= 0)
+    throw new Error("WebM Opus audio track has invalid sampling or channel parameters.");
+  return {
+    format,
+    mimeType: "audio/webm",
+    codec: "opus",
+    sampleRate: Math.round(sampleRate),
+    channels: channelCount,
+    container: "webm",
+    isVbr: true,
+    isCompressed: true
+  };
+}
 function inspectAudioSpecification(buffer, format) {
   if (isWavFormat(format) || ascii(new Uint8Array(buffer), 0, "RIFF")) {
     const parsed = parseWav(buffer);
@@ -366,7 +576,20 @@ function inspectAudioSpecification(buffer, format) {
       isCompressed: codec !== "pcm" && codec !== "unknown"
     };
   }
-  if (isMp3Format(format)) return parseMp3Specification(buffer, format) ?? formatAudioSpecification(format);
+  if (isMp3Format(format)) {
+    const specification2 = parseMp3Specification(buffer, format);
+    return specification2 ?? formatAudioSpecification(format);
+  }
+  if (isOggFormat(format) || ascii(new Uint8Array(buffer), 0, "OggS")) {
+    const specification2 = parseOggSpecification(buffer, format);
+    validateContainerFormat(specification2, format);
+    return specification2;
+  }
+  if (isWebmFormat(format) || new Uint8Array(buffer)[0] === 26) {
+    const specification2 = parseWebmSpecification(buffer, format);
+    validateContainerFormat(specification2, format);
+    return specification2;
+  }
   const specification = formatAudioSpecification(format);
   if (specification.container === "raw") validateRawAudioBuffer(buffer, specification);
   return specification;
@@ -375,7 +598,20 @@ 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;
+  if (specification.codec === "siren") return;
+  if (specification.codec === "silk") {
+    if (buffer.byteLength <= 9 || !ascii(new Uint8Array(buffer), 0, "#!SILK_V3"))
+      throw new Error("RAW SILK audio must contain a valid #!SILK_V3 payload header.");
+    return;
+  }
+  if (specification.codec === "opus" && buffer.byteLength === 0) throw new Error("RAW Opus audio cannot be empty.");
+  if (specification.codec === "opus") {
+    const packetCode = new Uint8Array(buffer)[0] ?? 0;
+    const frameCountCode = packetCode & 3;
+    if (packetCode >> 3 > 31 || buffer.byteLength < (frameCountCode === 3 ? 2 : 2) || frameCountCode === 3 && ((new Uint8Array(buffer)[1] ?? 0) & 63) === 0)
+      throw new Error("RAW Opus audio has an invalid packet framing header.");
+    return;
+  }
   const bytesPerFrame = specification.channels * Math.ceil(specification.bitDepth / 8);
   if (bytesPerFrame <= 0 || buffer.byteLength % bytesPerFrame !== 0) {
     throw new Error(
@@ -383,6 +619,15 @@ function validateRawAudioBuffer(buffer, specification) {
     );
   }
 }
+function validateContainerFormat(specification, format) {
+  const expected = formatAudioSpecification(format);
+  if (expected.sampleRate > 0 && specification.sampleRate !== expected.sampleRate || expected.channels > 0 && specification.channels !== expected.channels || expected.codec !== "unknown" && specification.codec !== expected.codec) {
+    throw new AudioFormatMismatchError(`Audio container does not match the requested format "${format}".`, [
+      expected,
+      specification
+    ]);
+  }
+}
 function validateAudioSpecifications(specs) {
   const first = specs[0];
   if (!first) return;
@@ -464,17 +709,29 @@ function stripMp3Tags(buffer) {
 function isMp3Format(format) {
   return /(?:mp3|mpeg)/i.test(format);
 }
+function isOggFormat(format) {
+  return /ogg/i.test(format);
+}
+function isWebmFormat(format) {
+  return /webm/i.test(format);
+}
 function isWavFormat(format) {
   return /(?:wav|wave|riff)/i.test(format);
 }
 function isRawFormat(format) {
   return /^raw(?:-|$)/i.test(format);
 }
-function validateMergedAudioBuffer(merged, format, buffers, inputSpecs, outputMimeType) {
+function validateMergedAudioBuffer(merged, format, buffers, inputSpecs, outputMimeType, allowExternalContainer) {
   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);
+  let specification;
+  try {
+    specification = inspectAudioSpecification(merged, format);
+  } catch (error) {
+    if (!allowExternalContainer) throw error;
+    specification = inputSpecs[0] ?? formatAudioSpecification(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)) {
@@ -494,6 +751,25 @@ function validateMergedAudioBuffer(merged, format, buffers, inputSpecs, outputMi
   }
   return specification;
 }
+async function withinDeadline(value, deadline) {
+  if (!deadline) return value;
+  deadline.throwIfExpired();
+  if (!Number.isFinite(deadline.remainingMs)) return value;
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve(value),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(
+          () => reject(new SynthesisTimeoutError("Speech synthesis exceeded the total job deadline.")),
+          deadline.remainingMs
+        );
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function resolveMergeAudioFormat(format) {
   if (isWavFormat(format)) return "wav";
   if (isMp3Format(format)) return "mp3";
@@ -506,6 +782,7 @@ function canMergeAudioFormat(format) {
 function mergeAudioBuffers(buffers, options) {
   const format = typeof options === "string" ? options : options?.format;
   if (!format) throw new UnsupportedMergeFormatError("");
+  if (!canMergeAudioFormat(format)) throw new UnsupportedMergeFormatError(format);
   try {
     validateAudioSpecifications(buffers.map((buffer) => inspectAudioSpecification(buffer, format)));
     if (isWavFormat(format)) return mergeWavBuffers(buffers);
@@ -814,10 +1091,23 @@ async function synthesizeWithRetry(ssml, config, retryOptions, onRetry, deadline
   }
 }
 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);
+  const deadline = new DeadlineController(config.timeouts?.totalJobMs, config.signal);
+  try {
+    deadline.throwIfExpired();
+    const synthesisConfig = {
+      ...config,
+      signal: deadline.signal,
+      timeouts: config.timeouts ? { ...config.timeouts, totalJobMs: void 0 } : void 0
+    };
+    const result = config.retryOptions ? await synthesizeWithRetry(ssml, synthesisConfig, config.retryOptions, () => void 0, deadline.deadlineAtMs) : await synthesizeSsmlOnce(ssml, synthesisConfig);
+    deadline.throwIfExpired();
+    return result;
+  } catch (error) {
+    if (deadline.timedOut) throw new SynthesisTimeoutError("Speech synthesis exceeded the total job deadline.");
+    throw error;
+  } finally {
+    deadline.dispose();
+  }
 }
 function createAbortScope(parent, timeoutMs) {
   const controller = new AbortController();
@@ -854,7 +1144,12 @@ async function synthesizeSsmlChunks(chunks, config) {
   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)
+    (chunk) => computeChunkFingerprint(chunk.ssml, config.outputFormat ?? DEFAULT_OUTPUT_FORMAT, {
+      region: config.region,
+      endpoint: config.endpoint,
+      customHeaders: config.customHeaders,
+      fingerprintSchemaVersion: config.fingerprintSchemaVersion
+    })
   );
   const results = new Array(totalChunks);
   const cachedChunks = new Map((config.resumeChunks ?? []).map((chunk) => [chunk.chunkIndex, chunk]));
@@ -878,6 +1173,7 @@ async function synthesizeSsmlChunks(chunks, config) {
   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 deadline = new DeadlineController(config.timeouts?.totalJobMs, config.signal);
   const scope = createAbortScope(config.signal, config.timeouts?.totalJobMs);
   const report = (event) => config.onProgress?.(event);
   for (const [index, input] of inputs.entries()) {
@@ -918,7 +1214,7 @@ async function synthesizeSsmlChunks(chunks, config) {
           input.ssml,
           {
             ...config,
-            signal: scope.signal,
+            signal: deadline.signal,
             ...input.originalTextRange ? { sourceTextRange: input.originalTextRange } : {},
             ...input.sourceNodePath ?? config.sourceNodePath ? { sourceNodePath: [...input.sourceNodePath ?? config.sourceNodePath ?? []] } : {},
             ...input.sourceTextSegments ? { sourceTextSegments: input.sourceTextSegments } : {},
@@ -963,7 +1259,7 @@ async function synthesizeSsmlChunks(chunks, config) {
           status: wasCancelled ? "cancelled" : "failed",
           isOriginalFailure: !wasCancelled,
           canResume: true,
-          error
+          error: serializeChunkError(error, "synthesis", !wasCancelled)
         };
         report({
           currentChunk: completed,
@@ -983,13 +1279,19 @@ async function synthesizeSsmlChunks(chunks, config) {
   try {
     await Promise.all(Array.from({ length: Math.min(concurrency, chunks.length) }, () => worker()));
     if (firstError) throw firstError;
+    const missingChunkIndices = Array.from(
+      { length: totalChunks },
+      (_value, index) => results[index] === void 0 ? index : void 0
+    ).filter((index) => index !== void 0);
+    if (missingChunkIndices.length > 0) throw new IncompleteChunkSetError(totalChunks, missingChunkIndices);
     const orderedResults = results.filter((result) => result !== void 0);
     return await mergeSynthesisResults(orderedResults, {
       format: config.outputFormat ?? DEFAULT_OUTPUT_FORMAT,
-      signal: scope.signal,
+      signal: deadline.signal,
       customMerger: config.customMerger,
       outputMimeType: config.outputMimeType,
-      postMergeValidator: config.postMergeValidator
+      postMergeValidator: config.postMergeValidator,
+      deadline
     });
   } catch (error) {
     if (firstError && config.cancelOnFailure !== false) {
@@ -1017,6 +1319,7 @@ async function synthesizeSsmlChunks(chunks, config) {
     throw error;
   } finally {
     scope.dispose();
+    deadline.dispose();
   }
 }
 function createMergedResult(results, audioData, format, audioSpec, outputMimeType) {
@@ -1094,19 +1397,33 @@ function mergeSynthesisResults(results, 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));
+  const inputSpecs = results.map((result) => {
+    if (result.audioSpec) return result.audioSpec;
+    try {
+      return inspectAudioSpecification(result.audioData, format);
+    } catch (error) {
+      if (resolvedOptions.customMerger) return formatAudioSpecification(format);
+      throw error;
+    }
+  });
   validateAudioSpecifications(inputSpecs);
-  const signal = resolvedOptions.signal ?? new AbortController().signal;
+  const deadline = resolvedOptions.deadline;
+  deadline?.throwIfExpired();
+  const signal = resolvedOptions.signal ?? deadline?.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
-      })
+    return withinDeadline(
+      Promise.resolve().then(
+        () => resolvedOptions.customMerger?.(buffers, {
+          format,
+          outputMimeType: resolvedOptions.outputMimeType ?? resolveMimeType(format),
+          inputSpecs,
+          signal
+        })
+      ),
+      deadline
     ).then((merged) => {
+      deadline?.throwIfExpired();
       if (!merged) throw new MergeError("The custom audio merger returned no audio buffer.");
       if (signal.aborted) throw new SynthesisCancelledError();
       const mergedSpec = validateMergedAudioBuffer(
@@ -1114,7 +1431,8 @@ function mergeSynthesisResults(results, options) {
         format,
         buffers,
         inputSpecs,
-        resolvedOptions.outputMimeType ?? resolveMimeType(format)
+        resolvedOptions.outputMimeType ?? resolveMimeType(format),
+        true
       );
       const result = createMergedResult(results, merged, format, mergedSpec, resolvedOptions.outputMimeType);
       return Promise.resolve(
@@ -1125,6 +1443,7 @@ function mergeSynthesisResults(results, options) {
           signal
         })
       ).then((valid) => {
+        deadline?.throwIfExpired();
         if (valid === false) throw new MergeError("The post-merge validator rejected the merged audio.");
         return result;
       });
@@ -1135,6 +1454,7 @@ function mergeSynthesisResults(results, options) {
     });
   }
   try {
+    deadline?.throwIfExpired();
     const result = createMergedResult(
       results,
       mergeAudioBuffers(buffers, { format }),
@@ -1150,12 +1470,14 @@ function mergeSynthesisResults(results, options) {
         signal
       });
       if (validation instanceof Promise)
-        return validation.then((valid) => {
+        return withinDeadline(validation, deadline).then((valid) => {
+          deadline?.throwIfExpired();
           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.");
     }
+    deadline?.throwIfExpired();
     return result;
   } catch (error) {
     if (error instanceof UnsupportedMergeFormatError || isAudioFormatMismatch(error) || error instanceof MergeError)
@@ -1300,47 +1622,55 @@ function sharedValidationOptions(options, signal) {
   };
 }
 async function synthesizeSsmlSafe(client, ssml, options = {}) {
-  const validationOptions = sharedValidationOptions(options.validation ?? options, options.signal);
+  const deadline = new DeadlineController(options.timeouts?.totalJobMs, options.signal);
+  const validationOptions = sharedValidationOptions(options.validation ?? options, deadline.signal);
   const diagnostics = await Promise.resolve(validateAzureSsml2(ssml, validationOptions));
-  if (options.signal?.aborted) {
-    const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+  if (deadline.signal.aborted) {
+    const error = toSynthesisError(
+      new Error(deadline.timedOut ? "Speech synthesis timed out." : "Speech synthesis was cancelled.")
+    );
+    deadline.dispose();
     return failure(error);
   }
   const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
   if (errors.length > 0) {
+    deadline.dispose();
     return failure({
       kind: "validation-error",
       message: "SSML validation failed; the Azure Speech API was not called.",
       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: jobScope?.signal ?? options.signal,
+        signal: deadline.signal,
         timeoutMs: options.timeouts?.perChunkMs,
-        timeouts: options.timeouts
+        timeouts: options.timeouts ? { ...options.timeouts, totalJobMs: void 0 } : void 0
       })
     };
   } catch (error) {
-    if (jobScope?.timedOut()) return failure(toSynthesisError(new Error("Speech synthesis timed out.")));
+    if (deadline.timedOut) return failure(toSynthesisError(new Error("Speech synthesis timed out.")));
     const synthesisError = toSynthesisError(error);
     return failure(synthesisError);
   } finally {
-    jobScope?.dispose();
+    deadline.dispose();
   }
 }
 async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
+  const deadline = new DeadlineController(options.timeouts?.totalJobMs, options.signal);
   const validationOptions = sharedValidationOptions(
     { ...options.validation ?? options, timeouts: options.timeouts },
-    options.signal
+    deadline.signal
   );
-  if (options.signal?.aborted) {
-    const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+  if (deadline.signal.aborted) {
+    const error = toSynthesisError(
+      new Error(deadline.timedOut ? "Speech synthesis timed out." : "Speech synthesis was cancelled.")
+    );
+    deadline.dispose();
     return failure(error);
   }
   const pending = (index, status, error) => {
@@ -1372,14 +1702,16 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
       return diagnostics.filter((diagnostic) => diagnostic.severity === "error");
     })
   );
-  if (options.signal?.aborted) {
+  if (deadline.signal.aborted) {
     const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+    deadline.dispose();
     return failure(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);
+    deadline.dispose();
     return failure(error);
   }
   let fallbackJobScope;
@@ -1392,9 +1724,9 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
       const value = await client.synthesizeChunks(normalizedChunks, {
         onProgress: options.onProgress,
         outputFormat: options.outputFormat,
-        signal: options.signal,
+        signal: deadline.signal,
         timeoutMs: options.timeoutMs,
-        timeouts: options.timeouts,
+        timeouts: options.timeouts ? { ...options.timeouts, totalJobMs: void 0 } : void 0,
         sourceNodePath: options.sourceNodePath,
         concurrency: options.concurrency,
         retryOptions: options.retryOptions,
@@ -1404,12 +1736,19 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
         customMerger: options.customMerger,
         outputMimeType: options.outputMimeType,
         postMergeValidator: options.postMergeValidator,
-        resumeValidation: options.resumeValidation
+        resumeValidation: options.resumeValidation,
+        customHeaders: options.customHeaders,
+        fingerprintSchemaVersion: options.fingerprintSchemaVersion
       });
       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 fingerprints = inputs.map(
+      (chunk) => computeChunkFingerprint(chunk.ssml, options.outputFormat, {
+        customHeaders: options.customHeaders,
+        fingerprintSchemaVersion: options.fingerprintSchemaVersion
+      })
+    );
     const results = new Array(chunks.length);
     const chunkStates = inputs.map((_chunk, chunkIndex) => ({
       chunkIndex,
@@ -1427,9 +1766,8 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
     }
     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;
+    const jobDeadlineAt = deadline.deadlineAtMs;
+    const jobScope = chunks.length > 1 || options.timeouts?.totalJobMs !== void 0 ? createSafeAbortScope(deadline.signal, void 0) : void 0;
     fallbackJobScope = jobScope;
     const failedIndices = /* @__PURE__ */ new Set();
     let firstError;
@@ -1453,8 +1791,8 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
         const startedAt = Date.now();
         try {
           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;
+          const chunkScope = chunkTimeout !== void 0 || jobScope ? createSafeAbortScope(jobScope?.signal ?? deadline.signal, chunkTimeout ?? options.timeoutMs) : void 0;
+          const chunkSignal = chunkScope?.signal ?? deadline.signal;
           let result;
           try {
             result = await retryableSynthesis(
@@ -1481,7 +1819,7 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
               jobDeadlineAt
             );
           } catch (error) {
-            if (chunkScope?.timedOut())
+            if (chunkScope?.timedOut() || deadline.timedOut)
               throw new Error(`Speech synthesis timed out after ${chunkTimeout ?? options.timeoutMs} ms.`);
             throw error;
           } finally {
@@ -1542,15 +1880,15 @@ 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);
+          const wasCancelled = firstError !== void 0 || !deadline.timedOut && Boolean(jobScope?.signal.aborted && !jobScope?.timedOut());
+          firstError ?? (firstError = deadline.timedOut ? new Error("Speech synthesis timed out.") : error);
           if (!wasCancelled) failedIndices.add(index);
           chunkStates[index] = {
             chunkIndex: index,
             status: wasCancelled ? "cancelled" : "failed",
             isOriginalFailure: !wasCancelled,
             canResume: true,
-            error
+            error: serializeChunkError(error, "synthesis", !wasCancelled)
           };
           options.onProgress?.({
             currentChunk: completed,
@@ -1593,6 +1931,11 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
       };
       throw error;
     }
+    const missingChunkIndices = Array.from(
+      { length: chunks.length },
+      (_value, index) => results[index] === void 0 ? index : void 0
+    ).filter((index) => index !== void 0);
+    if (missingChunkIndices.length > 0) throw new IncompleteChunkSetError(chunks.length, missingChunkIndices);
     const orderedResults = results.filter((result) => result !== void 0);
     return {
       ok: true,
@@ -1600,7 +1943,7 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
       status: "success",
       value: await mergeSynthesisResults(orderedResults, {
         format: options.outputFormat ?? "audio-16khz-128kbitrate-mono-mp3",
-        signal: jobScope?.signal ?? options.signal,
+        signal: jobScope?.signal ?? deadline.signal,
         customMerger: options.customMerger,
         outputMimeType: options.outputMimeType,
         postMergeValidator: options.postMergeValidator
@@ -1611,6 +1954,7 @@ async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
     return failure(synthesisError, partialResultFrom(error));
   } finally {
     fallbackJobScope?.dispose();
+    deadline.dispose();
   }
 }
 function withValidationSignal(options, signal) {
@@ -1631,7 +1975,16 @@ var AzureTtsClient = class {
     __privateSet(this, _options, options);
   }
   async synthesize(ssml) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs, timeouts } = __privateGet(this, _options);
+    const {
+      region,
+      subscriptionKey,
+      outputFormat,
+      signal,
+      timeoutMs,
+      timeouts,
+      customHeaders,
+      fingerprintSchemaVersion
+    } = __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 = {
@@ -1642,12 +1995,23 @@ var AzureTtsClient = class {
       signal,
       timeoutMs,
       timeouts,
-      retryOptions: __privateGet(this, _options).retryOptions
+      retryOptions: __privateGet(this, _options).retryOptions,
+      customHeaders,
+      fingerprintSchemaVersion
     };
     return synthesizeSpeech(ssml, config);
   }
   async synthesizeSsml(ssml, options = {}) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs, timeouts } = __privateGet(this, _options);
+    const {
+      region,
+      subscriptionKey,
+      outputFormat,
+      signal,
+      timeoutMs,
+      timeouts,
+      customHeaders,
+      fingerprintSchemaVersion
+    } = __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, {
@@ -1666,11 +2030,22 @@ var AzureTtsClient = class {
       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
+      resumeValidation: options.resumeValidation ?? __privateGet(this, _options).resumeValidation,
+      customHeaders: options.customHeaders ?? customHeaders,
+      fingerprintSchemaVersion: options.fingerprintSchemaVersion ?? fingerprintSchemaVersion
     });
   }
   async synthesizeChunks(chunks, options = {}) {
-    const { region, subscriptionKey, outputFormat, signal, timeoutMs, timeouts } = __privateGet(this, _options);
+    const {
+      region,
+      subscriptionKey,
+      outputFormat,
+      signal,
+      timeoutMs,
+      timeouts,
+      customHeaders,
+      fingerprintSchemaVersion
+    } = __privateGet(this, _options);
     const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
     return synthesizeSsmlChunks(chunks, {
       endpoint,
@@ -1690,7 +2065,9 @@ var AzureTtsClient = class {
       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
+      resumeValidation: options.resumeValidation ?? __privateGet(this, _options).resumeValidation,
+      customHeaders: options.customHeaders ?? customHeaders,
+      fingerprintSchemaVersion: options.fingerprintSchemaVersion ?? fingerprintSchemaVersion
     });
   }
   async synthesizeSsmlSafe(ssml, options = {}) {
@@ -1705,7 +2082,14 @@ var AzureTtsClient = class {
       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
+      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,
+      customHeaders: options.customHeaders ?? __privateGet(this, _options).customHeaders,
+      fingerprintSchemaVersion: options.fingerprintSchemaVersion ?? __privateGet(this, _options).fingerprintSchemaVersion
     });
   }
   async synthesizeSsmlChunksSafe(chunks, options = {}) {
@@ -1810,6 +2194,8 @@ export {
   BatchChunkValidationError,
   ChunkValidationError,
   DEFAULT_OUTPUT_FORMAT,
+  DeadlineController,
+  IncompleteChunkSetError,
   MergeError,
   SynthesisCancelledError,
   SynthesisTimeoutError,
@@ -1837,6 +2223,7 @@ export {
   parseSsml,
   resolveMergeAudioFormat,
   resolveMimeType,
+  serializeChunkError,
   splitSsmlDocument,
   synthesizeSpeech,
   synthesizeSsml,