ssml-builder-js 2.8.1 → 2.9.0

package/dist/core.js

@@ -31,12 +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);
 
@@ -73,7 +78,13 @@ var SSML_TAGS = {
   SILENCE: "silence",
   MSTTS_VISEME: "mstts:viseme",
   VISEME: "viseme",
-  MSTTS_AUDIO_DURATION: "mstts:audioduration"
+  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",
@@ -82,6 +93,7 @@ var SSML_ATTRS = {
   LANG: "lang",
   MSTTS_XMLNS: "xmlns:mstts",
   NAME: "name",
+  VOICE: "voice",
   EFFECT: "effect",
   RATE: "rate",
   PITCH: "pitch",
@@ -113,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
@@ -205,6 +219,20 @@ function getAttributes(element) {
     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:
@@ -771,6 +799,40 @@ function convertElement(node) {
       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,
@@ -1045,6 +1107,283 @@ 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"] },
@@ -1259,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;
@@ -1402,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())
@@ -1521,29 +1919,33 @@ function validateElement(token, source, diagnostics, voiceName, options, voiceCa
       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 = {}) {
@@ -1609,22 +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