@pie-players/pie-assessment-toolkit 0.3.73 → 0.3.75

package/dist/services/tts/ssml/spoken-text.d.ts

@@ -1,29 +1,5 @@
-/**
- * Shared SSML → spoken-text extractor.
- *
- * Strips SSML markup to the words a TTS engine would actually voice, while
- * recording a `rawToSpokenOffsetMap` from raw-SSML character offsets to
- * normalized spoken-text offsets. This is the single source of truth for SSML
- * stripping used by:
- *   - the catalog span aligner (`catalog-span-alignment.ts`),
- *   - the math speech tokenizer (`math-alignment/speech-tokenizer.ts`),
- *   - the runtime generated-speech path (PIE-623).
- *
- * Keeping one implementation guarantees provider word-boundary offsets (which
- * are into the raw SSML string) map to the same spoken text on every path.
- *
- * Tag handling:
- *   - Structural tags (`speak`, `p`, `s`, `emphasis`, `prosody`, `say-as`,
- *     `voice`, `lang`) are transparent; their text content flows through.
- *     `p`/`s` open tags inject a word boundary space.
- *   - `break` injects a space (a pause is a word boundary).
- *   - `sub alias="…"` substitutes the alias text (and skips the original).
- *     `sub` with no alias marks the content unsupported for word tracking.
- *   - Semantic tags that change *what* is spoken without leaving trackable
- *     text (`audio`, `phoneme`) mark the content unsupported.
- *   - Any other unknown element marks the content unsupported (degrade to
- *     coarse region highlighting rather than mis-track).
- */
+/** Whether `text` is an SSML document: it opens with a `<speak>` element. */
+export declare const isSsmlDocument: (text: string) => boolean;
 export interface ExtractedSpokenText {
     spokenText: string;
     rawToSpokenOffsetMap: Map<number, number>;

package/dist/services/tts/ssml/spoken-text.js

@@ -1,4 +1,33 @@
 import { normalizeTextForSpeech } from "../text-processing.js";
+/**
+ * Shared SSML → spoken-text extractor.
+ *
+ * Strips SSML markup to the words a TTS engine would actually voice, while
+ * recording a `rawToSpokenOffsetMap` from raw-SSML character offsets to
+ * normalized spoken-text offsets. This is the single source of truth for SSML
+ * stripping used by:
+ *   - the catalog span aligner (`catalog-span-alignment.ts`),
+ *   - the math speech tokenizer (`math-alignment/speech-tokenizer.ts`),
+ *   - the runtime generated-speech path (PIE-623).
+ *
+ * Keeping one implementation guarantees provider word-boundary offsets (which
+ * are into the raw SSML string) map to the same spoken text on every path.
+ *
+ * Tag handling:
+ *   - Structural tags (`speak`, `p`, `s`, `emphasis`, `prosody`, `say-as`,
+ *     `voice`, `lang`) are transparent; their text content flows through.
+ *     `p`/`s` open tags inject a word boundary space.
+ *   - `break` injects a space (a pause is a word boundary).
+ *   - `sub alias="…"` substitutes the alias text (and skips the original).
+ *     `sub` with no alias marks the content unsupported for word tracking.
+ *   - Semantic tags that change *what* is spoken without leaving trackable
+ *     text (`audio`, `phoneme`) mark the content unsupported.
+ *   - Any other unknown element marks the content unsupported (degrade to
+ *     coarse region highlighting rather than mis-track).
+ */
+const SSML_DOCUMENT = /^\s*<speak[\s/>]/i;
+/** Whether `text` is an SSML document: it opens with a `<speak>` element. */
+export const isSsmlDocument = (text) => SSML_DOCUMENT.test(text);
 const STRUCTURAL_SSML_TAGS = new Set([
     "speak",
     "p",

package/dist/services/tts/start-failure.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The `code` a speak's rejection carries when speech could not start, as
+ * distinct from a failure while speaking. Read by shape: several copies of the
+ * toolkit can share a page, so an error class from one fails `instanceof` in
+ * another.
+ */
+export declare const TTS_START_FAILED_CODE = "tts-start-failed";
+/** Whether a speak rejected because speech could not start. */
+export declare function isTTSStartFailure(error: unknown): boolean;
+/** Marks `cause` as a start failure, keeping its message and stack. */
+export declare function toTTSStartFailure(cause: unknown): Error;

package/dist/services/tts/start-failure.js

@@ -0,0 +1,19 @@
+/**
+ * The `code` a speak's rejection carries when speech could not start, as
+ * distinct from a failure while speaking. Read by shape: several copies of the
+ * toolkit can share a page, so an error class from one fails `instanceof` in
+ * another.
+ */
+export const TTS_START_FAILED_CODE = "tts-start-failed";
+/** Whether a speak rejected because speech could not start. */
+export function isTTSStartFailure(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        error.code === TTS_START_FAILED_CODE);
+}
+/** Marks `cause` as a start failure, keeping its message and stack. */
+export function toTTSStartFailure(cause) {
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    error.code = TTS_START_FAILED_CODE;
+    return error;
+}

package/dist/services/tts/text-processing.d.ts

@@ -62,9 +62,17 @@ export declare const collectRangeTextForSpeech: (range: Range, root: Element) =>
     text: string;
     filtered: boolean;
 };
+/** The part of `textNode`'s text that `range` holds, for a node it intersects. */
+export declare const textInRange: (textNode: Text, range: Range) => string;
+/**
+ * Whether `range` holds all of `element`'s speakable text: its first and last
+ * speakable characters, which a contiguous range holding both holds everything
+ * between. An element with no speakable text, an image for one, is held when the
+ * range touches it, since no part of it can be selected alone.
+ */
+export declare const rangeHoldsSpeakableElement: (range: Range, element: Element, root?: Element | null) => boolean;
 export declare const shouldInsertWordBoundarySpace: (previousChar: string | null, nextChar: string | null, options?: TextProcessingOptions) => boolean;
 export declare const collectVisibleTextAndMap: (element: Element, options?: TextProcessingOptions) => {
     text: string;
     map: NormalizedTextMap;
 };
-export declare const extractVisibleText: (element: Element, options?: TextProcessingOptions) => string;

package/dist/services/tts/text-processing.js

@@ -1,3 +1,4 @@
+import { flatTreeParentElement, flatTreeTextNodes, rangeHoldsTextPosition, rangeIntersectsComposedNode, } from "./flat-tree.js";
 export const normalizeTextForSpeech = (text) => text.trim().replace(/\s+/g, " ");
 // Single source of truth for aligning spoken text to visible / math text.
 // Letters are matched with `\p{L}` so the tokenizer is Unicode-aware — accented
@@ -50,15 +51,15 @@ export const isElementHiddenForTTS = (element) => {
     return false;
 };
 export const isNodeHiddenForTTS = (node, root) => {
-    let current = node.nodeType === 1
-        ? node
-        : node.parentElement;
+    // Up the flat tree, so a node in a shadow root inherits its host's
+    // visibility and a slotted node the visibility of the slot rendering it.
+    let current = node.nodeType === 1 ? node : flatTreeParentElement(node);
     while (current) {
         if (isElementHiddenForTTS(current))
             return true;
         if (root && current === root)
             break;
-        current = current.parentElement;
+        current = flatTreeParentElement(current);
     }
     return false;
 };
@@ -112,15 +113,14 @@ export const isElementSuppressedForTTS = (element) => {
     return true;
 };
 export const isNodeSuppressedForTTS = (node, root) => {
-    let current = node.nodeType === 1
-        ? node
-        : node.parentElement;
+    // Through shadow hosts as well: suppression on a host covers its shadow tree.
+    let current = node.nodeType === 1 ? node : flatTreeParentElement(node);
     while (current) {
         if (isElementSuppressedForTTS(current))
             return true;
         if (root && current === root)
             break;
-        current = current.parentElement;
+        current = flatTreeParentElement(current);
     }
     return false;
 };
@@ -146,11 +146,7 @@ export const isNodeExcludedFromSpeech = (node, root) => isNodeHiddenForTTS(node,
  * nothing".
  */
 export const collectRangeTextForSpeech = (range, root) => {
-    if (typeof document === "undefined" ||
-        typeof document.createTreeWalker !==
-            "function" ||
-        typeof NodeFilter === "undefined" ||
-        typeof range.intersectsNode !== "function") {
+    if (typeof range.intersectsNode !== "function") {
         // Degraded, and deliberately not silent about the difference: callers still
         // enforce whole-selection suppression from the range's common ancestor, so
         // the construct guard holds even here. What is lost is per-node filtering
@@ -159,25 +155,49 @@ export const collectRangeTextForSpeech = (range, root) => {
     }
     const parts = [];
     let filtered = false;
-    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
-    let current = walker.nextNode();
-    while (current) {
-        const textNode = current;
-        if (range.intersectsNode(textNode)) {
+    for (const textNode of flatTreeTextNodes(root)) {
+        if (rangeIntersectsComposedNode(range, textNode)) {
             if (isNodeExcludedFromSpeech(textNode, root)) {
                 filtered = true;
             }
             else {
-                const raw = textNode.textContent || "";
-                const start = textNode === range.startContainer ? range.startOffset : 0;
-                const end = textNode === range.endContainer ? range.endOffset : raw.length;
-                parts.push(raw.slice(start, end));
+                parts.push(textInRange(textNode, range));
             }
         }
-        current = walker.nextNode();
     }
     return { text: parts.join(""), filtered };
 };
+/** The part of `textNode`'s text that `range` holds, for a node it intersects. */
+export const textInRange = (textNode, range) => {
+    const raw = textNode.textContent || "";
+    const start = textNode === range.startContainer ? range.startOffset : 0;
+    const end = textNode === range.endContainer ? range.endOffset : raw.length;
+    return raw.slice(start, end);
+};
+/**
+ * Whether `range` holds all of `element`'s speakable text: its first and last
+ * speakable characters, which a contiguous range holding both holds everything
+ * between. An element with no speakable text, an image for one, is held when the
+ * range touches it, since no part of it can be selected alone.
+ */
+export const rangeHoldsSpeakableElement = (range, element, root) => {
+    let first = null;
+    let last = null;
+    for (const textNode of flatTreeTextNodes(element)) {
+        if (isNodeExcludedFromSpeech(textNode, root))
+            continue;
+        const raw = textNode.textContent || "";
+        const firstOffset = raw.search(/\S/);
+        if (firstOffset === -1)
+            continue;
+        first ??= { node: textNode, offset: firstOffset };
+        last = { node: textNode, offset: raw.trimEnd().length - 1 };
+    }
+    if (!first || !last)
+        return rangeIntersectsComposedNode(range, element);
+    return (rangeHoldsTextPosition(range, first.node, first.offset) &&
+        rangeHoldsTextPosition(range, last.node, last.offset));
+};
 export const shouldInsertWordBoundarySpace = (previousChar, nextChar, options) => {
     if (!previousChar || !nextChar)
         return false;
@@ -210,10 +230,7 @@ export const shouldInsertWordBoundarySpace = (previousChar, nextChar, options) =
 };
 export const collectVisibleTextAndMap = (element, options) => {
     const map = new Map();
-    if (typeof document === "undefined" ||
-        typeof document.createTreeWalker !==
-            "function" ||
-        typeof NodeFilter === "undefined") {
+    if (typeof document === "undefined") {
         return { text: "", map };
     }
     const outChars = [];
@@ -222,11 +239,8 @@ export const collectVisibleTextAndMap = (element, options) => {
     let lastCharWasWhitespace = false;
     let lastMapped = null;
     let previousVisibleChar = null;
-    const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
-    let current = walker.nextNode();
-    while (current) {
-        const textNode = current;
-        const parent = textNode.parentElement;
+    for (const textNode of flatTreeTextNodes(element)) {
+        const parent = flatTreeParentElement(textNode);
         if (parent && !isNodeExcludedFromSpeech(textNode, element)) {
             const raw = textNode.textContent || "";
             const firstVisibleMatch = raw.match(/\S/);
@@ -274,7 +288,6 @@ export const collectVisibleTextAndMap = (element, options) => {
                 }
             }
         }
-        current = walker.nextNode();
     }
     const text = outChars.join("").trimEnd();
     while (map.has(text.length)) {
@@ -282,4 +295,3 @@ export const collectVisibleTextAndMap = (element, options) => {
     }
     return { text, map };
 };
-export const extractVisibleText = (element, options) => collectVisibleTextAndMap(element, options).text;

package/dist/services/tts/text-segmentation.d.ts

@@ -7,3 +7,10 @@ export interface SentenceSegmentationOptions {
     useSentenceSegmenter?: boolean;
 }
 export declare const segmentSentences: (text: string, options?: SentenceSegmentationOptions) => SentenceSegment[];
+/**
+ * `text` in pieces of at most `maxLength` characters: whole sentences while they
+ * fit, a sentence too long for one piece cut at its last space that fits, and a
+ * word too long for one piece cut where the limit falls. Each piece is a trimmed
+ * substring of `text`, at its offset there.
+ */
+export declare const splitTextToLength: (text: string, maxLength: number, options?: SentenceSegmentationOptions) => SentenceSegment[];

package/dist/services/tts/text-segmentation.js

@@ -35,3 +35,50 @@ export const segmentSentences = (text, options) => {
     }
     return parsed.length > 0 ? parsed : [{ text, offset: 0 }];
 };
+/**
+ * `text` in pieces of at most `maxLength` characters: whole sentences while they
+ * fit, a sentence too long for one piece cut at its last space that fits, and a
+ * word too long for one piece cut where the limit falls. Each piece is a trimmed
+ * substring of `text`, at its offset there.
+ */
+export const splitTextToLength = (text, maxLength, options) => {
+    const limit = Math.max(1, Math.floor(maxLength));
+    const pieces = [];
+    let start = -1;
+    let end = -1;
+    const flush = () => {
+        if (start >= 0)
+            pieces.push({ text: text.slice(start, end), offset: start });
+        start = -1;
+    };
+    const append = (spanStart, spanEnd) => {
+        if (start >= 0 && spanEnd - start <= limit) {
+            end = spanEnd;
+            return;
+        }
+        flush();
+        let cursor = spanStart;
+        while (spanEnd - cursor > limit) {
+            const window = text.slice(cursor, cursor + limit + 1);
+            const space = window.search(/\s\S*$/);
+            const cut = space > 0 ? cursor + space : cursor + limit;
+            pieces.push({ text: text.slice(cursor, cut).trimEnd(), offset: cursor });
+            cursor = cut;
+            while (cursor < spanEnd && /\s/.test(text[cursor]))
+                cursor++;
+        }
+        if (cursor < spanEnd) {
+            start = cursor;
+            end = spanEnd;
+        }
+    };
+    for (const sentence of segmentSentences(text, options)) {
+        const leading = sentence.text.search(/\S/);
+        if (leading === -1)
+            continue;
+        const spanStart = sentence.offset + leading;
+        append(spanStart, sentence.offset + sentence.text.trimEnd().length);
+    }
+    flush();
+    return pieces;
+};

package/dist/services/tts-runtime-config.d.ts

@@ -1,5 +1,5 @@
 import type { TTSConfig } from "./TTSService.js";
-import type { ToolProviderConfig } from "./tools-config-normalizer.js";
+import type { TextToSpeechToolProviderConfig, ToolProviderConfig } from "./tools-config-normalizer.js";
 import { type SREMathSpeechOptions } from "./tts/math-speech.js";
 export type TTSLayoutMode = "reserved-row" | "expanding-row" | "floating-overlay" | "left-aligned";
 export interface TTSHostToolbarLayout {
@@ -26,9 +26,10 @@ export interface NormalizedTTSSpeedOption {
     isDefault: boolean;
 }
 export interface TTSRuntimeSettings {
-    backend?: "browser" | "polly" | "google" | "server";
+    /** `browser` speaks through the Web Speech API; `server` through a TTS server. */
+    backend?: "browser" | "server";
+    /** The service behind a `server` backend. */
     serverProvider?: "polly" | "google" | "custom";
-    provider?: "polly" | "google" | "custom";
     engine?: "standard" | "neural";
     sampleRate?: number;
     format?: "mp3" | "ogg" | "pcm";
@@ -37,14 +38,35 @@ export interface TTSRuntimeSettings {
     rate?: number;
     pitch?: number;
     apiEndpoint?: string;
+    /**
+     * The host's locale, used for a read whose content names no language: it
+     * drives text normalization and segmentation, is sent as `language` on the
+     * `pie` transport and as `lang_id` on the `custom` transport when nothing
+     * names a language, and a server given no voice picks one for it. The
+     * content language a read resolves (markup `lang`, the tool's `language`,
+     * the toolkit's `content-language`, then `lang_id`) wins over it.
+     * `docs/architecture/internationalization.md#tts-language` is the contract.
+     */
     language?: string;
     transportMode?: "pie" | "custom";
     endpointMode?: "synthesizePath" | "rootPost";
     endpointValidationMode?: "voices" | "endpoint" | "none";
     includeAuthOnAssetFetch?: boolean;
+    /** Origins trusted with the `Authorization` header on asset fetches. */
+    assetOrigins?: string[];
+    /** Fetch `credentials` mode for requests to the TTS server. */
+    credentials?: "omit" | "same-origin" | "include";
+    /** Headers sent with every request to the TTS server. */
+    headers?: Record<string, string>;
     validateEndpoint?: boolean;
     cache?: boolean;
     speedRate?: "slow" | "medium" | "fast";
+    /**
+     * The custom transport's locale, sent on every read in place of the content
+     * language. Where markup and the tool name no language it is also the read's
+     * content language, so text processing and catalog lookups follow it. Leave
+     * it unset to let content language reach the service.
+     */
     lang_id?: string;
     /**
      * Optional inline TTS speed buttons.
@@ -75,19 +97,13 @@ export interface TTSRuntimeSettings {
      * instead of relying on toolkit-specific speech rewrites.
      */
     mathSpeech?: SREMathSpeechOptions;
+    /**
+     * Options passed through to the provider. The fields derived from the
+     * settings above, such as `locale` and the Polly engine, win over these.
+     */
+    providerOptions?: Record<string, unknown>;
 }
 export declare const normalizeTTSLayoutMode: (value: unknown, fallback?: TTSLayoutMode) => TTSLayoutMode;
-/** Legacy numeric helper defaults. Rendered controls add visible Normal separately. */
-export declare const DEFAULT_TTS_SPEED_OPTIONS: readonly number[];
-export declare const normalizeTTSSpeedOptionConfigs: (value: unknown) => TTSSpeedOption[];
-/**
- * Resolves inline toolbar speed options from host config.
- * - Omitted/non-array: default speed buttons.
- * - Empty array: hide speed buttons.
- * - Arrays that sanitize to no valid values: default speed buttons.
- * - 1.0× is never shown as a discrete speed button.
- */
-export declare const normalizeTTSSpeedOptions: (value: unknown) => number[];
 export declare const normalizeTTSSpeedControlOptions: (value: unknown) => NormalizedTTSSpeedOption[];
 export declare const formatTTSSpeedOptionsAsText: (values: number[]) => string;
 /**
@@ -96,10 +112,20 @@ export declare const formatTTSSpeedOptionsAsText: (values: number[]) => string;
  * - Non-empty text with no parseable finite numbers → same as invalid-only array config: defaults.
  */
 export declare const parseTTSSpeedOptionsFromText: (text: string) => number[];
-export declare const resolveTTSRuntimeSettings: (config: ToolProviderConfig | TTSRuntimeSettings | undefined) => TTSRuntimeSettings;
+/**
+ * The runtime settings of a `textToSpeech` provider entry: its top-level keys
+ * with defaults applied. `enabled` and the runtime `provider` object belong to
+ * the tool registration and are dropped.
+ */
+export declare const resolveTTSRuntimeSettings: (config: TextToSpeechToolProviderConfig | ToolProviderConfig | TTSRuntimeSettings | undefined) => TTSRuntimeSettings;
 export declare const resolveTTSBackend: (config: TTSRuntimeSettings) => NonNullable<TTSRuntimeSettings["backend"]>;
-export declare const resolveRuntimeProvider: (config: TTSRuntimeSettings, backend: NonNullable<TTSRuntimeSettings["backend"]>) => TTSRuntimeSettings["serverProvider"];
-export declare const resolveTransportMode: (config: TTSRuntimeSettings, runtimeProvider: TTSRuntimeSettings["serverProvider"]) => NonNullable<TTSRuntimeSettings["transportMode"]>;
-export declare const buildRuntimeTTSConfig: (config: TTSRuntimeSettings) => Partial<TTSConfig>;
+/**
+ * The provider configuration built from host settings: the contract's portable
+ * fields plus the server adapter's, under the adapter's names.
+ */
+export type RuntimeTTSConfig = Pick<TTSConfig, "voice" | "rate" | "pitch" | "providerOptions" | "mathTokenHighlighting"> & Pick<TTSRuntimeSettings, "apiEndpoint" | "language" | "transportMode" | "endpointMode" | "endpointValidationMode" | "includeAuthOnAssetFetch" | "assetOrigins" | "credentials" | "headers" | "validateEndpoint"> & {
+    provider?: TTSRuntimeSettings["serverProvider"];
+};
+export declare const buildRuntimeTTSConfig: (config: TTSRuntimeSettings) => RuntimeTTSConfig;
 export declare const resolveTTSLayoutMode: (config: TTSRuntimeSettings) => TTSLayoutMode;
 export declare const resolveTTSHostToolbarLayout: (config: TTSRuntimeSettings) => TTSHostToolbarLayout;

package/dist/services/tts-runtime-config.js

@@ -6,26 +6,16 @@ const VALID_TTS_LAYOUT_MODES = new Set([
     "left-aligned",
 ]);
 const toRecord = (value) => value && typeof value === "object" ? value : {};
-const isServerBackend = (backend) => backend === "polly" || backend === "google" || backend === "server";
 const withDefault = (value, fallback) => value === undefined ? fallback : value;
 export const normalizeTTSLayoutMode = (value, fallback = "left-aligned") => typeof value === "string" &&
     VALID_TTS_LAYOUT_MODES.has(value)
     ? value
     : fallback;
-/** Legacy numeric helper defaults. Rendered controls add visible Normal separately. */
-export const DEFAULT_TTS_SPEED_OPTIONS = Object.freeze([0.8, 1.25]);
 const DEFAULT_TTS_SPEED_CONTROL_OPTIONS = Object.freeze([
     { rate: 0.8, label: "Slow", ariaLabel: "Slow speed" },
     { rate: 1, label: "Normal", ariaLabel: "Normal speed", default: true },
     { rate: 1.25, label: "Fast", ariaLabel: "Fast speed" },
 ]);
-const normalizeSpeedRate = (entry) => {
-    if (typeof entry !== "number" || !Number.isFinite(entry) || entry <= 0) {
-        return undefined;
-    }
-    const rounded = Math.round(entry * 100) / 100;
-    return rounded === 1 ? undefined : rounded;
-};
 const normalizeControlSpeedRate = (entry) => {
     if (typeof entry !== "number" || !Number.isFinite(entry) || entry <= 0) {
         return undefined;
@@ -51,56 +41,6 @@ const normalizeSpeedAriaLabel = (label, ariaLabel, usedDefaultLabel) => {
         return ariaLabel;
     return `${label} ${ariaLabel}`;
 };
-const normalizeTTSSpeedOptionConfig = (entry) => {
-    if (typeof entry === "number")
-        return normalizeSpeedRate(entry);
-    if (!entry || typeof entry !== "object" || Array.isArray(entry))
-        return undefined;
-    const record = entry;
-    const rate = normalizeSpeedRate(record.rate);
-    if (rate === undefined)
-        return undefined;
-    const label = trimOptionalText(record.label);
-    const ariaLabel = trimOptionalText(record.ariaLabel);
-    return {
-        rate,
-        ...(label ? { label } : {}),
-        ...(ariaLabel ? { ariaLabel } : {}),
-    };
-};
-export const normalizeTTSSpeedOptionConfigs = (value) => {
-    if (!Array.isArray(value))
-        return [...DEFAULT_TTS_SPEED_OPTIONS];
-    if (value.length === 0)
-        return [];
-    const dedupedRates = new Set();
-    const normalized = [];
-    for (const entry of value) {
-        const option = normalizeTTSSpeedOptionConfig(entry);
-        if (option === undefined)
-            continue;
-        const rate = typeof option === "number" ? option : option.rate;
-        if (dedupedRates.has(rate))
-            continue;
-        dedupedRates.add(rate);
-        normalized.push(option);
-    }
-    return normalized.length ? normalized : [...DEFAULT_TTS_SPEED_OPTIONS];
-};
-/**
- * Resolves inline toolbar speed options from host config.
- * - Omitted/non-array: default speed buttons.
- * - Empty array: hide speed buttons.
- * - Arrays that sanitize to no valid values: default speed buttons.
- * - 1.0× is never shown as a discrete speed button.
- */
-export const normalizeTTSSpeedOptions = (value) => {
-    if (!Array.isArray(value))
-        return [...DEFAULT_TTS_SPEED_OPTIONS];
-    if (value.length === 0)
-        return [];
-    return normalizeTTSSpeedOptionConfigs(value).map((option) => typeof option === "number" ? option : option.rate);
-};
 export const normalizeTTSSpeedControlOptions = (value) => {
     const input = Array.isArray(value)
         ? value
@@ -203,8 +143,7 @@ const applyRuntimeDefaults = (config) => {
         ...config,
         layoutMode: normalizeTTSLayoutMode(config.layoutMode),
     };
-    const backend = config.backend || "browser";
-    if (!isServerBackend(backend))
+    if (config.backend !== "server")
         return withLayoutDefaults;
     const withServerDefaults = {
         ...withLayoutDefaults,
@@ -216,62 +155,48 @@ const applyRuntimeDefaults = (config) => {
         rate: withDefault(withLayoutDefaults.rate, 1.0),
         language: withDefault(withLayoutDefaults.language, "en-US"),
     };
-    if (backend === "polly") {
+    if (config.serverProvider === "polly") {
         return {
             ...withServerDefaults,
-            defaultVoice: withDefault(withServerDefaults.defaultVoice, "Joanna"),
             engine: withDefault(withServerDefaults.engine, "neural"),
             format: withDefault(withServerDefaults.format, "mp3"),
             speechMarksMode: withDefault(withServerDefaults.speechMarksMode, "word+sentence"),
         };
     }
-    if (backend === "google") {
-        return {
-            ...withServerDefaults,
-            defaultVoice: withDefault(withServerDefaults.defaultVoice, "en-US-Wavenet-A"),
-        };
-    }
     return withServerDefaults;
 };
+/**
+ * The runtime settings of a `textToSpeech` provider entry: its top-level keys
+ * with defaults applied. `enabled` and the runtime `provider` object belong to
+ * the tool registration and are dropped.
+ */
 export const resolveTTSRuntimeSettings = (config) => {
-    const configRecord = toRecord(config);
-    const settingsRecord = toRecord(configRecord.settings);
-    return applyRuntimeDefaults({
-        ...configRecord,
-        ...settingsRecord,
-    });
+    const { enabled: _enabled, provider: _provider, ...settings } = toRecord(config);
+    return applyRuntimeDefaults(settings);
 };
 export const resolveTTSBackend = (config) => config.backend || "browser";
-export const resolveRuntimeProvider = (config, backend) => {
-    if (backend === "polly" || backend === "google")
-        return backend;
-    if (backend === "server") {
-        return config.serverProvider || config.provider;
-    }
-    return config.serverProvider || config.provider;
-};
-export const resolveTransportMode = (config, runtimeProvider) => config.transportMode || (runtimeProvider === "custom" ? "custom" : "pie");
 export const buildRuntimeTTSConfig = (config) => {
-    const backend = resolveTTSBackend(config);
-    const runtimeProvider = resolveRuntimeProvider(config, backend);
-    const transportMode = resolveTransportMode(config, runtimeProvider);
+    const runtimeProvider = resolveTTSBackend(config) === "server" ? config.serverProvider : undefined;
+    const polly = runtimeProvider === "polly";
+    const transportMode = config.transportMode || (runtimeProvider === "custom" ? "custom" : "pie");
     const mathSpeech = normalizeSREMathSpeechOptions(config.mathSpeech);
-    return {
+    const runtimeConfig = {
         voice: config.defaultVoice,
         rate: config.rate,
         pitch: config.pitch,
         providerOptions: {
+            ...toRecord(config.providerOptions),
             ...(config.language ? { locale: config.language } : {}),
-            ...(backend === "polly" && config.engine
+            ...(polly && config.engine
                 ? { engine: config.engine }
                 : {}),
-            ...(backend === "polly" && typeof config.sampleRate === "number"
+            ...(polly && typeof config.sampleRate === "number"
                 ? { sampleRate: config.sampleRate }
                 : {}),
-            ...(backend === "polly" && config.format
+            ...(polly && config.format
                 ? { format: config.format }
                 : {}),
-            ...(backend === "polly"
+            ...(polly
                 ? {
                     speechMarkTypes: config.speechMarksMode === "word+sentence"
                         ? ["word", "sentence"]
@@ -296,6 +221,9 @@ export const buildRuntimeTTSConfig = (config) => {
         endpointMode: config.endpointMode,
         endpointValidationMode: config.endpointValidationMode,
         includeAuthOnAssetFetch: config.includeAuthOnAssetFetch,
+        assetOrigins: config.assetOrigins,
+        credentials: config.credentials,
+        headers: config.headers,
         validateEndpoint: config.validateEndpoint,
         // Toolkit-level highlight setting carried through the config channel
         // (like apiEndpoint/transportMode); consumed by the highlight pipeline,
@@ -305,6 +233,7 @@ export const buildRuntimeTTSConfig = (config) => {
             ? { mathTokenHighlighting: config.mathTokenHighlighting }
             : {}),
     };
+    return runtimeConfig;
 };
 export const resolveTTSLayoutMode = (config) => normalizeTTSLayoutMode(config.layoutMode);
 export const resolveTTSHostToolbarLayout = (config) => {