ssml-builder-js 2.12.0 → 2.14.0

package/dist/core.d.ts

@@ -188,13 +188,37 @@ interface BuildPartialSsmlOptions extends SsmlPartialContext {
 declare function buildPartialSsml(text: string, context?: SsmlPartialContext): string;
 declare function buildPartialSsml(options: BuildPartialSsmlOptions): string;
 
+interface SsmlTextRange {
+    start: number;
+    end: number;
+}
+interface SsmlChunkContext {
+    voice?: string;
+    lang?: string;
+    prosody?: Record<string, string>;
+}
+interface SsmlChunk {
+    chunkIndex: number;
+    ssml: string;
+    originalTextRange: SsmlTextRange;
+    inheritedContext: SsmlChunkContext;
+    containedMarks: string[];
+    hasBackgroundAudio: boolean;
+    /** Best-effort path to the first source element represented by this chunk. */
+    sourceNodePath?: string[];
+}
+interface SplitSsmlOptions {
+    maxLength?: number;
+    /** Keeps `<mstts:backgroundaudio>` in every chunk instead of the first chunk only. */
+    replicateBackgroundAudio?: boolean;
+}
 /**
  * Splits SSML into independently synthesizable documents without breaking XML
  * elements. Parent elements such as `<voice>` and `<prosody>` are copied into
  * every block. Paragraph and sentence elements therefore remain the natural
  * split points, while oversized text is split at word/character boundaries.
  */
-declare function splitSsmlDocument(ssml: string, maxLength?: number): string[];
+declare function splitSsmlDocument(ssml: string, maxLength?: number | SplitSsmlOptions, options?: SplitSsmlOptions): SsmlChunk[];
 
 declare function parseSsml(xmlString: string): SsmlDocument;
 
@@ -292,6 +316,17 @@ interface AzureValidationOptions {
     allowHttpAudio?: boolean;
     customVoiceStyleMap?: Record<string, readonly string[]>;
     customVoiceDefinitions?: readonly AzureVoiceDefinition[];
+    /** Host-side validation hook for URL-bearing SSML attributes. */
+    urlValidator?: AzureUrlValidator;
+    /** Alias for urlValidator retained for applications that use the longer name. */
+    customUrlValidator?: AzureUrlValidator;
+    /** Controls deduplication, caching, cancellation, and concurrency for URL checks. */
+    urlValidation?: AzureUrlValidationRunnerOptions;
+    /** Flat aliases retained for callers that prefer not to nest URL runner options. */
+    urlValidatorConcurrency?: number;
+    urlValidatorTimeoutMs?: number;
+    urlValidatorSignal?: AbortSignal;
+    urlValidatorCache?: Map<string, AzureUrlValidationResult>;
     languageAliases?: Record<string, string | readonly string[]>;
     maxLength?: number;
     /** Maximum XML element nesting depth, counting `<speak>` as depth 1. */
@@ -311,6 +346,22 @@ interface AzureValidationOptions {
     voiceCatalog?: readonly AzureVoiceDefinition[];
     voiceDefinitions?: readonly AzureVoiceDefinition[];
 }
+type AzureUrlValidationResult = boolean | {
+    valid: boolean;
+    reason?: string;
+};
+type AzureUrlValidator = (url: string, context: {
+    tag: string;
+    attribute: string;
+}) => AzureUrlValidationResult | Promise<AzureUrlValidationResult>;
+interface AzureUrlValidationRunnerOptions {
+    concurrency?: number;
+    cache?: Map<string, AzureUrlValidationResult>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/** Wraps a URL validator with URL deduplication, bounded concurrency, caching, and cancellation. */
+declare function createAzureUrlValidatorRunner(validator: AzureUrlValidator, options?: AzureUrlValidationRunnerOptions): AzureUrlValidator;
 type AzureLanguageNormalizationOptions = Pick<AzureValidationOptions, "languageAliases" | "normalizeLanguage">;
 /** @deprecated Use AzureValidationOptions instead. */
 type AzureSsmlValidationOptions = AzureValidationOptions;
@@ -320,7 +371,15 @@ declare function isValidAzureAudioDuration(value: string): boolean;
 declare function normalizeAzureLanguage(language: string, options?: AzureLanguageNormalizationOptions): string;
 /** Compares two Azure language tags after BCP 47 and alias normalization. */
 declare function areAzureLanguagesEquivalent(first: string, second: string, options?: AzureLanguageNormalizationOptions): boolean;
-declare function validateAzureSsml(ssml: string, options?: AzureValidationOptions): SsmlDiagnostic[];
+/**
+ * Validates Azure SSML synchronously unless a URL validator is supplied. URL
+ * validation is asynchronous-capable so hosts can perform DNS/private-network checks.
+ */
+declare function validateAzureSsml(ssml: string, options?: Omit<AzureValidationOptions, "urlValidator" | "customUrlValidator">): SsmlDiagnostic[];
+declare function validateAzureSsml(ssml: string, options: AzureValidationOptions & {
+    urlValidator?: AzureUrlValidator;
+    customUrlValidator?: AzureUrlValidator;
+}): SsmlDiagnostic[] | Promise<SsmlDiagnostic[]>;
 
 interface AzureVoiceCatalogMetadata {
     apiVersion: string;
@@ -334,4 +393,4 @@ declare function getAzureVoiceCatalogMetadata(): AzureVoiceCatalogMetadata;
 /** Alias for consumers that refer to the bundled catalog as the built-in catalog. */
 declare const getBuiltInVoiceCatalogMetadata: typeof getAzureVoiceCatalogMetadata;
 
-export { type AudioElement, type AzureDiagnosticCode, type AzureLanguageNormalizationOptions, type AzureSsmlValidationOptions, type AzureValidationOptions, type AzureVoiceCatalogMetadata, type AzureVoiceDefinition, type AzureVoiceMetadata, type BookmarkElement, type BreakElement, type BuildPartialSsmlOptions, type CustomElement, type EmphasisElement, type ExpressAsElement, type ExtractSsmlTranslatableTextOptions, type FromPlainTextToSsmlOptions, type LangElement, type LexiconElement, type MapSsmlTextNodesOptions, type MarkElement, type MsttsAudioDurationElement, type MsttsEmbeddingElement, type MsttsSilenceElement, type MsttsTtsEmbeddingElement, type MsttsVisemeElement, type MsttsVoiceConversionElement, type NamedElement, type ParagraphElement, type PhonemeElement, type ProsodyElement, type SayAsElement, type SentenceElement, type SsmlAttributeValue, type SsmlAttributes, type SsmlBackgroundAudioNode, type SsmlBreakElement, type SsmlDiagnostic, type SsmlDiagnosticSeverity, type SsmlDiagnosticSource, type SsmlDialogNode, type SsmlDocument, type SsmlElement, type SsmlElementBase, type SsmlEmbeddingNode, type SsmlExpressAsElement, type SsmlNode, type SsmlPartialContext, type SsmlPartialProsody, type SsmlPartialVoice, type SsmlPhonemeElement, type SsmlProsodyElement, type SsmlSayAsElement, type SsmlStructureIntegrityResult, type SsmlStructureMismatch, type SsmlText, type SsmlTextNodeContext, type SsmlTtsEmbeddingNode, type SsmlTurnNode, type SsmlValidationError, type SsmlVoiceConversionNode, type SsmlVoiceElement, type SubElement, type VoiceElement, type WordElement, areAzureLanguagesEquivalent, buildPartialSsml, buildSsml, extractSsmlText, extractSsmlTranslatableText, fromPlainTextToSsml, getAzureVoiceCatalogMetadata, getBuiltInVoiceCatalogMetadata, isValidAzureAudioDuration, mapSsmlTextNodes, normalizeAzureLanguage, parseSsml, splitSsmlDocument, validateAzureSsml, validateSsml, validateSsmlStructureIntegrity };
+export { type AudioElement, type AzureDiagnosticCode, type AzureLanguageNormalizationOptions, type AzureSsmlValidationOptions, type AzureUrlValidationResult, type AzureUrlValidationRunnerOptions, type AzureUrlValidator, type AzureValidationOptions, type AzureVoiceCatalogMetadata, type AzureVoiceDefinition, type AzureVoiceMetadata, type BookmarkElement, type BreakElement, type BuildPartialSsmlOptions, type CustomElement, type EmphasisElement, type ExpressAsElement, type ExtractSsmlTranslatableTextOptions, type FromPlainTextToSsmlOptions, type LangElement, type LexiconElement, type MapSsmlTextNodesOptions, type MarkElement, type MsttsAudioDurationElement, type MsttsEmbeddingElement, type MsttsSilenceElement, type MsttsTtsEmbeddingElement, type MsttsVisemeElement, type MsttsVoiceConversionElement, type NamedElement, type ParagraphElement, type PhonemeElement, type ProsodyElement, type SayAsElement, type SentenceElement, type SplitSsmlOptions, type SsmlAttributeValue, type SsmlAttributes, type SsmlBackgroundAudioNode, type SsmlBreakElement, type SsmlChunk, type SsmlChunkContext, type SsmlDiagnostic, type SsmlDiagnosticSeverity, type SsmlDiagnosticSource, type SsmlDialogNode, type SsmlDocument, type SsmlElement, type SsmlElementBase, type SsmlEmbeddingNode, type SsmlExpressAsElement, type SsmlNode, type SsmlPartialContext, type SsmlPartialProsody, type SsmlPartialVoice, type SsmlPhonemeElement, type SsmlProsodyElement, type SsmlSayAsElement, type SsmlStructureIntegrityResult, type SsmlStructureMismatch, type SsmlText, type SsmlTextNodeContext, type SsmlTextRange, type SsmlTtsEmbeddingNode, type SsmlTurnNode, type SsmlValidationError, type SsmlVoiceConversionNode, type SsmlVoiceElement, type SubElement, type VoiceElement, type WordElement, areAzureLanguagesEquivalent, buildPartialSsml, buildSsml, createAzureUrlValidatorRunner, extractSsmlText, extractSsmlTranslatableText, fromPlainTextToSsml, getAzureVoiceCatalogMetadata, getBuiltInVoiceCatalogMetadata, isValidAzureAudioDuration, mapSsmlTextNodes, normalizeAzureLanguage, parseSsml, splitSsmlDocument, validateAzureSsml, validateSsml, validateSsmlStructureIntegrity };

package/dist/core.js

@@ -30,6 +30,7 @@ __export(core_exports, {
   areAzureLanguagesEquivalent: () => areAzureLanguagesEquivalent,
   buildPartialSsml: () => buildPartialSsml,
   buildSsml: () => buildSsml,
+  createAzureUrlValidatorRunner: () => createAzureUrlValidatorRunner,
   extractSsmlText: () => extractSsmlText,
   extractSsmlTranslatableText: () => extractSsmlTranslatableText,
   fromPlainTextToSsml: () => fromPlainTextToSsml,
@@ -1045,30 +1046,138 @@ function splitNode(document, node, maxLength, context = []) {
   flush();
   return parts;
 }
-function splitSsmlDocument(ssml, maxLength = DEFAULT_MAX_LENGTH) {
-  if (!Number.isInteger(maxLength) || maxLength <= 0) {
+function textFromNode(node) {
+  if (typeof node === "string") return node;
+  if (node.type === "text") return node.value;
+  return (node.children ?? []).map(textFromNode).join("");
+}
+function collectMarks(node, marks) {
+  if (typeof node === "string" || node.type === "text") return;
+  if (node.type === "mark" && node.name) marks.push(node.name);
+  if (node.type === "bookmark" && node.mark) marks.push(node.mark);
+  for (const child of node.children ?? []) collectMarks(child, marks);
+}
+function collectInheritedContext(nodes) {
+  const context = {};
+  const visit = (node) => {
+    if (typeof node === "string" || node.type === "text") return;
+    if (context.voice === void 0 && node.type === "voice" && node.name) context.voice = node.name;
+    if (context.lang === void 0 && node.type === "lang" && node.lang) context.lang = node.lang;
+    if (context.prosody === void 0 && node.type === "prosody") {
+      const prosody = {};
+      for (const [key, value] of Object.entries(node.attributes ?? {})) prosody[key] = String(value);
+      for (const key of ["rate", "pitch", "volume", "contour", "range"]) {
+        const value = node[key];
+        if (value !== void 0) prosody[key] = String(value);
+      }
+      if (Object.keys(prosody).length > 0) context.prosody = prosody;
+    }
+    for (const child of node.children ?? []) visit(child);
+  };
+  nodes.forEach(visit);
+  return context;
+}
+function elementName(node) {
+  return node.type === "custom" || node.type === "element" ? node.name : node.type;
+}
+function findSourceNodePath(nodes, targetOffset) {
+  let textOffset = 0;
+  let firstPath;
+  let foundPath;
+  const visit = (node, path) => {
+    if (typeof node === "string" || node.type === "text") {
+      const text = typeof node === "string" ? node : node.value;
+      if (text && firstPath === void 0) firstPath = [...path];
+      if (text && foundPath === void 0 && targetOffset < textOffset + text.length) foundPath = [...path];
+      textOffset += text.length;
+      return;
+    }
+    node.children?.forEach((child, index) => {
+      const childPath = typeof child === "string" || child.type === "text" ? path : [...path, `${elementName(child)}[${index}]`];
+      visit(child, childPath);
+    });
+  };
+  nodes.forEach((node, index) => {
+    if (!foundPath) {
+      if (typeof node === "string" || node.type === "text") visit(node, ["speak"]);
+      else visit(node, ["speak", `${elementName(node)}[${index}]`]);
+    }
+  });
+  return foundPath ?? firstPath;
+}
+function createChunk(document, nodes, chunkIndex, textStart, backgroundAudio, replicateBackgroundAudio) {
+  const chunkNodes = backgroundAudio && (replicateBackgroundAudio || chunkIndex === 0) ? [backgroundAudio, ...nodes] : nodes;
+  const text = nodes.map(textFromNode).join("");
+  const marks = [];
+  for (const node of nodes) collectMarks(node, marks);
+  const inheritedContext = collectInheritedContext(nodes);
+  if (inheritedContext.lang === void 0 && document.lang) inheritedContext.lang = document.lang;
+  return {
+    chunkIndex,
+    ssml: documentWithChildren(document, chunkNodes),
+    originalTextRange: { start: textStart, end: textStart + text.length },
+    inheritedContext,
+    containedMarks: marks,
+    hasBackgroundAudio: chunkNodes.some(
+      (node) => typeof node !== "string" && node.type !== "text" && node.type === "mstts:backgroundaudio"
+    ),
+    sourceNodePath: findSourceNodePath(document.children ?? [], textStart)
+  };
+}
+function splitSsmlDocument(ssml, maxLength = DEFAULT_MAX_LENGTH, options = {}) {
+  const resolvedMaxLength = typeof maxLength === "number" ? maxLength : maxLength.maxLength ?? DEFAULT_MAX_LENGTH;
+  const resolvedOptions = typeof maxLength === "number" ? options : maxLength;
+  if (!Number.isInteger(resolvedMaxLength) || resolvedMaxLength <= 0) {
     throw new RangeError("maxLength must be a positive integer");
   }
   const document = parseSsml(ssml);
-  if (ssml.length <= maxLength) return [ssml];
-  const children = document.children ?? [];
-  const splitChildren = children.flatMap((child) => splitNode(document, child, maxLength));
+  const backgroundAudio = (document.children ?? []).find(
+    (node) => typeof node !== "string" && node.type !== "text" && node.type === "mstts:backgroundaudio"
+  );
+  if (ssml.length <= resolvedMaxLength) {
+    return [createChunk(document, document.children ?? [], 0, 0, backgroundAudio, true)];
+  }
+  const contentChildren = (document.children ?? []).filter((node) => node !== backgroundAudio);
+  const plainDocumentLength = documentWithChildren(document, []).length;
+  const backgroundDocumentLength = backgroundAudio ? documentWithChildren(document, [backgroundAudio]).length : plainDocumentLength;
+  const backgroundOverhead = Math.max(0, backgroundDocumentLength - plainDocumentLength);
+  const contentMaxLength = Math.max(1, resolvedMaxLength - backgroundOverhead);
+  const splitChildren = contentChildren.flatMap((child) => splitNode(document, child, contentMaxLength));
   const chunks = [];
   let group = [];
   for (const child of splitChildren) {
     const candidate = [...group, child];
-    if (documentWithChildren(document, candidate).length <= maxLength) {
+    if (documentWithChildren(document, candidate).length <= contentMaxLength) {
       group = candidate;
       continue;
     }
     if (group.length > 0) chunks.push(group);
     group = [child];
-    if (documentWithChildren(document, group).length > maxLength) {
+    if (documentWithChildren(document, group).length > contentMaxLength) {
       throw new RangeError("maxLength is too small to contain the SSML document wrapper");
     }
   }
   if (group.length > 0) chunks.push(group);
-  return chunks.map((chunk) => documentWithChildren(document, chunk));
+  if (chunks.length === 0) {
+    const result = createChunk(document, [], 0, 0, backgroundAudio, resolvedOptions.replicateBackgroundAudio ?? false);
+    if (result.ssml.length > resolvedMaxLength) {
+      throw new RangeError("maxLength is too small to contain the SSML document wrapper");
+    }
+    return [result];
+  }
+  let textStart = 0;
+  return chunks.map((chunk, chunkIndex) => {
+    const result = createChunk(
+      document,
+      chunk,
+      chunkIndex,
+      textStart,
+      backgroundAudio,
+      resolvedOptions.replicateBackgroundAudio ?? false
+    );
+    textStart = result.originalTextRange.end;
+    return result;
+  });
 }
 
 // packages/ssml-core/src/validation.ts
@@ -1238,7 +1347,7 @@ async function mapSsmlTextNodes(ssml, transform, options = {}) {
 
 // packages/ssml-core/src/migration.ts
 var DEFAULT_TRANSLATION_SKIP_TAGS = ["phoneme", "say-as", "sayAs", "sub"];
-function elementName(element) {
+function elementName2(element) {
   switch (element.type) {
     case "custom":
     case "element":
@@ -1391,7 +1500,7 @@ function extractSsmlTranslatableText(ssml, options = {}) {
         }
         return;
       }
-      const tag = elementName(node);
+      const tag = elementName2(node);
       if (skipTags.has(tag.toLowerCase())) return;
       visit(childrenOf(node), [...ancestors, tag], [...path, String(index)]);
     });
@@ -1437,7 +1546,7 @@ function serializeDocument2(document) {
   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 tag = elementName2(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("");
@@ -1451,7 +1560,7 @@ function flatten(document) {
     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 });
+      result.push({ name: elementName2(node), attributes: elementAttributes(node), path: currentPath });
       visit(childrenOf(node), currentPath);
     });
   };
@@ -1649,6 +1758,69 @@ var AZURE_VOICE_DEFINITIONS = [
 ];
 
 // packages/ssml-core/src/azureValidation.ts
+function createAzureUrlValidatorRunner(validator, options = {}) {
+  if (typeof validator !== "function") throw new TypeError("A URL validator function is required.");
+  const concurrency = options.concurrency === void 0 ? Infinity : Number.isFinite(options.concurrency) ? Math.max(1, Math.floor(options.concurrency)) : Infinity;
+  const cache = options.cache ?? /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  const waiters = [];
+  let active = 0;
+  const acquire = async () => {
+    if (active < concurrency) {
+      active += 1;
+      return;
+    }
+    await new Promise((resolve) => waiters.push(resolve));
+    active += 1;
+  };
+  const release = () => {
+    active -= 1;
+    waiters.shift()?.();
+  };
+  const check = async (url, context) => {
+    if (options.signal?.aborted) throw new Error("URL validation was aborted.");
+    const cached = cache.get(url);
+    if (cached !== void 0) return cached;
+    const existing = inFlight.get(url);
+    if (existing) return existing;
+    const promise = (async () => {
+      await acquire();
+      try {
+        if (options.signal?.aborted) throw new Error("URL validation was aborted.");
+        const validation = Promise.resolve(validator(url, context));
+        let timer;
+        let abortHandler;
+        const cancellation = new Promise((_resolve, reject) => {
+          abortHandler = () => reject(new Error("URL validation was aborted."));
+          options.signal?.addEventListener("abort", abortHandler, { once: true });
+          if (options.timeoutMs !== void 0 && options.timeoutMs > 0) {
+            timer = setTimeout(
+              () => reject(new Error(`URL validation timed out after ${options.timeoutMs} ms.`)),
+              options.timeoutMs
+            );
+          }
+        });
+        try {
+          const result = await (timer || abortHandler ? Promise.race([validation, cancellation]) : validation);
+          cache.set(url, result);
+          return result;
+        } finally {
+          if (timer) clearTimeout(timer);
+          if (abortHandler) options.signal?.removeEventListener("abort", abortHandler);
+        }
+      } finally {
+        release();
+      }
+    })();
+    inFlight.set(url, promise);
+    try {
+      return await promise;
+    } finally {
+      inFlight.delete(url);
+    }
+  };
+  return (url, context) => check(url, context);
+}
 var ALLOWED_BREAK_STRENGTHS = /* @__PURE__ */ new Set(["none", "x-weak", "weak", "medium", "strong", "x-strong"]);
 var ALLOWED_SAY_AS = /* @__PURE__ */ new Set([
   "characters",
@@ -1943,23 +2115,23 @@ function validateVoiceFeatureMatrix(token, source, diagnostics, voiceName, defin
     );
   }
 }
-function validateAudioSource(token, source, diagnostics, options, elementName2) {
+function validateAudioSource(token, source, diagnostics, options, elementName3) {
   const src = attr(token, "src");
   if (!src) {
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2}> requires a "src" attribute.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3}> 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.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} src> must be an absolute HTTP(S) URL.`);
     return;
   }
   if (parsed.username || parsed.password)
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must not contain URL credentials.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} src> must not contain URL credentials.`);
   if (parsed.protocol !== "https:" && !(options.allowHttpAudio && parsed.protocol === "http:"))
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> must use HTTPS.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} src> must use HTTPS.`);
   const isAllowedOrigin = options.allowedAudioOrigins?.some((allowedOrigin) => {
     try {
       const configured = new URL(allowedOrigin);
@@ -1971,13 +2143,13 @@ function validateAudioSource(token, source, diagnostics, options, elementName2)
     }
   }) ?? false;
   if (options.allowedAudioOrigins && !isAllowedOrigin)
-    addDiagnostic(diagnostics, source, token.start, `<${elementName2} src> origin "${parsed.origin}" is not allowed.`);
+    addDiagnostic(diagnostics, source, token.start, `<${elementName3} src> origin "${parsed.origin}" is not allowed.`);
   else if (!isAllowedOrigin && !options.allowExternalAudio)
     addDiagnostic(
       diagnostics,
       source,
       token.start,
-      `<${elementName2} src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`
+      `<${elementName3} src> external origin "${parsed.origin}" is blocked by default; set allowExternalAudio to true or provide allowedAudioOrigins.`
     );
 }
 function validateElement(token, source, diagnostics, voiceName, options, voiceCatalog) {
@@ -2159,7 +2331,7 @@ function validateElement(token, source, diagnostics, voiceName, options, voiceCa
       addDiagnostic(diagnostics, source, token.start, "<mstts:backgroundaudio> must be self-closing.");
   }
 }
-function validateAzureSsml(ssml, options = {}) {
+function validateAzureSsmlStatic(ssml, options = {}) {
   const diagnostics = [];
   if (typeof ssml !== "string") {
     return [
@@ -2283,6 +2455,59 @@ function validateAzureSsml(ssml, options = {}) {
   }
   return diagnostics;
 }
+function urlAttributes(token) {
+  const tag = canonicalTagName(token.name);
+  const attributes = tag === "audio" || tag === "mstts:backgroundaudio" ? ["src"] : tag === "lexicon" ? ["uri"] : tag === "mstts:voiceconversion" ? ["url"] : [];
+  return attributes.flatMap((attribute) => {
+    const value = attr(token, attribute);
+    return value === void 0 ? [] : [{ attribute, value }];
+  });
+}
+function validateAzureSsml(ssml, options = {}) {
+  const diagnostics = validateAzureSsmlStatic(ssml, options);
+  const validator = options.urlValidator ?? options.customUrlValidator;
+  if (!validator || typeof ssml !== "string") return diagnostics;
+  const runnerOptions = options.urlValidation ?? {};
+  const boundedValidator = createAzureUrlValidatorRunner(validator, {
+    ...runnerOptions,
+    ...options.urlValidatorConcurrency !== void 0 ? { concurrency: options.urlValidatorConcurrency } : {},
+    ...options.urlValidatorTimeoutMs !== void 0 ? { timeoutMs: options.urlValidatorTimeoutMs } : {},
+    ...options.urlValidatorSignal ? { signal: options.urlValidatorSignal } : {},
+    ...options.urlValidatorCache ? { cache: options.urlValidatorCache } : {}
+  });
+  let tokens;
+  try {
+    tokens = tokenizeElements(ssml);
+  } catch {
+    return diagnostics;
+  }
+  const checks = tokens.flatMap(
+    (token) => urlAttributes(token).map(async ({ attribute, value }) => {
+      try {
+        const result = await boundedValidator(value, { tag: token.name, attribute });
+        const valid = typeof result === "boolean" ? result : result.valid;
+        if (!valid) {
+          const reason = typeof result === "boolean" ? void 0 : result.reason;
+          addDiagnostic(
+            diagnostics,
+            ssml,
+            token.start,
+            `<${token.name} ${attribute}> was rejected by the custom URL validator${reason ? `: ${reason}` : "."}`
+          );
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        addDiagnostic(
+          diagnostics,
+          ssml,
+          token.start,
+          `<${token.name} ${attribute}> could not be validated by the custom URL validator: ${reason}`
+        );
+      }
+    })
+  );
+  return Promise.all(checks).then(() => diagnostics);
+}
 
 // packages/ssml-core/src/generated/azureVoiceCatalog.ts
 var AZURE_VOICE_CATALOG_METADATA = {
@@ -2305,6 +2530,7 @@ var getBuiltInVoiceCatalogMetadata = getAzureVoiceCatalogMetadata;
   areAzureLanguagesEquivalent,
   buildPartialSsml,
   buildSsml,
+  createAzureUrlValidatorRunner,
   extractSsmlText,
   extractSsmlTranslatableText,
   fromPlainTextToSsml,