@ssml-builder-js/azure-tts-client 2.13.0 → 2.15.0

package/dist/index.mjs

@@ -10,6 +10,7 @@ var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "
 var AzureTtsError = class extends Error {
   constructor(status, statusText, responseBody, requestId) {
     super(`Azure TTS request failed: ${status} ${statusText}`);
+    this.kind = "azure-api-error";
     this.name = "AzureTtsError";
     this.status = status;
     this.statusText = statusText;
@@ -25,6 +26,44 @@ var AzureTtsSdkError = class extends AzureTtsError {
     this.errorDetails = errorDetails;
   }
 };
+var SynthesisCancelledError = class extends Error {
+  constructor(message = "Speech synthesis was cancelled.") {
+    super(message);
+    this.kind = "cancelled";
+    this.name = "SynthesisCancelledError";
+  }
+};
+var SynthesisTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.kind = "timeout";
+    this.name = "SynthesisTimeoutError";
+  }
+};
+var MergeError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.kind = "merge-error";
+    this.name = "MergeError";
+    this.cause = cause;
+  }
+};
+var UnsupportedMergeFormatError = class extends Error {
+  constructor(format) {
+    super(`Audio format "${format}" cannot be safely concatenated; container re-multiplexing is required.`);
+    this.kind = "unsupported-format-error";
+    this.name = "UnsupportedMergeFormatError";
+    this.format = format;
+  }
+};
+function toSynthesisError(error) {
+  if (error instanceof AzureTtsError || error instanceof MergeError || error instanceof UnsupportedMergeFormatError || error instanceof SynthesisCancelledError || error instanceof SynthesisTimeoutError)
+    return error;
+  const message = error instanceof Error ? error.message : String(error);
+  if (/cancel|abort/i.test(message)) return new SynthesisCancelledError(message);
+  if (/tim(?:e|ed) ?out/i.test(message)) return new SynthesisTimeoutError(message);
+  return createSpeechSdkError(error);
+}
 function createSpeechSdkError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return new AzureTtsSdkError(message);
@@ -32,9 +71,7 @@ function createSpeechSdkError(error) {
 
 // src/synthesis.ts
 import * as SpeechSDK2 from "microsoft-cognitiveservices-speech-sdk";
-
-// src/speechConfig.ts
-import { SpeechConfig } from "microsoft-cognitiveservices-speech-sdk";
+import { getSsmlSourceMap } from "@ssml-builder-js/ssml-core";
 
 // src/outputFormats.ts
 import * as SpeechSDK from "microsoft-cognitiveservices-speech-sdk";
@@ -80,6 +117,14 @@ var OUTPUT_FORMATS = {
   "amr-wb-16000hz": SpeechSDK.SpeechSynthesisOutputFormat.AmrWb16000Hz,
   "g722-16khz-64kbps": SpeechSDK.SpeechSynthesisOutputFormat.G72216Khz64Kbps
 };
+function resolveMimeType(outputFormat) {
+  if (/(?:wav|wave|riff)/i.test(outputFormat)) return "audio/wav";
+  if (/(?:mp3|mpeg)/i.test(outputFormat)) return "audio/mpeg";
+  if (/ogg/i.test(outputFormat)) return "audio/ogg";
+  if (/webm/i.test(outputFormat)) return "audio/webm";
+  if (/raw/i.test(outputFormat)) return "audio/L16";
+  return "application/octet-stream";
+}
 function resolveOutputFormat(outputFormat) {
   const resolvedFormat = OUTPUT_FORMATS[outputFormat];
   if (resolvedFormat === void 0) {
@@ -89,6 +134,7 @@ function resolveOutputFormat(outputFormat) {
 }
 
 // src/speechConfig.ts
+import { SpeechConfig } from "microsoft-cognitiveservices-speech-sdk";
 function resolveEndpoint(config) {
   const endpoint = config.endpoint?.trim() || "https://{region}.tts.speech.microsoft.com/cognitiveservices/v1";
   return endpoint.replace(/\{region\}/g, encodeURIComponent(config.region));
@@ -102,6 +148,156 @@ function createSpeechConfig(config) {
 }
 
 // src/synthesis.ts
+function ascii(bytes, offset, value) {
+  return [...value].every((character, index) => bytes[offset + index] === character.charCodeAt(0));
+}
+function readUint32(bytes, offset) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(offset, true);
+}
+function parseWav(buffer) {
+  const bytes = new Uint8Array(buffer);
+  if (bytes.byteLength < 12 || !ascii(bytes, 0, "RIFF") || !ascii(bytes, 8, "WAVE")) {
+    throw new Error("Invalid WAV/RIFF audio buffer.");
+  }
+  const chunks = [];
+  const dataParts = [];
+  let format;
+  let offset = 12;
+  while (offset < bytes.byteLength) {
+    if (offset + 8 > bytes.byteLength) throw new Error("Invalid WAV chunk header.");
+    const id = String.fromCharCode(...bytes.slice(offset, offset + 4));
+    const size = readUint32(bytes, offset + 4);
+    const dataStart = offset + 8;
+    const dataEnd = dataStart + size;
+    if (dataEnd > bytes.byteLength) throw new Error(`WAV chunk "${id}" exceeds the audio buffer.`);
+    const data2 = bytes.slice(dataStart, dataEnd);
+    chunks.push({ id, data: data2 });
+    if (id === "fmt ") format ?? (format = data2);
+    if (id === "data") dataParts.push(data2);
+    offset = dataEnd + (size & 1);
+    if (offset > bytes.byteLength) throw new Error("Invalid WAV chunk padding.");
+  }
+  if (!format || dataParts.length === 0) throw new Error("WAV audio must contain fmt and data chunks.");
+  const dataLength = dataParts.reduce((total, part) => total + part.byteLength, 0);
+  const data = new Uint8Array(dataLength);
+  let dataOffset = 0;
+  for (const part of dataParts) {
+    data.set(part, dataOffset);
+    dataOffset += part.byteLength;
+  }
+  return { chunks, data, format };
+}
+function writeUint32(target, offset, value) {
+  new DataView(target.buffer).setUint32(offset, value, true);
+}
+function writeChunk(target, offset, id, data) {
+  for (let index = 0; index < 4; index += 1) target[offset + index] = id.charCodeAt(index) ?? 0;
+  writeUint32(target, offset + 4, data.byteLength);
+  target.set(data, offset + 8);
+  const end = offset + 8 + data.byteLength;
+  if (data.byteLength & 1) target[end] = 0;
+  return end + (data.byteLength & 1);
+}
+function mergeWavBuffers(buffers) {
+  if (buffers.length === 0) return new ArrayBuffer(0);
+  const parsed = buffers.map(parseWav);
+  const first = parsed[0];
+  if (!first) throw new Error("At least one WAV buffer is required.");
+  if (parsed.some(
+    (item) => item.format.length !== first.format.length || item.format.some((value, i) => value !== first.format[i])
+  ))
+    throw new Error("WAV buffers have incompatible fmt chunks.");
+  const dataLength = parsed.reduce((total, item) => total + item.data.byteLength, 0);
+  const nonDataLength = first.chunks.reduce(
+    (total, chunk) => chunk.id === "data" ? total : total + 8 + chunk.data.byteLength + (chunk.data.byteLength & 1),
+    0
+  );
+  const outputLength = 12 + nonDataLength + 8 + dataLength + (dataLength & 1);
+  if (outputLength - 8 > 4294967295) throw new RangeError("Merged WAV exceeds the RIFF format size limit.");
+  const output = new Uint8Array(outputLength);
+  output.set(Uint8Array.from([82, 73, 70, 70]), 0);
+  writeUint32(output, 4, outputLength - 8);
+  output.set(Uint8Array.from([87, 65, 86, 69]), 8);
+  let outputOffset = 12;
+  let dataWritten = false;
+  for (const chunk of first.chunks) {
+    if (chunk.id === "data") {
+      if (dataWritten) continue;
+      const data = new Uint8Array(dataLength);
+      let dataOffset = 0;
+      for (const item of parsed) {
+        data.set(item.data, dataOffset);
+        dataOffset += item.data.byteLength;
+      }
+      outputOffset = writeChunk(output, outputOffset, "data", data);
+      dataWritten = true;
+    } else {
+      outputOffset = writeChunk(output, outputOffset, chunk.id, chunk.data);
+    }
+  }
+  if (!dataWritten) throw new Error("WAV audio must contain a data chunk.");
+  return output.buffer;
+}
+function skipId3v2(bytes) {
+  if (!ascii(bytes, 0, "ID3") || bytes.byteLength < 10) return 0;
+  const size = [bytes[6], bytes[7], bytes[8], bytes[9]].reduce((total, value) => total << 7 | value & 127, 0);
+  const hasFooter = (bytes[5] & 16) !== 0;
+  return Math.min(bytes.byteLength, 10 + size + (hasFooter ? 10 : 0));
+}
+function stripMp3Tags(buffer) {
+  const bytes = new Uint8Array(buffer);
+  const start = skipId3v2(bytes);
+  const end = bytes.byteLength >= 128 && ascii(bytes, bytes.byteLength - 128, "TAG") ? bytes.byteLength - 128 : bytes.byteLength;
+  return bytes.slice(Math.min(start, end), end);
+}
+function isMp3Format(format) {
+  return /(?:mp3|mpeg)/i.test(format);
+}
+function isWavFormat(format) {
+  return /(?:wav|wave|riff)/i.test(format);
+}
+function isRawFormat(format) {
+  return /^raw(?:-|$)/i.test(format);
+}
+function resolveMergeAudioFormat(format) {
+  if (isWavFormat(format)) return "wav";
+  if (isMp3Format(format)) return "mp3";
+  if (isRawFormat(format)) return "raw";
+  return void 0;
+}
+function canMergeAudioFormat(format) {
+  return resolveMergeAudioFormat(format) !== void 0;
+}
+function mergeAudioBuffers(buffers, options) {
+  const format = typeof options === "string" ? options : options?.format;
+  if (!format) throw new UnsupportedMergeFormatError("");
+  try {
+    if (isWavFormat(format)) return mergeWavBuffers(buffers);
+    if (isMp3Format(format)) {
+      const parts = buffers.map(stripMp3Tags);
+      const output = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
+      let offset = 0;
+      for (const part of parts) {
+        output.set(part, offset);
+        offset += part.byteLength;
+      }
+      return output.buffer;
+    }
+    if (isRawFormat(format)) {
+      const output = new Uint8Array(buffers.reduce((total, buffer) => total + buffer.byteLength, 0));
+      let offset = 0;
+      for (const buffer of buffers) {
+        output.set(new Uint8Array(buffer), offset);
+        offset += buffer.byteLength;
+      }
+      return output.buffer;
+    }
+    throw new UnsupportedMergeFormatError(format);
+  } catch (error) {
+    if (error instanceof UnsupportedMergeFormatError || error instanceof MergeError) throw error;
+    throw new MergeError(`Audio buffers could not be merged for format "${format}".`, error);
+  }
+}
 function closeSpeechResources(speechConfig, synthesizer) {
   try {
     synthesizer.close();
@@ -115,7 +311,7 @@ function closeSpeechResources(speechConfig, synthesizer) {
 var ticksToMilliseconds = (ticks) => Math.max(0, ticks) / 1e4;
 async function synthesizeSsml(ssml, config) {
   if (config.signal?.aborted) {
-    throw createSpeechSdkError("Speech synthesis was cancelled.");
+    throw new SynthesisCancelledError();
   }
   const speechConfig = createSpeechConfig(config);
   const synthesizer = new SpeechSDK2.SpeechSynthesizer(speechConfig, null);
@@ -138,23 +334,94 @@ async function synthesizeSsml(ssml, config) {
       settled = true;
       cleanup();
       closeResources();
-      reject(createSpeechSdkError(error));
+      reject(toSynthesisError(error));
     };
     const boundaries = [];
     const visemes = [];
     const bookmarks = [];
+    let sourceEventCursor = 0;
+    let generatedSourceMap;
+    if (!config.sourceTextSegments && !config.sourceMarkers) {
+      try {
+        generatedSourceMap = getSsmlSourceMap(ssml);
+      } catch {
+        generatedSourceMap = void 0;
+      }
+    }
+    const sourceBaseOffset = config.sourceTextRange?.start ?? 0;
+    const sourceSegments = config.sourceTextSegments ?? generatedSourceMap?.segments.map((segment) => ({
+      ...segment,
+      range: {
+        start: segment.range.start + sourceBaseOffset,
+        end: segment.range.end + sourceBaseOffset
+      },
+      sourceNodePath: [...segment.sourceNodePath]
+    })) ?? [];
+    const sourceMarkers = config.sourceMarkers ?? generatedSourceMap?.markers.map((marker) => ({
+      ...marker,
+      originalTextRange: {
+        start: marker.originalTextRange.start + sourceBaseOffset,
+        end: marker.originalTextRange.end + sourceBaseOffset
+      },
+      sourceNodePath: [...marker.sourceNodePath]
+    })) ?? [];
+    const sourceText = sourceSegments.map((segment) => segment.text).join("");
+    const mapSourceEvent = (text, offsetHint, markerName) => {
+      const marker = markerName ? sourceMarkers.find((candidate) => candidate.name === markerName) : void 0;
+      if (marker) {
+        return {
+          originalTextRange: { ...marker.originalTextRange },
+          sourceNodePath: [...marker.sourceNodePath],
+          textRange: { ...marker.originalTextRange }
+        };
+      }
+      if (sourceSegments.length === 0 && !config.sourceTextRange && !config.sourceNodePath) return {};
+      const value = text ?? "";
+      let localStart = Number.isFinite(offsetHint) && (offsetHint ?? 0) >= 0 ? offsetHint : -1;
+      if (value && localStart >= 0 && sourceText.slice(localStart, localStart + value.length) !== value)
+        localStart = -1;
+      if (localStart < 0 || localStart > sourceText.length) {
+        localStart = value ? sourceText.indexOf(value, sourceEventCursor) : sourceEventCursor;
+        if (localStart < 0) localStart = value ? sourceText.indexOf(value) : sourceEventCursor;
+      }
+      localStart = Math.max(0, localStart);
+      const localEnd = Math.min(sourceText.length, localStart + value.length);
+      sourceEventCursor = Math.max(sourceEventCursor, localEnd);
+      const baseStart = config.sourceTextRange?.start ?? sourceSegments[0]?.range.start ?? 0;
+      const fallbackRange = { start: baseStart + localStart, end: baseStart + localEnd };
+      const segment = sourceSegments.find(({ range }) => range.start <= fallbackRange.start && range.end > fallbackRange.start) ?? sourceSegments.find(({ range }) => range.end > fallbackRange.start) ?? (value.length === 0 ? sourceSegments.find(({ range }) => range.start <= fallbackRange.start && range.end >= fallbackRange.start) : void 0);
+      return {
+        originalTextRange: { ...fallbackRange },
+        textRange: { ...fallbackRange },
+        ...segment ? { sourceNodePath: [...segment.sourceNodePath] } : config.sourceNodePath ? { sourceNodePath: [...config.sourceNodePath] } : {}
+      };
+    };
     synthesizer.wordBoundary = (_sender, event) => {
       boundaries.push({
         text: event.text,
         audioOffsetMs: ticksToMilliseconds(event.audioOffset),
-        durationMs: ticksToMilliseconds(event.duration)
+        durationMs: ticksToMilliseconds(event.duration),
+        ...mapSourceEvent(
+          event.text,
+          event.textOffset
+        )
       });
     };
     synthesizer.visemeReceived = (_sender, event) => {
-      visemes.push({ visemeId: event.visemeId, audioOffsetMs: ticksToMilliseconds(event.audioOffset) });
+      const eventWithOffset = event;
+      visemes.push({
+        visemeId: event.visemeId,
+        audioOffsetMs: ticksToMilliseconds(event.audioOffset),
+        ...mapSourceEvent(void 0, eventWithOffset.textOffset)
+      });
     };
     synthesizer.bookmarkReached = (_sender, event) => {
-      bookmarks.push({ name: event.text, audioOffsetMs: ticksToMilliseconds(event.audioOffset) });
+      const eventWithOffset = event;
+      bookmarks.push({
+        name: event.text,
+        audioOffsetMs: ticksToMilliseconds(event.audioOffset),
+        ...mapSourceEvent(void 0, eventWithOffset.textOffset, event.text)
+      });
     };
     const cb = (result) => {
       if (settled) return;
@@ -177,7 +444,10 @@ async function synthesizeSsml(ssml, config) {
       const requestId = result.resultId;
       const addSourceMetadata = (event) => ({
         ...event,
-        ...config.sourceTextRange ? { textRange: { ...config.sourceTextRange } } : {},
+        ...config.sourceTextRange && !("textRange" in event) ? { textRange: { ...config.sourceTextRange } } : {},
+        ...config.sourceTextRange && !("originalTextRange" in event) ? { originalTextRange: { ...config.sourceTextRange } } : {},
+        ...config.chunkIndex !== void 0 ? { chunkIndex: config.chunkIndex } : {},
+        ...config.sourceNodePath ? { sourceNodePath: [...config.sourceNodePath] } : {},
         ...requestId ? { requestId } : {}
       });
       const sourceBoundaries = boundaries.map((boundary) => addSourceMetadata(boundary));
@@ -195,12 +465,12 @@ async function synthesizeSsml(ssml, config) {
     };
     try {
       if (config.signal) {
-        abortHandler = () => rejectWithError("Speech synthesis was cancelled.");
+        abortHandler = () => rejectWithError(new SynthesisCancelledError());
         config.signal.addEventListener("abort", abortHandler, { once: true });
       }
       if (config.timeoutMs !== void 0 && config.timeoutMs > 0) {
         timeout = setTimeout(
-          () => rejectWithError(`Speech synthesis timed out after ${config.timeoutMs} ms.`),
+          () => rejectWithError(new SynthesisTimeoutError(`Speech synthesis timed out after ${config.timeoutMs} ms.`)),
           config.timeoutMs
         );
       }
@@ -213,60 +483,117 @@ async function synthesizeSsml(ssml, config) {
 async function synthesizeSsmlChunks(chunks, config) {
   const results = [];
   const totalChunks = chunks.length;
+  const report = (event) => config.onProgress?.(event);
   for (const [index, chunk] of chunks.entries()) {
     const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
-    const result = await synthesizeSsml(input.ssml, {
-      ...config,
-      ...input.originalTextRange ? { sourceTextRange: input.originalTextRange } : {},
-      onProgress: void 0
+    report({
+      currentChunk: index,
+      totalChunks,
+      percent: totalChunks === 0 ? 100 : Math.round(index / totalChunks * 100),
+      chunkIndex: index,
+      originalTextRange: input.originalTextRange,
+      status: "pending",
+      durationMs: 0
     });
-    results.push(result);
-    config.onProgress?.({
-      currentChunk: index + 1,
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
+    report({
+      currentChunk: index,
       totalChunks,
-      percent: totalChunks === 0 ? 100 : Math.round((index + 1) / totalChunks * 100)
+      percent: totalChunks === 0 ? 100 : Math.round(index / totalChunks * 100),
+      chunkIndex: index,
+      originalTextRange: input.originalTextRange,
+      status: "synthesizing",
+      durationMs: 0
     });
+    const startedAt = Date.now();
+    try {
+      const result = await synthesizeSsml(input.ssml, {
+        ...config,
+        ...input.originalTextRange ? { sourceTextRange: input.originalTextRange } : {},
+        ...input.sourceNodePath ?? config.sourceNodePath ? { sourceNodePath: [...input.sourceNodePath ?? config.sourceNodePath ?? []] } : {},
+        ...input.sourceTextSegments ? { sourceTextSegments: input.sourceTextSegments } : {},
+        ...input.sourceMarkers ? { sourceMarkers: input.sourceMarkers } : {},
+        chunkIndex: index,
+        onProgress: void 0
+      });
+      results.push(result);
+      report({
+        currentChunk: index + 1,
+        totalChunks,
+        percent: totalChunks === 0 ? 100 : Math.round((index + 1) / totalChunks * 100),
+        chunkIndex: index,
+        originalTextRange: input.originalTextRange,
+        status: "success",
+        durationMs: Date.now() - startedAt
+      });
+    } catch (error) {
+      report({
+        currentChunk: index,
+        totalChunks,
+        percent: totalChunks === 0 ? 100 : Math.round(index / totalChunks * 100),
+        chunkIndex: index,
+        originalTextRange: input.originalTextRange,
+        status: "failed",
+        durationMs: Date.now() - startedAt,
+        error
+      });
+      throw error;
+    }
   }
-  return mergeSynthesisResults(results);
+  return mergeSynthesisResults(results, {
+    format: config.outputFormat ?? "audio-16khz-128kbitrate-mono-mp3"
+  });
 }
-function mergeSynthesisResults(results) {
-  const audioLength = results.reduce((total, result) => total + result.audioData.byteLength, 0);
-  const audioData = new Uint8Array(audioLength);
+function createMergedResult(results, audioData, format) {
   const boundaries = [];
   const visemes = [];
   const bookmarks = [];
-  let byteOffset = 0;
   let durationOffset = 0;
-  for (const result of results) {
-    audioData.set(new Uint8Array(result.audioData), byteOffset);
-    byteOffset += result.audioData.byteLength;
+  for (const [resultIndex, result] of results.entries()) {
     const chunkBoundaries = result.boundaries && result.boundaries.length > 0 ? result.boundaries : result.wordBoundary ?? result.wordBoundaries ?? [];
     for (const boundary of chunkBoundaries) {
       const textRange = boundary.textRange ?? result.textRange;
+      const originalTextRange = boundary.originalTextRange ?? textRange;
       const requestId = boundary.requestId ?? result.requestId;
       boundaries.push({
         ...boundary,
         audioOffsetMs: boundary.audioOffsetMs + durationOffset,
+        chunkAudioOffsetMs: boundary.chunkAudioOffsetMs ?? boundary.audioOffsetMs,
+        ...boundary.chunkIndex === void 0 ? { chunkIndex: resultIndex } : {},
+        ...boundary.sourceNodePath ? { sourceNodePath: [...boundary.sourceNodePath] } : {},
+        ...originalTextRange ? { originalTextRange: { ...originalTextRange } } : {},
         ...textRange ? { textRange: { ...textRange } } : {},
         ...requestId ? { requestId } : {}
       });
     }
     for (const viseme of result.visemes ?? []) {
       const textRange = viseme.textRange ?? result.textRange;
+      const originalTextRange = viseme.originalTextRange ?? textRange;
       const requestId = viseme.requestId ?? result.requestId;
       visemes.push({
         ...viseme,
         audioOffsetMs: viseme.audioOffsetMs + durationOffset,
+        chunkAudioOffsetMs: viseme.chunkAudioOffsetMs ?? viseme.audioOffsetMs,
+        ...viseme.chunkIndex === void 0 ? { chunkIndex: resultIndex } : {},
+        ...viseme.sourceNodePath ? { sourceNodePath: [...viseme.sourceNodePath] } : {},
+        ...originalTextRange ? { originalTextRange: { ...originalTextRange } } : {},
         ...textRange ? { textRange: { ...textRange } } : {},
         ...requestId ? { requestId } : {}
       });
     }
     for (const bookmark of result.bookmarks ?? []) {
       const textRange = bookmark.textRange ?? result.textRange;
+      const originalTextRange = bookmark.originalTextRange ?? textRange;
       const requestId = bookmark.requestId ?? result.requestId;
       bookmarks.push({
         ...bookmark,
         audioOffsetMs: bookmark.audioOffsetMs + durationOffset,
+        chunkAudioOffsetMs: bookmark.chunkAudioOffsetMs ?? bookmark.audioOffsetMs,
+        ...bookmark.chunkIndex === void 0 ? { chunkIndex: resultIndex } : {},
+        ...bookmark.sourceNodePath ? { sourceNodePath: [...bookmark.sourceNodePath] } : {},
+        ...originalTextRange ? { originalTextRange: { ...originalTextRange } } : {},
         ...textRange ? { textRange: { ...textRange } } : {},
         ...requestId ? { requestId } : {}
       });
@@ -274,8 +601,9 @@ function mergeSynthesisResults(results) {
     durationOffset += Math.max(0, result.durationMs);
   }
   return {
-    audioData: audioData.buffer,
+    audioData,
     durationMs: durationOffset,
+    mimeType: resolveMimeType(format),
     ...boundaries.length > 0 ? { boundaries, wordBoundary: boundaries, wordBoundaries: boundaries } : {},
     ...visemes.length > 0 ? { visemes } : {},
     ...bookmarks.length > 0 ? { bookmarks } : {},
@@ -283,35 +611,225 @@ function mergeSynthesisResults(results) {
     ...results.length === 1 && results[0]?.textRange ? { textRange: { ...results[0].textRange } } : {}
   };
 }
+function mergeSynthesisResults(results, options) {
+  const resolvedOptions = typeof options === "string" ? { format: options } : options;
+  const format = resolvedOptions?.format;
+  if (!format) throw new UnsupportedMergeFormatError("");
+  const buffers = results.map((result) => result.audioData);
+  if (resolvedOptions.customMerger) {
+    return Promise.resolve().then(() => resolvedOptions.customMerger?.(buffers, format)).then((merged) => {
+      if (!merged) throw new MergeError("The custom audio merger returned no audio buffer.");
+      return createMergedResult(results, merged, format);
+    }).catch((error) => {
+      if (error instanceof UnsupportedMergeFormatError || error instanceof MergeError) throw error;
+      throw new MergeError(`Custom audio merger failed for format "${format}".`, error);
+    });
+  }
+  try {
+    return createMergedResult(results, mergeAudioBuffers(buffers, { format }), format);
+  } catch (error) {
+    if (error instanceof UnsupportedMergeFormatError || error instanceof MergeError) throw error;
+    throw new MergeError(`Audio buffers could not be merged for format "${format}".`, error);
+  }
+}
 async function synthesizeSpeech(ssml, config) {
   return (await synthesizeSsml(ssml, config)).audioData;
 }
 
 // src/safe.ts
 import { validateAzureSsml } from "@ssml-builder-js/ssml-core";
+var ChunkValidationError = class extends Error {
+  constructor(chunkIndex, diagnostics) {
+    super(`SSML validation failed for chunk ${chunkIndex}; the Azure Speech API was not called.`);
+    this.kind = "validation-error";
+    this.name = "ChunkValidationError";
+    this.chunkIndex = chunkIndex;
+    this.diagnostics = diagnostics;
+  }
+};
+function failure(error) {
+  return { ok: false, success: false, status: error.kind, error };
+}
 async function synthesizeSsmlSafe(client, ssml, options = {}) {
-  const validationOptions = options.validation ?? options;
+  const validationOptions = withValidationSignal(options.validation ?? options, options.signal);
   const diagnostics = await Promise.resolve(validateAzureSsml(ssml, validationOptions));
+  if (options.signal?.aborted) {
+    const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+    return failure(error);
+  }
   const errors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
   if (errors.length > 0) {
+    return failure({
+      kind: "validation-error",
+      message: "SSML validation failed; the Azure Speech API was not called.",
+      diagnostics: errors
+    });
+  }
+  try {
     return {
-      ok: false,
-      success: false,
-      status: "validation-error",
-      error: {
-        kind: "validation",
-        message: "SSML validation failed; the Azure Speech API was not called.",
-        diagnostics: errors
-      }
+      ok: true,
+      success: true,
+      status: "success",
+      value: await client.synthesizeSsml(ssml, { signal: options.signal })
     };
+  } catch (error) {
+    const synthesisError = toSynthesisError(error);
+    return failure(synthesisError);
+  }
+}
+async function synthesizeSsmlChunksSafe(client, chunks, options = {}) {
+  const validationOptions = withValidationSignal(options.validation ?? options, options.signal);
+  if (options.signal?.aborted) {
+    const error = toSynthesisError(new Error("Speech synthesis was cancelled."));
+    return failure(error);
+  }
+  const pending = (index, status, error) => {
+    options.onProgress?.({
+      currentChunk: status === "success" ? index + 1 : index,
+      totalChunks: chunks.length,
+      percent: chunks.length === 0 ? 100 : Math.round((status === "success" ? index + 1 : index) / chunks.length * 100),
+      chunkIndex: index,
+      originalTextRange: typeof chunks[index] === "string" ? void 0 : chunks[index]?.originalTextRange,
+      status,
+      durationMs: 0,
+      ...error ? { error } : {}
+    });
+  };
+  chunks.forEach((_chunk, index) => {
+    pending(index, "pending");
+  });
+  const validations = await Promise.all(
+    chunks.map(async (chunk) => {
+      const ssml = typeof chunk === "string" ? chunk : chunk.ssml;
+      const sourceNodePath = typeof chunk === "string" ? options.sourceNodePath : chunk.sourceNodePath ?? options.sourceNodePath;
+      const diagnostics = await Promise.resolve(
+        validateAzureSsml(ssml, { ...validationOptions, ...sourceNodePath ? { sourceNodePath } : {} })
+      );
+      return diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+    })
+  );
+  const firstInvalidIndex = validations.findIndex((diagnostics) => diagnostics.length > 0);
+  if (firstInvalidIndex >= 0) {
+    const error = new ChunkValidationError(firstInvalidIndex, validations[firstInvalidIndex] ?? []);
+    pending(firstInvalidIndex, "failed", error);
+    return failure(error);
   }
   try {
-    return { ok: true, success: true, status: "success", value: await client.synthesizeSsml(ssml) };
+    if (client.synthesizeChunks) {
+      const normalizedChunks = chunks.map((chunk) => {
+        if (typeof chunk === "string" || chunk.sourceNodePath || !options.sourceNodePath) return chunk;
+        return { ...chunk, sourceNodePath: [...options.sourceNodePath] };
+      });
+      const value = await client.synthesizeChunks(normalizedChunks, {
+        onProgress: options.onProgress,
+        outputFormat: options.outputFormat,
+        signal: options.signal,
+        timeoutMs: options.timeoutMs,
+        sourceNodePath: options.sourceNodePath
+      });
+      return { ok: true, success: true, status: "success", value };
+    }
+    const results = [];
+    for (const [index, chunk] of chunks.entries()) {
+      const input = typeof chunk === "string" ? { ssml: chunk } : chunk;
+      const sourceNodePath = input.sourceNodePath;
+      const originalTextRange = input.originalTextRange;
+      pending(index, "synthesizing");
+      const startedAt = Date.now();
+      try {
+        const result = await client.synthesizeSsml(input.ssml, {
+          outputFormat: options.outputFormat,
+          signal: options.signal,
+          timeoutMs: options.timeoutMs,
+          sourceNodePath: input.sourceNodePath ?? options.sourceNodePath
+        });
+        results.push({
+          ...result,
+          ...input.originalTextRange ? { textRange: { ...input.originalTextRange } } : {},
+          ...sourceNodePath ? {
+            boundaries: result.boundaries?.map((event) => ({
+              ...event,
+              sourceNodePath: [...sourceNodePath],
+              ...event.originalTextRange ? { originalTextRange: { ...event.originalTextRange } } : input.originalTextRange ? { originalTextRange: { ...input.originalTextRange } } : {}
+            })),
+            visemes: result.visemes?.map((event) => ({
+              ...event,
+              sourceNodePath: [...sourceNodePath],
+              ...event.originalTextRange ? { originalTextRange: { ...event.originalTextRange } } : input.originalTextRange ? { originalTextRange: { ...input.originalTextRange } } : {}
+            })),
+            bookmarks: result.bookmarks?.map((event) => ({
+              ...event,
+              sourceNodePath: [...sourceNodePath],
+              ...event.originalTextRange ? { originalTextRange: { ...event.originalTextRange } } : input.originalTextRange ? { originalTextRange: { ...input.originalTextRange } } : {}
+            }))
+          } : {},
+          ...originalTextRange ? {
+            boundaries: result.boundaries?.map((event) => ({
+              ...event,
+              originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+            })),
+            wordBoundary: result.wordBoundary?.map((event) => ({
+              ...event,
+              originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+            })),
+            wordBoundaries: result.wordBoundaries?.map((event) => ({
+              ...event,
+              originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+            })),
+            visemes: result.visemes?.map((event) => ({
+              ...event,
+              originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+            })),
+            bookmarks: result.bookmarks?.map((event) => ({
+              ...event,
+              originalTextRange: event.originalTextRange ? { ...event.originalTextRange } : { ...originalTextRange }
+            }))
+          } : {}
+        });
+        options.onProgress?.({
+          currentChunk: index + 1,
+          totalChunks: chunks.length,
+          percent: chunks.length === 0 ? 100 : Math.round((index + 1) / chunks.length * 100),
+          chunkIndex: index,
+          originalTextRange: input.originalTextRange,
+          status: "success",
+          durationMs: Date.now() - startedAt
+        });
+      } catch (error) {
+        options.onProgress?.({
+          currentChunk: index,
+          totalChunks: chunks.length,
+          percent: chunks.length === 0 ? 100 : Math.round(index / chunks.length * 100),
+          chunkIndex: index,
+          originalTextRange: input.originalTextRange,
+          status: "failed",
+          durationMs: Date.now() - startedAt,
+          error
+        });
+        throw error;
+      }
+    }
+    return {
+      ok: true,
+      success: true,
+      status: "success",
+      value: mergeSynthesisResults(results, {
+        format: options.outputFormat ?? "audio-16khz-128kbitrate-mono-mp3"
+      })
+    };
   } catch (error) {
-    const azureError = error instanceof AzureTtsError ? error : createSpeechSdkError(error);
-    return { ok: false, success: false, status: "azure-api-error", error: azureError };
+    const synthesisError = toSynthesisError(error);
+    return failure(synthesisError);
   }
 }
+function withValidationSignal(options, signal) {
+  if (!signal) return options;
+  return {
+    ...options,
+    urlValidatorSignal: signal,
+    urlValidation: { ...options.urlValidation ?? {}, signal }
+  };
+}
 
 // src/client.ts
 var ENDPOINT_TEMPLATE = "https://{region}.tts.speech.microsoft.com/cognitiveservices/v1";
@@ -328,11 +846,21 @@ var AzureTtsClient = class {
     const config = { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs };
     return synthesizeSpeech(ssml, config);
   }
-  async synthesizeSsml(ssml) {
+  async synthesizeSsml(ssml, options = {}) {
     const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
     const endpoint = __privateGet(this, _options).endpoint?.trim() || ENDPOINT_TEMPLATE.replace("{region}", region);
     __privateGet(this, _options).logger?.debug?.("Using Azure TTS endpoint:", endpoint);
-    return synthesizeSsml(ssml, { endpoint, region, subscriptionKey, outputFormat, signal, timeoutMs });
+    return synthesizeSsml(ssml, {
+      endpoint,
+      region,
+      subscriptionKey,
+      outputFormat: options.outputFormat ?? outputFormat,
+      signal: options.signal ?? signal,
+      timeoutMs: options.timeoutMs ?? timeoutMs,
+      sourceNodePath: options.sourceNodePath,
+      sourceTextSegments: options.sourceTextSegments,
+      sourceMarkers: options.sourceMarkers
+    });
   }
   async synthesizeChunks(chunks, options = {}) {
     const { region, subscriptionKey, outputFormat, signal, timeoutMs } = __privateGet(this, _options);
@@ -341,15 +869,28 @@ var AzureTtsClient = class {
       endpoint,
       region,
       subscriptionKey,
-      outputFormat,
-      signal,
-      timeoutMs,
+      outputFormat: options.outputFormat ?? outputFormat,
+      signal: options.signal ?? signal,
+      timeoutMs: options.timeoutMs ?? timeoutMs,
+      sourceNodePath: options.sourceNodePath,
       onProgress: options.onProgress ?? __privateGet(this, _options).onProgress
     });
   }
   async synthesizeSsmlSafe(ssml, options = {}) {
     return synthesizeSsmlSafe(this, ssml, options);
   }
+  async synthesizeChunksSafe(chunks, options = {}) {
+    return synthesizeSsmlChunksSafe(this, chunks, {
+      ...options,
+      outputFormat: options.outputFormat ?? __privateGet(this, _options).outputFormat,
+      signal: options.signal ?? __privateGet(this, _options).signal,
+      timeoutMs: options.timeoutMs ?? __privateGet(this, _options).timeoutMs,
+      onProgress: options.onProgress ?? __privateGet(this, _options).onProgress
+    });
+  }
+  async synthesizeSsmlChunksSafe(chunks, options = {}) {
+    return this.synthesizeChunksSafe(chunks, options);
+  }
 };
 _options = new WeakMap();
 
@@ -405,6 +946,9 @@ async function fetchAzureVoiceCatalog(options) {
       const secondaryLocales = stringList(record.SecondaryLocaleList);
       const styles = stringList(record.StyleList);
       const status = normalizeStatus(record.Status);
+      const supportedTags = stringList(record.SupportedTags);
+      const unsupportedTags = stringList(record.UnsupportedTags);
+      const models = stringList(record.Models);
       const merged = {
         name: existing?.name ?? name,
         locale: existing?.locale ?? locale,
@@ -414,6 +958,12 @@ async function fetchAzureVoiceCatalog(options) {
       if (mergedSecondaryLocales.length > 0) merged.secondaryLocales = mergedSecondaryLocales;
       const mergedStyles = [.../* @__PURE__ */ new Set([...existing?.styles ?? [], ...styles])];
       if (mergedStyles.length > 0) merged.styles = mergedStyles;
+      const mergedSupportedTags = [.../* @__PURE__ */ new Set([...existing?.supportedTags ?? [], ...supportedTags])];
+      if (mergedSupportedTags.length > 0) merged.supportedTags = mergedSupportedTags;
+      const mergedUnsupportedTags = [.../* @__PURE__ */ new Set([...existing?.unsupportedTags ?? [], ...unsupportedTags])];
+      if (mergedUnsupportedTags.length > 0) merged.unsupportedTags = mergedUnsupportedTags;
+      const mergedModels = [.../* @__PURE__ */ new Set([...existing?.models ?? [], ...models])];
+      if (mergedModels.length > 0) merged.models = mergedModels;
       if (status) merged.status = status;
       else if (existing?.status) merged.status = existing.status;
       voices.set(key, merged);
@@ -434,11 +984,22 @@ export {
   AzureTtsClient,
   AzureTtsError,
   AzureTtsSdkError,
+  ChunkValidationError,
+  DEFAULT_OUTPUT_FORMAT,
+  MergeError,
+  SynthesisCancelledError,
+  SynthesisTimeoutError,
+  UnsupportedMergeFormatError,
+  canMergeAudioFormat,
   fetchAzureVoiceCatalog,
+  mergeAudioBuffers,
   mergeSynthesisResults,
+  resolveMergeAudioFormat,
+  resolveMimeType,
   synthesizeSpeech,
   synthesizeSsml,
   synthesizeSsmlChunks,
+  synthesizeSsmlChunksSafe,
   synthesizeSsmlSafe
 };
 //# sourceMappingURL=index.mjs.map