ssml-builder-js 2.8.0 → 2.9.0

package/dist/core.js

@@ -31,11 +31,17 @@ __export(core_exports, {
   buildPartialSsml: () => buildPartialSsml,
   buildSsml: () => buildSsml,
   extractSsmlText: () => extractSsmlText,
+  extractSsmlTranslatableText: () => extractSsmlTranslatableText,
+  fromPlainTextToSsml: () => fromPlainTextToSsml,
+  getAzureVoiceCatalogMetadata: () => getAzureVoiceCatalogMetadata,
+  getBuiltInVoiceCatalogMetadata: () => getBuiltInVoiceCatalogMetadata,
+  isValidAzureAudioDuration: () => isValidAzureAudioDuration,
   mapSsmlTextNodes: () => mapSsmlTextNodes,
   normalizeAzureLanguage: () => normalizeAzureLanguage,
   parseSsml: () => parseSsml,
   validateAzureSsml: () => validateAzureSsml,
-  validateSsml: () => validateSsml
+  validateSsml: () => validateSsml,
+  validateSsmlStructureIntegrity: () => validateSsmlStructureIntegrity
 });
 module.exports = __toCommonJS(core_exports);
 
@@ -71,7 +77,14 @@ var SSML_TAGS = {
   MSTTS_SILENCE: "mstts:silence",
   SILENCE: "silence",
   MSTTS_VISEME: "mstts:viseme",
-  VISEME: "viseme"
+  VISEME: "viseme",
+  MSTTS_AUDIO_DURATION: "mstts:audioduration",
+  MSTTS_DIALOG: "mstts:dialog",
+  MSTTS_TURN: "mstts:turn",
+  MSTTS_BACKGROUND_AUDIO: "mstts:backgroundaudio",
+  MSTTS_TTS_EMBEDDING: "mstts:ttsembedding",
+  MSTTS_EMBEDDING: "mstts:embedding",
+  MSTTS_VOICE_CONVERSION: "mstts:voiceconversion"
 };
 var SSML_ATTRS = {
   VERSION: "version",
@@ -80,6 +93,7 @@ var SSML_ATTRS = {
   LANG: "lang",
   MSTTS_XMLNS: "xmlns:mstts",
   NAME: "name",
+  VOICE: "voice",
   EFFECT: "effect",
   RATE: "rate",
   PITCH: "pitch",
@@ -111,7 +125,9 @@ var SSML_ATTRS = {
   MARK: "mark",
   URI: "uri",
   TYPE: "type",
-  VALUE: "value"
+  VALUE: "value",
+  FADE_IN: "fadein",
+  FADE_OUT: "fadeout"
 };
 
 // packages/ssml-core/src/builder.ts
@@ -200,6 +216,23 @@ function getAttributes(element) {
     case SSML_TAGS.VISEME:
       addAttribute(attributes, SSML_ATTRS.TYPE, element.typeValue ?? element.visemeType);
       break;
+    case SSML_TAGS.MSTTS_AUDIO_DURATION:
+      addAttribute(attributes, SSML_ATTRS.VALUE, element.value);
+      break;
+    case SSML_TAGS.MSTTS_TURN:
+      addAttribute(attributes, SSML_ATTRS.VOICE, element.voice);
+      break;
+    case SSML_TAGS.MSTTS_BACKGROUND_AUDIO:
+      addAttribute(attributes, SSML_ATTRS.SRC, element.src);
+      addAttribute(attributes, SSML_ATTRS.VOLUME, element.volume);
+      addAttribute(attributes, SSML_ATTRS.FADE_IN, element.fadeIn ?? element.fadein);
+      addAttribute(attributes, SSML_ATTRS.FADE_OUT, element.fadeOut ?? element.fadeout);
+      break;
+    case SSML_TAGS.MSTTS_DIALOG:
+    case SSML_TAGS.MSTTS_TTS_EMBEDDING:
+    case SSML_TAGS.MSTTS_EMBEDDING:
+    case SSML_TAGS.MSTTS_VOICE_CONVERSION:
+      break;
     case SSML_TAGS.PARAGRAPH:
     case SSML_TAGS.SENTENCE:
     case SSML_TAGS.WORD:
@@ -224,6 +257,8 @@ function getTagName(element) {
     case SSML_TAGS.VISEME:
     case SSML_TAGS.MSTTS_VISEME:
       return SSML_TAGS.MSTTS_VISEME;
+    case SSML_TAGS.MSTTS_AUDIO_DURATION:
+      return SSML_TAGS.MSTTS_AUDIO_DURATION;
     case "element":
     case "custom":
       return element.name;
@@ -758,6 +793,46 @@ function convertElement(node) {
       if (typeValue !== void 0) element.typeValue = typeValue;
       return finishElement(element, node, attributes);
     }
+    case SSML_TAGS.MSTTS_AUDIO_DURATION: {
+      const element = { type: SSML_TAGS.MSTTS_AUDIO_DURATION };
+      const value = readAttribute(attributes, SSML_ATTRS.VALUE);
+      if (value !== void 0) element.value = value;
+      return finishElement(element, node, attributes);
+    }
+    case SSML_TAGS.MSTTS_DIALOG: {
+      const element = { type: SSML_TAGS.MSTTS_DIALOG };
+      return finishElement(element, node, attributes);
+    }
+    case SSML_TAGS.MSTTS_TURN: {
+      const element = { type: SSML_TAGS.MSTTS_TURN };
+      const voice = readAttribute(attributes, SSML_ATTRS.VOICE);
+      if (voice !== void 0) element.voice = voice;
+      return finishElement(element, node, attributes);
+    }
+    case SSML_TAGS.MSTTS_BACKGROUND_AUDIO: {
+      const element = { type: SSML_TAGS.MSTTS_BACKGROUND_AUDIO };
+      const src = readAttribute(attributes, SSML_ATTRS.SRC);
+      const volume = readAttribute(attributes, SSML_ATTRS.VOLUME);
+      const fadeIn = readAttribute(attributes, SSML_ATTRS.FADE_IN);
+      const fadeOut = readAttribute(attributes, SSML_ATTRS.FADE_OUT);
+      if (src !== void 0) element.src = src;
+      if (volume !== void 0) element.volume = volume;
+      if (fadeIn !== void 0) element.fadeIn = fadeIn;
+      if (fadeOut !== void 0) element.fadeOut = fadeOut;
+      return finishElement(element, node, attributes);
+    }
+    case SSML_TAGS.MSTTS_TTS_EMBEDDING: {
+      const element = { type: SSML_TAGS.MSTTS_TTS_EMBEDDING };
+      return finishElement(element, node, attributes);
+    }
+    case SSML_TAGS.MSTTS_EMBEDDING: {
+      const element = { type: SSML_TAGS.MSTTS_EMBEDDING };
+      return finishElement(element, node, attributes);
+    }
+    case SSML_TAGS.MSTTS_VOICE_CONVERSION: {
+      const element = { type: SSML_TAGS.MSTTS_VOICE_CONVERSION };
+      return finishElement(element, node, attributes);
+    }
     default: {
       const element = {
         name: node.name,
@@ -1032,93 +1107,403 @@ async function mapSsmlTextNodes(ssml, transform, options = {}) {
   return result + ssml.slice(cursor);
 }
 
+// packages/ssml-core/src/migration.ts
+var DEFAULT_TRANSLATION_SKIP_TAGS = ["phoneme", "say-as", "sayAs", "sub"];
+function elementName(element) {
+  switch (element.type) {
+    case "custom":
+    case "element":
+      return element.name;
+    case "expressAs":
+      return "mstts:express-as";
+    case "sayAs":
+      return "say-as";
+    case "silence":
+      return "mstts:silence";
+    case "viseme":
+      return "mstts:viseme";
+    default:
+      return element.type;
+  }
+}
+function addAttribute2(attributes, name, value) {
+  if (value !== void 0) attributes[name] = value;
+}
+function elementAttributes(element) {
+  const attributes = { ...element.attributes ?? {} };
+  switch (element.type) {
+    case "voice":
+      addAttribute2(attributes, "name", element.name);
+      addAttribute2(attributes, "effect", element.effect);
+      break;
+    case "prosody":
+      addAttribute2(attributes, "rate", element.rate);
+      addAttribute2(attributes, "pitch", element.pitch);
+      addAttribute2(attributes, "volume", element.volume);
+      addAttribute2(attributes, "contour", element.contour);
+      addAttribute2(attributes, "range", element.range);
+      break;
+    case "break":
+      addAttribute2(attributes, "time", element.time);
+      addAttribute2(attributes, "strength", element.strength);
+      break;
+    case "express-as":
+    case "expressAs":
+    case "mstts:express-as":
+      addAttribute2(attributes, "style", element.style);
+      addAttribute2(attributes, "styledegree", element.styleDegree);
+      addAttribute2(attributes, "role", element.role);
+      break;
+    case "say-as":
+    case "sayAs":
+      addAttribute2(attributes, "interpret-as", element.interpretAs);
+      addAttribute2(attributes, "format", element.format);
+      addAttribute2(attributes, "detail", element.detail);
+      break;
+    case "phoneme":
+      addAttribute2(attributes, "alphabet", element.alphabet);
+      addAttribute2(attributes, "ph", element.ph);
+      break;
+    case "emphasis":
+      addAttribute2(attributes, "level", element.level);
+      break;
+    case "audio":
+      addAttribute2(attributes, "src", element.src);
+      addAttribute2(attributes, "desc", element.desc);
+      addAttribute2(attributes, "clipBegin", element.clipBegin);
+      addAttribute2(attributes, "clipEnd", element.clipEnd);
+      addAttribute2(attributes, "speed", element.speed);
+      addAttribute2(attributes, "repeatCount", element.repeatCount);
+      addAttribute2(attributes, "repeatDuration", element.repeatDuration);
+      addAttribute2(attributes, "soundLevel", element.soundLevel);
+      break;
+    case "sub":
+      addAttribute2(attributes, "alias", element.alias);
+      break;
+    case "lang":
+      addAttribute2(attributes, "xml:lang", element.lang);
+      break;
+    case "mark":
+      addAttribute2(attributes, "name", element.name);
+      break;
+    case "bookmark":
+      addAttribute2(attributes, "mark", element.mark);
+      break;
+    case "lexicon":
+      addAttribute2(attributes, "uri", element.uri);
+      break;
+    case "mstts:silence":
+    case "silence":
+      addAttribute2(attributes, "type", element.typeValue ?? element.silenceType);
+      addAttribute2(attributes, "value", element.value);
+      break;
+    case "mstts:viseme":
+    case "viseme":
+      addAttribute2(attributes, "type", element.typeValue ?? element.visemeType);
+      break;
+    case "mstts:audioduration":
+      addAttribute2(attributes, "value", element.value);
+      break;
+    case "mstts:turn":
+      addAttribute2(attributes, "voice", element.voice);
+      break;
+    case "mstts:backgroundaudio":
+      addAttribute2(attributes, "src", element.src);
+      addAttribute2(attributes, "volume", element.volume);
+      addAttribute2(attributes, "fadein", element.fadeIn ?? element.fadein);
+      addAttribute2(attributes, "fadeout", element.fadeOut ?? element.fadeout);
+      break;
+  }
+  return Object.fromEntries(Object.entries(attributes).map(([name, value]) => [name, String(value)]));
+}
+function childrenOf(node) {
+  return node.children ?? [];
+}
+function extractSsmlTranslatableText(ssml, options = {}) {
+  const document = parseSsml(ssml);
+  const skipTags = new Set((options.skipTags ?? DEFAULT_TRANSLATION_SKIP_TAGS).map((tag) => tag.toLowerCase()));
+  const result = [];
+  const visit = (nodes, ancestors, path) => {
+    nodes.forEach((node, index) => {
+      if (typeof node === "string") {
+        if (options.includeWhitespace || node.trim().length > 0) {
+          const context = {
+            ancestorTags: [...ancestors],
+            parentAttributes: {},
+            parentTag: ancestors[ancestors.length - 1] ?? "",
+            path: [...path, String(index)]
+          };
+          if (options.filter?.(context) ?? true) result.push(node);
+        }
+        return;
+      }
+      if (node.type === "text") {
+        if (options.includeWhitespace || node.value.trim().length > 0) {
+          const context = {
+            ancestorTags: [...ancestors],
+            parentAttributes: {},
+            parentTag: ancestors[ancestors.length - 1] ?? "",
+            path: [...path, String(index)]
+          };
+          if (options.filter?.(context) ?? true) result.push(node.value);
+        }
+        return;
+      }
+      const tag = elementName(node);
+      if (skipTags.has(tag.toLowerCase())) return;
+      visit(childrenOf(node), [...ancestors, tag], [...path, String(index)]);
+    });
+  };
+  visit(childrenOf(document), ["speak"], []);
+  return result;
+}
+function splitSentences(text) {
+  const sentences = [];
+  let start = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const isTerminator = "\u3002\uFF01\uFF1F!?".includes(character) || character === "." && /\s|$/.test(text[index + 1] ?? "");
+    if (isTerminator) {
+      const value = text.slice(start, index + 1).trim();
+      if (value) sentences.push(value);
+      start = index + 1;
+    }
+  }
+  const tail = text.slice(start).trim();
+  if (tail) sentences.push(tail);
+  return sentences;
+}
+function fromPlainTextToSsml(text, options = {}) {
+  if (typeof text !== "string") throw new TypeError("Plain text must be a string");
+  const paragraphs = text.replace(/\r\n?/g, "\n").split(/\n\s*\n/).map((paragraph) => paragraph.replace(/\s*\n\s*/g, " ").trim()).filter(Boolean);
+  const useSentences = options.splitSentences ?? options.includeSentences ?? true;
+  const paragraphNodes = paragraphs.map((paragraph) => ({
+    type: "p",
+    children: useSentences ? splitSentences(paragraph).map((sentence) => ({ type: "s", children: [sentence] })) : [paragraph]
+  }));
+  const voiceName = options.voice ?? options.voiceName;
+  const children = voiceName ? [{ type: "voice", name: voiceName, children: paragraphNodes }] : paragraphNodes;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+${serializeDocument2({
+    version: options.version ?? "1.0",
+    lang: options.lang ?? options.language ?? "en-US",
+    children
+  })}`;
+}
+function serializeDocument2(document) {
+  const attributes = [`version="${document.version}"`, `xml:lang="${document.lang}"`];
+  const serialize = (node) => {
+    if (typeof node === "string") return node.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    if (node.type === "text") return serialize(node.value);
+    const tag = elementName(node);
+    const nodeAttributes = elementAttributes(node);
+    const serializedAttributes = Object.entries(nodeAttributes).map(([name, value]) => ` ${name}="${serialize(value).replace(/"/g, "&quot;")}"`).join("");
+    const children = childrenOf(node).map(serialize).join("");
+    return children ? `<${tag}${serializedAttributes}>${children}</${tag}>` : `<${tag}${serializedAttributes}/>`;
+  };
+  return `<speak ${attributes.join(" ")} xmlns="http://www.w3.org/2001/10/synthesis">${(document.children ?? []).map(serialize).join("")}</speak>`;
+}
+function flatten(document) {
+  const result = [];
+  const visit = (nodes, path) => {
+    nodes.forEach((node, index) => {
+      if (typeof node === "string" || node.type === "text") return;
+      const currentPath = `${path}/${index}`;
+      result.push({ name: elementName(node), attributes: elementAttributes(node), path: currentPath });
+      visit(childrenOf(node), currentPath);
+    });
+  };
+  result.push({ name: "speak", attributes: { version: document.version, "xml:lang": document.lang }, path: "0" });
+  visit(childrenOf(document), "0");
+  return result;
+}
+function validateSsmlStructureIntegrity(originalSsml, translatedSsml) {
+  const mismatches = [];
+  let original;
+  let translated;
+  try {
+    original = parseSsml(originalSsml);
+  } catch (error) {
+    mismatches.push({ kind: "parse", message: `Original SSML cannot be parsed: ${String(error)}`, path: "0" });
+    return {
+      isValid: false,
+      valid: false,
+      errors: mismatches.map((item) => item.message),
+      mismatches,
+      mismatchedTags: []
+    };
+  }
+  try {
+    translated = parseSsml(translatedSsml);
+  } catch (error) {
+    mismatches.push({ kind: "parse", message: `Translated SSML cannot be parsed: ${String(error)}`, path: "0" });
+    return {
+      isValid: false,
+      valid: false,
+      errors: mismatches.map((item) => item.message),
+      mismatches,
+      mismatchedTags: []
+    };
+  }
+  const originalElements = flatten(original);
+  const translatedElements = flatten(translated);
+  const count = Math.max(originalElements.length, translatedElements.length);
+  for (let index = 0; index < count; index += 1) {
+    const originalElement = originalElements[index];
+    const translatedElement = translatedElements[index];
+    if (!originalElement || !translatedElement || originalElement.name !== translatedElement.name) {
+      mismatches.push({
+        kind: "element",
+        message: `SSML element structure differs at index ${index}`,
+        original: originalElement?.name,
+        path: originalElement?.path ?? translatedElement?.path ?? String(index),
+        translated: translatedElement?.name
+      });
+      continue;
+    }
+    const attributeNames = /* @__PURE__ */ new Set([
+      ...Object.keys(originalElement.attributes),
+      ...Object.keys(translatedElement.attributes)
+    ]);
+    for (const attribute of attributeNames) {
+      if (originalElement.attributes[attribute] !== translatedElement.attributes[attribute]) {
+        mismatches.push({
+          kind: "attribute",
+          message: `Attribute ${attribute} differs on <${originalElement.name}>`,
+          original: originalElement.attributes[attribute],
+          path: originalElement.path,
+          translated: translatedElement.attributes[attribute]
+        });
+      }
+    }
+  }
+  const mismatchedTags = [
+    ...new Set(mismatches.flatMap((mismatch) => [mismatch.original, mismatch.translated].filter(Boolean)))
+  ];
+  const errors = mismatches.map((mismatch) => mismatch.message);
+  return { isValid: mismatches.length === 0, valid: mismatches.length === 0, errors, mismatches, mismatchedTags };
+}
+
+// packages/ssml-core/src/generated/azureVoiceDefinitions.ts
+var AZURE_VOICE_DEFINITIONS = [
+  { name: "de-DE-ConradNeural", locale: "de-DE", styles: ["cheerful", "sad"] },
+  { name: "de-DE-KatjaNeural", locale: "de-DE", styles: ["cheerful", "sad"] },
+  { name: "en-US-AndrewNeural", locale: "en-US", styles: ["empathetic", "relieved"] },
+  {
+    name: "en-US-GuyNeural",
+    locale: "en-US",
+    styles: [
+      "angry",
+      "cheerful",
+      "excited",
+      "friendly",
+      "hopeful",
+      "newscast",
+      "sad",
+      "shouting",
+      "terrified",
+      "unfriendly",
+      "whispering"
+    ]
+  },
+  {
+    name: "en-US-JennyMultilingualNeural",
+    locale: "en-US",
+    styles: [
+      "cheerful",
+      "empathetic",
+      "excited",
+      "friendly",
+      "hopeful",
+      "sad",
+      "shouting",
+      "terrified",
+      "unfriendly",
+      "whispering"
+    ]
+  },
+  {
+    name: "en-US-JennyNeural",
+    locale: "en-US",
+    styles: [
+      "assistant",
+      "chat",
+      "customerservice",
+      "newscast",
+      "cheerful",
+      "empathetic",
+      "excited",
+      "friendly",
+      "hopeful",
+      "sad",
+      "shouting",
+      "terrified",
+      "unfriendly",
+      "whispering"
+    ]
+  },
+  { name: "es-ES-ElviraNeural", locale: "es-ES" },
+  { name: "fil-PH-AngeloNeural", locale: "fil-PH" },
+  { name: "fr-FR-DeniseNeural", locale: "fr-FR", styles: ["cheerful", "sad"] },
+  { name: "fr-FR-HenriNeural", locale: "fr-FR", styles: ["cheerful", "sad"] },
+  { name: "id-ID-GadisNeural", locale: "id-ID" },
+  { name: "it-IT-ElsaNeural", locale: "it-IT", styles: ["cheerful", "sad"] },
+  { name: "ja-JP-KeitaNeural", locale: "ja-JP", styles: ["chat"] },
+  { name: "ja-JP-MayuNeural", locale: "ja-JP", styles: ["calm", "cheerful", "sad"] },
+  { name: "ja-JP-NanamiNeural", locale: "ja-JP", styles: ["chat", "customerservice", "cheerful", "whispering", "sad"] },
+  { name: "ko-KR-SunHiNeural", locale: "ko-KR", styles: ["cheerful", "sad"] },
+  { name: "ms-MY-YasminNeural", locale: "ms-MY" },
+  { name: "pt-BR-FranciscaNeural", locale: "pt-BR", styles: ["calm"] },
+  {
+    name: "ru-RU-SvetlanaNeural",
+    locale: "ru-RU",
+    styles: ["cheerful", "sad", "angry", "disgruntled", "embarrassed", "fearful"]
+  },
+  { name: "th-TH-PremwadeeNeural", locale: "th-TH" },
+  { name: "vi-VN-HoaiMyNeural", locale: "vi-VN" },
+  {
+    name: "zh-CN-XiaoxiaoNeural",
+    locale: "zh-CN",
+    styles: [
+      "assistant",
+      "chat",
+      "customerservice",
+      "newscast",
+      "cheerful",
+      "empathetic",
+      "excited",
+      "friendly",
+      "hopeful",
+      "sad",
+      "terrified",
+      "whispering",
+      "poetry-reading",
+      "sports_commentary",
+      "sports_commentary_excited",
+      "story"
+    ]
+  },
+  {
+    name: "zh-CN-YunxiNeural",
+    locale: "zh-CN",
+    styles: [
+      "narration-relaxed",
+      "embarrassed",
+      "fearful",
+      "sad",
+      "disgruntled",
+      "serious",
+      "angry",
+      "depressed",
+      "chat",
+      "cheerful",
+      "assistant"
+    ]
+  },
+  { name: "zh-TW-HsiaoChenNeural", locale: "zh-TW" }
+];
+
 // packages/ssml-core/src/azureValidation.ts
-var EXPRESS_AS_STYLES = {
-  "en-us-jennyneural": [
-    "assistant",
-    "chat",
-    "customerservice",
-    "newscast",
-    "cheerful",
-    "empathetic",
-    "excited",
-    "friendly",
-    "hopeful",
-    "sad",
-    "shouting",
-    "terrified",
-    "unfriendly",
-    "whispering"
-  ],
-  "en-us-guyneural": [
-    "angry",
-    "cheerful",
-    "excited",
-    "friendly",
-    "hopeful",
-    "newscast",
-    "sad",
-    "shouting",
-    "terrified",
-    "unfriendly",
-    "whispering"
-  ],
-  "en-us-jennymultilingualneural": [
-    "cheerful",
-    "empathetic",
-    "excited",
-    "friendly",
-    "hopeful",
-    "sad",
-    "shouting",
-    "terrified",
-    "unfriendly",
-    "whispering"
-  ],
-  "en-us-andrewneural": ["empathetic", "relieved"],
-  "ja-jp-mayuneural": ["calm", "cheerful", "sad"],
-  "ja-jp-nanamineural": ["chat", "customerservice", "cheerful", "whispering", "sad"],
-  "ja-jp-keitaneural": ["chat"],
-  "ko-kr-sunhineural": ["cheerful", "sad"],
-  "zh-cn-yunxineural": [
-    "narration-relaxed",
-    "embarrassed",
-    "fearful",
-    "sad",
-    "disgruntled",
-    "serious",
-    "angry",
-    "depressed",
-    "chat",
-    "cheerful",
-    "assistant"
-  ],
-  "zh-cn-xiaoxiaoneural": [
-    "assistant",
-    "chat",
-    "customerservice",
-    "newscast",
-    "cheerful",
-    "empathetic",
-    "excited",
-    "friendly",
-    "hopeful",
-    "sad",
-    "terrified",
-    "whispering",
-    "poetry-reading",
-    "sports_commentary",
-    "sports_commentary_excited",
-    "story"
-  ],
-  "fr-fr-deniseneural": ["cheerful", "sad"],
-  "fr-fr-henrineural": ["cheerful", "sad"],
-  "pt-br-franciscaneural": ["calm"],
-  "it-it-elsaneural": ["cheerful", "sad"],
-  "de-de-katjaneural": ["cheerful", "sad"],
-  "de-de-conradneural": ["cheerful", "sad"],
-  "ru-ru-svetlananeural": ["cheerful", "sad", "angry", "disgruntled", "embarrassed", "fearful"]
-};
 var ALLOWED_BREAK_STRENGTHS = /* @__PURE__ */ new Set(["none", "x-weak", "weak", "medium", "strong", "x-strong"]);
 var ALLOWED_SAY_AS = /* @__PURE__ */ new Set([
   "characters",
@@ -1213,12 +1598,23 @@ function tokenizeElements(source) {
       attributes.set(match[1].toLowerCase(), decodeAttribute(match[3]));
     }
     const selfClosing = /\/\s*>$/.test(raw);
+    const parent = openElements[openElements.length - 1];
     const parentVoiceName = [...openElements].reverse().find((element) => element.voiceName)?.voiceName;
-    tokens.push({ attributes, end, name: nameMatch[1], parentVoiceName, selfClosing, start });
+    const tokenName = nameMatch[1];
+    const tokenVoiceName = tokenName.toLowerCase() === "voice" ? attributes.get("name") : tokenName.toLowerCase() === "mstts:turn" ? attributes.get("voice") ?? parentVoiceName : parentVoiceName;
+    tokens.push({
+      attributes,
+      end,
+      name: tokenName,
+      parentName: parent?.name,
+      parentVoiceName,
+      selfClosing,
+      start
+    });
     if (!selfClosing) {
       openElements.push({
-        name: nameMatch[1],
-        voiceName: nameMatch[1].toLowerCase() === "voice" ? attributes.get("name") : parentVoiceName
+        name: tokenName,
+        voiceName: tokenVoiceName
       });
     }
     index = end + 1;
@@ -1247,18 +1643,17 @@ function isSupportedProsodyRate(value) {
   const numericValue = Number(multiplier[1]);
   return numericValue >= 0.5 && numericValue <= 2;
 }
+function isValidAzureAudioDuration(value) {
+  const trimmed = value.trim();
+  const numeric = /^(\d+(?:\.\d+)?)(ms|s)$/.exec(trimmed);
+  if (numeric) return Number(numeric[1]) > 0;
+  const clock = /^(\d{2,}):([0-5]\d):([0-5]\d)(?:\.(\d{1,3}))?$/.exec(trimmed);
+  if (!clock) return false;
+  return Number(clock[1]) > 0 || Number(clock[2]) > 0 || Number(clock[3]) > 0 || Number(clock[4] ?? 0) > 0;
+}
 function attr(token, name) {
   return token.attributes.get(name.toLowerCase());
 }
-var ADDITIONAL_VOICE_DEFINITIONS = [
-  { name: "zh-TW-HsiaoChenNeural", locale: "zh-TW" },
-  { name: "es-ES-ElviraNeural", locale: "es-ES" },
-  { name: "th-TH-PremwadeeNeural", locale: "th-TH" },
-  { name: "fil-PH-AngeloNeural", locale: "fil-PH" },
-  { name: "vi-VN-HoaiMyNeural", locale: "vi-VN" },
-  { name: "id-ID-GadisNeural", locale: "id-ID" },
-  { name: "ms-MY-YasminNeural", locale: "ms-MY" }
-];
 var DEFAULT_LANGUAGE_ALIASES = {
   "zh-CN": ["zh-Hans"],
   "zh-TW": ["zh-Hant"]
@@ -1321,10 +1716,7 @@ function definitionFromStyleMap(voiceName, styles) {
 }
 function normalizeVoiceCatalog(options) {
   const definitions = /* @__PURE__ */ new Map();
-  for (const [name, styles] of Object.entries(EXPRESS_AS_STYLES)) {
-    definitions.set(name.toLowerCase(), definitionFromStyleMap(name, styles));
-  }
-  for (const definition of ADDITIONAL_VOICE_DEFINITIONS) definitions.set(definition.name.toLowerCase(), definition);
+  for (const definition of AZURE_VOICE_DEFINITIONS) definitions.set(definition.name.toLowerCase(), definition);
   for (const definition of options.voiceCatalog ?? []) definitions.set(definition.name.toLowerCase(), definition);
   for (const definition of options.voiceDefinitions ?? []) definitions.set(definition.name.toLowerCase(), definition);
   for (const definition of options.customVoiceDefinitions ?? [])
@@ -1360,6 +1752,54 @@ function definitionMatchesLanguage(definition, voiceName, language, normalizeLan
   if (!normalizedLanguage || !normalizedCandidates.some(Boolean)) return void 0;
   return normalizedLanguage === languagePart(normalizedLanguage) ? normalizedCandidates.some((candidate) => languagePart(candidate) === normalizedLanguage) : false;
 }
+function canonicalTagName(name) {
+  const normalized = name.toLowerCase();
+  if (normalized === "express-as" || normalized === "expressas") return "mstts:express-as";
+  if (normalized === "sayas") return "say-as";
+  return normalized;
+}
+function validateVoiceFeatureMatrix(token, source, diagnostics, voiceName, definition) {
+  if (!voiceName || !definition || token.name.toLowerCase() === "voice" || token.name.toLowerCase() === "mstts:turn")
+    return;
+  const tagName = canonicalTagName(token.name);
+  const unsupportedTags = new Set((definition.unsupportedTags ?? []).map(canonicalTagName));
+  const supportedTags = definition.supportedTags?.map(canonicalTagName);
+  if (unsupportedTags.has(tagName) || supportedTags !== void 0 && !supportedTags.includes(tagName)) {
+    addDiagnostic(
+      diagnostics,
+      source,
+      token.start,
+      `Tag <${token.name}> is not supported by voice "${voiceName}" according to the configured feature matrix.`,
+      "error",
+      "azure-unsupported-tag-for-voice"
+    );
+  }
+}
+function validateAudioSource(token, source, diagnostics, options, elementName2) {
+  const src = attr(token, "src");
+  if (!src) {
+    addDiagnostic(diagnostics, source, token.start, `<${elementName2}> requires a "src" attribute.`);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = new URL(src);
+  } catch {
+    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must be an absolute HTTP(S) URL.`);
+    return;
+  }
+  if (parsed.protocol !== "https:" && !(options.allowHttpAudio && parsed.protocol === "http:"))
+    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must use HTTPS.`);
+  if (options.allowedAudioOrigins && !options.allowedAudioOrigins.includes(parsed.origin))
+    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> origin "${parsed.origin}" is not allowed.`);
+  else if (!options.allowExternalAudio)
+    addDiagnostic(
+      diagnostics,
+      source,
+      token.start,
+      `<${elementName2} src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`
+    );
+}
 function validateElement(token, source, diagnostics, voiceName, options, voiceCatalog) {
   const name = token.name.toLowerCase();
   if (name === "voice" && !attr(token, "name")?.trim())
@@ -1461,35 +1901,51 @@ function validateElement(token, source, diagnostics, voiceName, options, voiceCa
     if (!value || !/^\d+(?:\.\d+)?(?:ms|s)$/.test(value.trim()))
       addDiagnostic(diagnostics, source, token.start, '<mstts:silence> requires a time-valued "value" attribute.');
   }
+  if (name === "mstts:audioduration") {
+    const value = attr(token, "value");
+    if (!value || !isValidAzureAudioDuration(value))
+      addDiagnostic(
+        diagnostics,
+        source,
+        token.start,
+        '<mstts:audioduration> requires a positive duration such as "10s", "5000ms", or "00:00:10".'
+      );
+    if (!token.selfClosing)
+      addDiagnostic(diagnostics, source, token.start, "<mstts:audioduration> must be self-closing.");
+  }
   if (name === "mstts:viseme") {
     const type = attr(token, "type");
     if (!type || !ALLOWED_VISEME_TYPES.has(type))
       addDiagnostic(diagnostics, source, token.start, '<mstts:viseme> requires a supported "type" attribute.');
   }
   if (name === "audio") {
-    const src = attr(token, "src");
-    if (!src) addDiagnostic(diagnostics, source, token.start, '<audio> requires a "src" attribute.');
-    else {
-      let parsed;
-      try {
-        parsed = new URL(src);
-      } catch {
-        addDiagnostic(diagnostics, source, token.start, "<audio src> must be an absolute HTTP(S) URL.");
-        return;
-      }
-      if (parsed.protocol !== "https:" && !(options.allowHttpAudio && parsed.protocol === "http:"))
-        addDiagnostic(diagnostics, source, token.start, "<audio src> must use HTTPS.");
-      if (options.allowedAudioOrigins && !options.allowedAudioOrigins.includes(parsed.origin))
-        addDiagnostic(diagnostics, source, token.start, `<audio src> origin "${parsed.origin}" is not allowed.`);
-      else if (!options.allowExternalAudio)
+    validateAudioSource(token, source, diagnostics, options, "audio");
+  }
+  if (name === "mstts:turn") {
+    if (!attr(token, "voice")?.trim())
+      addDiagnostic(diagnostics, source, token.start, '<mstts:turn> requires a non-empty "voice" attribute.');
+    if (token.parentName?.toLowerCase() !== "mstts:dialog")
+      addDiagnostic(diagnostics, source, token.start, "<mstts:turn> is only allowed directly inside <mstts:dialog>.");
+  }
+  if (name === "mstts:backgroundaudio") {
+    validateAudioSource(token, source, diagnostics, options, "mstts:backgroundaudio");
+    const volume = attr(token, "volume");
+    if (volume && !/^(silent|x-soft|soft|medium|loud|x-loud|[+-]?\d+(?:\.\d+)?(?:dB|%))$/i.test(volume.trim()))
+      addDiagnostic(diagnostics, source, token.start, `Unsupported <mstts:backgroundaudio volume> value "${volume}".`);
+    for (const [attribute, value] of [
+      ["fadein", attr(token, "fadein")],
+      ["fadeout", attr(token, "fadeout")]
+    ]) {
+      if (value && !isValidAzureAudioDuration(value))
         addDiagnostic(
           diagnostics,
           source,
           token.start,
-          `<audio src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`,
-          "error"
+          `<mstts:backgroundaudio ${attribute}> must be a positive duration such as "500ms" or "10s".`
         );
     }
+    if (!token.selfClosing)
+      addDiagnostic(diagnostics, source, token.start, "<mstts:backgroundaudio> must be self-closing.");
   }
 }
 function validateAzureSsml(ssml, options = {}) {
@@ -1555,21 +2011,57 @@ function validateAzureSsml(ssml, options = {}) {
       );
   }
   for (const token of tokens) {
-    const tokenVoiceName = options.validateNestedVoices === false ? voiceName : token.parentVoiceName;
+    const tokenName = token.name.toLowerCase();
+    const tokenVoiceName = tokenName === "voice" ? attr(token, "name")?.trim() : tokenName === "mstts:turn" ? attr(token, "voice")?.trim() || token.parentVoiceName : options.validateNestedVoices === false ? voiceName : token.parentVoiceName;
     validateElement(token, ssml, diagnostics, tokenVoiceName, options, voiceCatalog);
+    const definition = tokenVoiceName ? voiceCatalog.get(tokenVoiceName.toLowerCase()) : void 0;
+    validateVoiceFeatureMatrix(token, ssml, diagnostics, tokenVoiceName, definition);
+    if (tokenName === "voice" && options.model && definition?.models && !definition.models.some((model) => model.toLowerCase() === options.model?.toLowerCase())) {
+      addDiagnostic(
+        diagnostics,
+        ssml,
+        token.start,
+        `Voice "${tokenVoiceName}" does not support model "${options.model}" according to the configured feature matrix.`,
+        "error",
+        "azure-unsupported-model-for-voice"
+      );
+    }
   }
   return diagnostics;
 }
+
+// packages/ssml-core/src/generated/azureVoiceCatalog.ts
+var AZURE_VOICE_CATALOG_METADATA = {
+  apiVersion: "2025-10-01",
+  generatedAt: "2026-08-28T00:00:00.000Z",
+  regions: [],
+  voiceCount: AZURE_VOICE_DEFINITIONS.length
+};
+
+// packages/ssml-core/src/voiceCatalog.ts
+function getAzureVoiceCatalogMetadata() {
+  return {
+    ...AZURE_VOICE_CATALOG_METADATA,
+    regions: [...AZURE_VOICE_CATALOG_METADATA.regions]
+  };
+}
+var getBuiltInVoiceCatalogMetadata = getAzureVoiceCatalogMetadata;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   areAzureLanguagesEquivalent,
   buildPartialSsml,
   buildSsml,
   extractSsmlText,
+  extractSsmlTranslatableText,
+  fromPlainTextToSsml,
+  getAzureVoiceCatalogMetadata,
+  getBuiltInVoiceCatalogMetadata,
+  isValidAzureAudioDuration,
   mapSsmlTextNodes,
   normalizeAzureLanguage,
   parseSsml,
   validateAzureSsml,
-  validateSsml
+  validateSsml,
+  validateSsmlStructureIntegrity
 });
 //# sourceMappingURL=core.js.map