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

package/dist/services/tools-config-normalizer.d.ts

@@ -1,3 +1,4 @@
+import type { CalculatorProviderConfig } from "@pie-players/pie-calculator";
 import type { SREMathSpeechOptions } from "./tts/math-speech.js";
 export type ToolPlacementLevel = "section" | "item" | "passage";
 export interface ToolPolicyConfig {
@@ -58,8 +59,19 @@ export interface TextToSpeechToolProviderConfig extends Omit<ToolProviderConfig,
     mathSpeech?: SREMathSpeechOptions;
     settings?: TextToSpeechToolProviderSettings;
 }
+/**
+ * `tools.providers.calculator`, closed to the keys the calculator reads, so a
+ * misplaced key such as a top-level `authFetcher` fails to compile instead of
+ * being ignored. `Pick` keeps it assignable to the providers index signature,
+ * which an interface would not be.
+ */
+export type CalculatorToolProviderConfig = Pick<CalculatorProviderConfig, keyof CalculatorProviderConfig> & {
+    enabled?: boolean;
+    provider?: ToolRuntimeProviderConfig;
+};
 export interface ToolProvidersConfig {
     textToSpeech?: TextToSpeechToolProviderConfig;
+    calculator?: CalculatorToolProviderConfig;
     [key: string]: ToolProviderConfig | TextToSpeechToolProviderConfig | undefined;
 }
 /**
@@ -89,7 +101,14 @@ export interface CanonicalToolsConfig {
      */
     pnpEnforcement?: ToolsPnpEnforcement;
 }
+/**
+ * The tools config a host supplies. Every part is optional, placement levels
+ * included: {@link normalizeToolsConfig} fills a missing level with its default.
+ */
+export type ToolsConfigInput = Omit<Partial<CanonicalToolsConfig>, "placement"> & {
+    placement?: ToolPlacementConfig;
+};
 export declare function normalizeToolAlias(toolId: string): string;
 export declare function normalizeToolList(toolIds: string[] | undefined | null): string[];
 export declare function parseToolList(input: string | undefined | null): string[];
-export declare function normalizeToolsConfig(input?: Partial<CanonicalToolsConfig> | null): CanonicalToolsConfig;
+export declare function normalizeToolsConfig(input?: ToolsConfigInput | null): CanonicalToolsConfig;

package/dist/services/tts/catalog-span-alignment.d.ts

@@ -1,11 +1,5 @@
+import { type SpeechSourceTokenization } from "./math-alignment/speech-tokenizer.js";
 export type CatalogChunkPlaybackMode = "exact-word" | "anchor-span" | "region-fallback";
-export type BoundaryOffsetMode = "plain-spoken-text" | "raw-ssml" | "unsupported";
-export interface CatalogTextToken {
-    text: string;
-    normalized: string;
-    start: number;
-    end: number;
-}
 export interface CatalogSpanAnchor {
     spokenStart: number;
     spokenEnd: number;
@@ -14,25 +8,16 @@ export interface CatalogSpanAnchor {
     score: number;
 }
 export interface CatalogSpanAlignment {
-    speechText: string;
-    spokenText: string;
+    speech: SpeechSourceTokenization;
     visibleText: string;
     playbackMode: CatalogChunkPlaybackMode;
-    boundaryOffsetMode: BoundaryOffsetMode;
     anchors: CatalogSpanAnchor[];
     confidence: number;
-    spokenTokens: CatalogTextToken[];
-    visibleTokens: CatalogTextToken[];
-    rawToSpokenOffsetMap: Map<number, number>;
 }
 export declare const createCatalogSpanAlignment: (args: {
     speechText: string;
     visibleText: string;
 }) => CatalogSpanAlignment;
-export declare const resolveSpokenBoundaryOffset: (alignment: CatalogSpanAlignment, position: number, length?: number, boundaryWord?: string) => {
-    start: number;
-    length: number;
-} | null;
 export declare const resolveVisibleSpanForBoundary: (alignment: CatalogSpanAlignment, spokenOffset: number) => {
     start: number;
     end: number;

package/dist/services/tts/catalog-span-alignment.js

@@ -1,25 +1,8 @@
-import { extractSpokenText } from "./ssml/spoken-text.js";
-import { createSpeechAlignmentTokenPattern, normalizeTextForSpeech, } from "./text-processing.js";
-// Shared Unicode-aware tokenizer (see `createSpeechAlignmentTokenPattern`), so
-// accented Latin and non-Latin words tokenize the same way here as in the math
-// speech tokenizer. LIMITATION (i18n): the phrase table below is still English,
-// so multi-word operator phrases ("plus or minus", "divided by") only align for
-// English speech; other locales degrade to coarse region highlighting. A fresh
-// pattern per call because of the global flag's mutable `lastIndex`.
-const TOKEN_PATTERN = createSpeechAlignmentTokenPattern();
-const NUMERIC_WORDS = new Map([
-    ["zero", "0"],
-    ["one", "1"],
-    ["two", "2"],
-    ["three", "3"],
-    ["four", "4"],
-    ["five", "5"],
-    ["six", "6"],
-    ["seven", "7"],
-    ["eight", "8"],
-    ["nine", "9"],
-    ["ten", "10"],
-]);
+import { tokenizeAlignmentText, tokenizeSpeechSource, } from "./math-alignment/speech-tokenizer.js";
+import { normalizeTextForSpeech } from "./text-processing.js";
+// LIMITATION (i18n): the phrase table is English, so multi-word operator
+// phrases ("plus or minus", "divided by") only align for English speech; other
+// locales degrade to coarse region highlighting.
 const SPOKEN_PHRASE_TARGETS = [
     { phrase: ["plus", "or", "minus"], visible: "±", score: 8 },
     { phrase: ["square", "root"], visible: "√", score: 8 },
@@ -36,28 +19,12 @@ const SPOKEN_PHRASE_TARGETS = [
     { phrase: ["minus"], visible: "-", score: 5 },
     { phrase: ["plus"], visible: "+", score: 5 },
 ];
-const tokenize = (text) => {
-    const tokens = [];
-    for (const match of text.matchAll(TOKEN_PATTERN)) {
-        const value = match[0];
-        const start = match.index ?? 0;
-        tokens.push({
-            text: value,
-            normalized: value.toLowerCase(),
-            start,
-            end: start + value.length,
-        });
-    }
-    return tokens;
-};
-const normalizedTokenValue = (token) => NUMERIC_WORDS.get(token.normalized) || token.normalized;
 const createCandidates = (spokenTokens, visibleTokens) => {
     const candidates = [];
     for (let spokenIndex = 0; spokenIndex < spokenTokens.length; spokenIndex++) {
         for (let visibleIndex = 0; visibleIndex < visibleTokens.length; visibleIndex++) {
-            const spokenValue = normalizedTokenValue(spokenTokens[spokenIndex]);
-            const visibleValue = normalizedTokenValue(visibleTokens[visibleIndex]);
-            if (spokenValue === visibleValue) {
+            if (spokenTokens[spokenIndex].normalized ===
+                visibleTokens[visibleIndex].normalized) {
                 candidates.push({
                     spokenStartToken: spokenIndex,
                     spokenEndToken: spokenIndex + 1,
@@ -74,7 +41,9 @@ const createCandidates = (spokenTokens, visibleTokens) => {
                 continue;
             }
             for (let visibleIndex = 0; visibleIndex < visibleTokens.length; visibleIndex++) {
-                if (visibleTokens[visibleIndex].normalized !== phraseTarget.visible) {
+                // Glyph targets compare against the visible text as written, so a
+                // visible number word ("two") never stands in for the digit "2".
+                if (visibleTokens[visibleIndex].text !== phraseTarget.visible) {
                     continue;
                 }
                 candidates.push({
@@ -151,21 +120,20 @@ const scoreConfidence = (anchors, spokenTokens, visibleTokens) => {
     return Math.min(1, tokenCoverage * averageScore);
 };
 export const createCatalogSpanAlignment = (args) => {
-    const extracted = extractSpokenText(args.speechText);
+    const speech = tokenizeSpeechSource({ speechText: args.speechText });
     const visibleText = normalizeTextForSpeech(args.visibleText);
-    const spokenText = extracted.spokenText;
-    const spokenTokens = tokenize(spokenText);
-    const visibleTokens = tokenize(visibleText);
-    const anchors = extracted.unsupportedSemantic
+    const spokenTokens = speech.tokens;
+    const visibleTokens = tokenizeAlignmentText(visibleText);
+    const anchors = speech.unsupportedSemantic
         ? []
         : computeAnchors(spokenTokens, visibleTokens);
     const confidence = scoreConfidence(anchors, spokenTokens, visibleTokens);
-    const isExact = spokenText === visibleText && spokenText.length > 0;
+    const isExact = speech.spokenText === visibleText && speech.spokenText.length > 0;
     const hasShortSingleExactAnchor = anchors.length === 1 &&
         anchors[0].score === 10 &&
         spokenTokens.length <= 2 &&
         visibleTokens.length <= 2;
-    const playbackMode = extracted.unsupportedSemantic
+    const playbackMode = speech.unsupportedSemantic
         ? "region-fallback"
         : isExact
             ? "exact-word"
@@ -174,107 +142,14 @@ export const createCatalogSpanAlignment = (args) => {
                     ? "anchor-span"
                     : "region-fallback"
                 : "region-fallback";
-    const boundaryOffsetMode = extracted.unsupportedSemantic
-        ? "unsupported"
-        : extracted.hasMarkup
-            ? "raw-ssml"
-            : "plain-spoken-text";
     return {
-        speechText: args.speechText,
-        spokenText,
+        speech,
         visibleText,
         playbackMode,
-        boundaryOffsetMode,
         anchors,
         confidence,
-        spokenTokens,
-        visibleTokens,
-        rawToSpokenOffsetMap: extracted.rawToSpokenOffsetMap,
-    };
-};
-const findTokenAtOffset = (tokens, offset) => tokens.find((token) => token.start <= offset && offset < token.end) || null;
-const normalizeBoundaryWord = (word) => {
-    if (!word)
-        return null;
-    if (/^<[^>]+>$/.test(word.trim()))
-        return null;
-    const token = tokenize(word)[0];
-    if (!token)
-        return null;
-    return NUMERIC_WORDS.get(token.normalized) || token.normalized;
-};
-const candidateMatchesBoundaryWord = (alignment, candidate, boundaryWord) => {
-    const normalizedBoundary = normalizeBoundaryWord(boundaryWord);
-    if (!candidate || !normalizedBoundary)
-        return false;
-    const token = findTokenAtOffset(alignment.spokenTokens, candidate.start);
-    if (!token)
-        return false;
-    return normalizedTokenValue(token) === normalizedBoundary;
-};
-const mapRawOffsetToSpokenOffset = (alignment, position) => {
-    const direct = alignment.rawToSpokenOffsetMap.get(position);
-    if (direct !== undefined)
-        return direct;
-    for (let offset = position; offset < alignment.speechText.length; offset++) {
-        const mapped = alignment.rawToSpokenOffsetMap.get(offset);
-        if (mapped !== undefined)
-            return mapped;
-        if (alignment.speechText[offset] === ">")
-            break;
-    }
-    return null;
-};
-const resolveRawBoundaryOffset = (alignment, position, safeLength) => {
-    const mappedStart = mapRawOffsetToSpokenOffset(alignment, position);
-    if (mappedStart === null)
-        return null;
-    const mappedEnd = mapRawOffsetToSpokenOffset(alignment, Math.max(position, position + safeLength - 1));
-    const token = findTokenAtOffset(alignment.spokenTokens, mappedStart);
-    const mappedLength = mappedEnd !== null && mappedEnd >= mappedStart
-        ? mappedEnd - mappedStart + 1
-        : token
-            ? token.end - mappedStart
-            : safeLength;
-    return { start: mappedStart, length: Math.max(1, mappedLength) };
-};
-const resolvePlainBoundaryOffset = (alignment, position, safeLength) => {
-    if (position < 0 || position >= alignment.spokenText.length)
-        return null;
-    const token = findTokenAtOffset(alignment.spokenTokens, position);
-    if (!token)
-        return null;
-    return {
-        start: position,
-        length: Math.min(safeLength, token.end - position),
     };
 };
-export const resolveSpokenBoundaryOffset = (alignment, position, length = 1, boundaryWord) => {
-    if (alignment.boundaryOffsetMode === "unsupported" ||
-        !Number.isFinite(position)) {
-        return null;
-    }
-    const safeLength = Math.max(1, Number.isFinite(length) ? length : 1);
-    if (boundaryWord && /^<[^>]+>$/.test(boundaryWord.trim()))
-        return null;
-    if (alignment.boundaryOffsetMode === "raw-ssml") {
-        const rawCandidate = resolveRawBoundaryOffset(alignment, position, safeLength);
-        const plainCandidate = resolvePlainBoundaryOffset(alignment, position, safeLength);
-        if (boundaryWord) {
-            if (candidateMatchesBoundaryWord(alignment, rawCandidate, boundaryWord)) {
-                return rawCandidate;
-            }
-            if (candidateMatchesBoundaryWord(alignment, plainCandidate, boundaryWord)) {
-                return plainCandidate;
-            }
-            if (normalizeBoundaryWord(boundaryWord))
-                return null;
-        }
-        return rawCandidate || plainCandidate;
-    }
-    return (resolvePlainBoundaryOffset(alignment, position, safeLength) ||
-        resolveRawBoundaryOffset(alignment, position, safeLength));
-};
 export const resolveVisibleSpanForBoundary = (alignment, spokenOffset) => {
     if (alignment.playbackMode === "region-fallback")
         return null;

package/dist/services/tts/generated-speech/types.d.ts

@@ -14,7 +14,6 @@
  * without rewriting the core. The runtime binds live DOM via `DomAnchor`
  * (see `./dom/types.ts`).
  */
-export type StructuralBreakStrength = "weak" | "medium" | "strong";
 export interface ProseSegment {
     kind: "prose";
     /** Spoken words for this prose run. Identical to `visibleText` today. */
@@ -53,18 +52,7 @@ export interface MathSegment {
      */
     ssml?: string;
 }
-/**
- * A structural pause. Breaks are never standalone speakable units: the DOM
- * adapter folds them into the SSML of an adjacent speakable segment (or relies
- * on the gap between sequential per-chunk utterances). Modeled here so the
- * plan can carry pause intent for the SSML serializer.
- */
-export interface StructuralBreak {
-    kind: "break";
-    strength: StructuralBreakStrength;
-}
 export type SpeechSegment = ProseSegment | MathSegment;
-export type PlanSegment = SpeechSegment | StructuralBreak;
 /** One assembled (still anchor-free) segment plus its source chunk index. */
 export interface AssembledSegment {
     segment: SpeechSegment;

package/dist/services/tts/highlight-pipeline/boundary-normalizer.js

@@ -1,43 +1,4 @@
-import { resolveSpokenBoundaryOffset } from "../catalog-span-alignment.js";
-import { resolveBoundaryToSpeechToken, tokenizeSpeechSource, } from "../math-alignment/speech-tokenizer.js";
-const normalizeBoundaryWord = (word) => {
-    if (!word || /^<[^>]+>$/.test(word.trim()))
-        return null;
-    return (tokenizeSpeechSource({ speechText: word }).tokens[0]?.normalized || null);
-};
-// Resolve a provider boundary for a chunk that carries no catalog span
-// alignment — notably the generated-SSML math path, whose `speechText` is a
-// raw `<speak>` document. The provider's offset is an index into `speechText`
-// exactly as it was sent (which may include SSML tags), so we tokenize that
-// same string and let the shared speech tokenizer translate the offset into the
-// extracted spoken text. Returns the boundary in spoken-text space alongside
-// that spoken text, so the downstream word/offset checks share one coordinate
-// system. The previous "direct" path treated the raw-SSML offset as a
-// spoken-text offset and rejected every math boundary (PIE-623 regression).
-const speechSourceBoundary = (chunk, event) => {
-    const tokenization = tokenizeSpeechSource({ speechText: chunk.speechText });
-    if (!Number.isFinite(event.position)) {
-        return { boundary: null, spokenText: tokenization.spokenText };
-    }
-    const resolved = resolveBoundaryToSpeechToken({
-        tokenization,
-        position: event.position,
-        length: event.length,
-        boundaryWord: event.word,
-    });
-    return {
-        boundary: resolved
-            ? { start: resolved.start, length: resolved.length }
-            : null,
-        spokenText: tokenization.spokenText,
-    };
-};
-const tokenAtOffsetMatches = (speechText, start, normalizedWord) => {
-    if (!normalizedWord)
-        return true;
-    const token = tokenizeSpeechSource({ speechText }).tokens.find((candidate) => candidate.start <= start && start < candidate.end);
-    return token?.normalized === normalizedWord;
-};
+import { normalizeBoundaryWord, resolveBoundaryToSpeechToken, tokenizeSpeechSource, } from "../math-alignment/speech-tokenizer.js";
 export const normalizeBoundaryEvent = (chunk, event) => {
     const normalizedWord = normalizeBoundaryWord(event.word);
     if (chunk.id !== event.chunkId) {
@@ -61,17 +22,16 @@ export const normalizeBoundaryEvent = (chunk, event) => {
             reason: "boundary offset space is unsupported",
         };
     }
-    let boundary;
-    let spokenText;
-    if (chunk.catalogAlignment) {
-        boundary = resolveSpokenBoundaryOffset(chunk.catalogAlignment, event.position, event.length, event.word);
-        spokenText = chunk.catalogAlignment.spokenText;
-    }
-    else {
-        const resolved = speechSourceBoundary(chunk, event);
-        boundary = resolved.boundary;
-        spokenText = resolved.spokenText;
-    }
+    // The provider's offset indexes `speechText` exactly as sent, which may be a
+    // raw `<speak>` document; the shared tokenizer maps it into spoken text and
+    // checks it against the reported word, on the catalog path and without one.
+    const boundary = resolveBoundaryToSpeechToken({
+        tokenization: chunk.catalogAlignment?.speech ??
+            tokenizeSpeechSource({ speechText: chunk.speechText }),
+        position: event.position,
+        length: event.length,
+        boundaryWord: event.word,
+    });
     if (!boundary) {
         return {
             chunkId: chunk.id,
@@ -82,22 +42,12 @@ export const normalizeBoundaryEvent = (chunk, event) => {
             reason: "could not resolve provider boundary to chunk speech",
         };
     }
-    if (!tokenAtOffsetMatches(spokenText, boundary.start, normalizedWord)) {
-        return {
-            chunkId: chunk.id,
-            normalizedWord,
-            chunkSpokenStart: null,
-            chunkSpokenEnd: null,
-            confidence: 0,
-            reason: "could not resolve provider boundary to matching word",
-        };
-    }
     return {
         chunkId: chunk.id,
         normalizedWord,
         chunkSpokenStart: boundary.start,
         chunkSpokenEnd: boundary.start + boundary.length,
-        confidence: normalizedWord ? 1 : 0.75,
+        confidence: boundary.confidence,
         reason: chunk.catalogAlignment
             ? "resolved through catalog alignment"
             : "resolved through speech tokenization",

package/dist/services/tts/highlight-pipeline/create-highlight-plan.js

@@ -3,6 +3,7 @@ import { createHighlightDecision } from "./highlight-policy.js";
 import { resolveMathBoundaryTarget } from "./math-semantic-resolver.js";
 import { resolveProseBoundaryTarget } from "./prose-boundary-resolver.js";
 import { classifyMathHighlightCapability, createRenderedMathTargetResolver, } from "./rendered-math-target-resolver.js";
+import { isNodeHiddenForTTS } from "../text-processing.js";
 const regionTargetFor = (chunk) => chunk.regionRange
     ? {
         type: "range",
@@ -73,6 +74,25 @@ const wouldEscalateInsideTokenMath = (planned, target, candidates) => {
         element.contains(startContainer) &&
         element.contains(endContainer));
 };
+// A prose range in hidden content paints nothing. Catalog words over MathJax
+// math land in its clipped source MathML, so they select the equation, and a
+// range over one source token resolves to that token's rendered glyph — the
+// fill-in a single-text-node range gives native MathML.
+const isHiddenRange = (target) => target?.type === "range" && isNodeHiddenForTTS(target.range.startContainer);
+const renderHiddenProseTarget = (planned, target) => {
+    if (!isHiddenRange(target))
+        return null;
+    const { startContainer, endContainer, startOffset, endOffset } = target.range;
+    if (startContainer !== endContainer || startContainer.nodeType !== TEXT_NODE)
+        return null;
+    return planned.renderedMathTargetResolver({
+        type: "text-range",
+        quality: "exact-word",
+        node: startContainer,
+        startOffset,
+        endOffset,
+    });
+};
 const createPlannedChunk = (chunk, mathTokenHighlighting) => ({
     chunk,
     regionTarget: regionTargetFor(chunk),
@@ -136,9 +156,13 @@ export const createTTSHighlightPlan = (args) => {
             const normalized = normalizeBoundaryEvent(chunk, event);
             const proseTarget = resolveProseBoundaryTarget(chunk, normalized);
             const mathCandidates = mathCandidatesForTarget(proseTarget, chunk);
-            const mathTarget = (!proseTarget || mathCandidates.length > 0
+            const resolvedMathTarget = (!proseTarget || mathCandidates.length > 0
                 ? resolveMathBoundaryTarget(chunk, normalized, event, mathCandidates, planned.renderedMathTargetResolver)
                 : null) || null;
+            const mathTarget = resolvedMathTarget?.quality === "semantic-token"
+                ? resolvedMathTarget
+                : (renderHiddenProseTarget(planned, proseTarget) ??
+                    resolvedMathTarget);
             const mathTokenTarget = mathTokenHighlighting &&
                 mathTarget &&
                 mathTarget.quality !== "expression"
@@ -169,6 +193,7 @@ export const createTTSHighlightPlan = (args) => {
             // highlighting is disabled, any prose range that lands inside a
             // formula is likewise rejected so the formula stays a single block.
             if (proseTarget &&
+                !isHiddenRange(proseTarget) &&
                 (mathTokenHighlighting
                     ? !wouldEscalateInsideTokenMath(planned, proseTarget, mathCandidates)
                     : mathCandidates.length === 0)) {

package/dist/services/tts/highlight-pipeline/normalize-speech-chunks.js

@@ -1,10 +1,7 @@
 const chunkOffsetSpaceFor = (chunk) => {
-    if (chunk.alignment?.boundaryOffsetMode)
-        return chunk.alignment.boundaryOffsetMode;
-    const mathOffsetSpace = chunk.mathAlignment?.speech.boundaryOffsetSpace;
-    if (mathOffsetSpace)
-        return mathOffsetSpace;
-    return "plain-spoken-text";
+    return (chunk.alignment?.speech.boundaryOffsetSpace ??
+        chunk.mathAlignment?.speech.boundaryOffsetSpace ??
+        "plain-spoken-text");
 };
 const mathAlignmentsFor = (chunk) => {
     if (chunk.mathAlignments?.length)

package/dist/services/tts/math-alignment/index.d.ts

@@ -14,11 +14,6 @@ export declare const resolveHighlightTargetForBoundary: (alignment: MathAwareAli
     length?: number;
     boundaryWord?: string;
 }) => HighlightTarget;
-export declare const resolveMatchedHighlightTargetForBoundary: (alignment: MathAwareAlignment, args: {
-    position: number;
-    length?: number;
-    boundaryWord?: string;
-}) => HighlightTarget | null;
 export declare const resolveMatchedHighlightTargetForSpokenBoundary: (alignment: MathAwareAlignment, args: {
     position: number;
     length?: number;

package/dist/services/tts/math-alignment/index.js

@@ -1,7 +1,7 @@
 import { tokenizeMathML } from "./mathml-tokenizer.js";
 import { resolveMatchedHighlightTargetForBoundary as resolveMatchedTargetForBoundary, resolveHighlightTargetForBoundary as resolveTargetForBoundary, } from "./range-resolver.js";
 import { alignSpeechToMath } from "./sequence-aligner.js";
-import { resolveBoundaryToSpeechToken, resolveSpokenOffsetToSpeechToken, tokenizeSpeechSource, } from "./speech-tokenizer.js";
+import { normalizeBoundaryWord, resolveBoundaryToSpeechToken, resolveSpokenOffsetToSpeechToken, tokenizeSpeechSource, } from "./speech-tokenizer.js";
 export const createMathAwareAlignment = (args) => {
     const speech = tokenizeSpeechSource({ speechText: args.speechText });
     const math = tokenizeMathML(args.mathElement);
@@ -23,18 +23,6 @@ export const resolveHighlightTargetForBoundary = (alignment, args) => {
         boundary,
     });
 };
-export const resolveMatchedHighlightTargetForBoundary = (alignment, args) => {
-    const boundary = resolveBoundaryToSpeechToken({
-        tokenization: alignment.speech,
-        position: args.position,
-        length: args.length,
-        boundaryWord: args.boundaryWord,
-    });
-    return resolveMatchedTargetForBoundary({
-        alignment: alignment.result,
-        boundary,
-    });
-};
 export const resolveMatchedHighlightTargetForSpokenBoundary = (alignment, args) => {
     const boundary = resolveSpokenOffsetToSpeechToken({
         tokenization: alignment.speech,
@@ -48,18 +36,10 @@ export const resolveMatchedHighlightTargetForSpokenBoundary = (alignment, args)
     });
 };
 export const resolveUniqueMathTargetForBoundaryWord = (alignment, args) => {
-    if (!args.boundaryWord || /^<[^>]+>$/.test(args.boundaryWord.trim())) {
-        return null;
-    }
-    const boundaryToken = tokenizeSpeechSource({
-        speechText: args.boundaryWord,
-    }).tokens[0];
-    if (!boundaryToken)
+    const normalized = normalizeBoundaryWord(args.boundaryWord);
+    if (!normalized)
         return null;
-    const matches = alignment.math.tokens.filter((token) => {
-        const normalized = boundaryToken.normalized.toLowerCase();
-        return (token.normalized.toLowerCase() === normalized ||
-            token.spokenAliases.some((alias) => alias.toLowerCase() === normalized));
-    });
+    const matches = alignment.math.tokens.filter((token) => token.normalized.toLowerCase() === normalized ||
+        token.spokenAliases.some((alias) => alias.toLowerCase() === normalized));
     return matches.length === 1 ? matches[0].target : null;
 };

package/dist/services/tts/math-alignment/speech-tokenizer.d.ts

@@ -1,4 +1,4 @@
-import type { BoundaryOffsetSpace, SpeechAlignmentToken } from "./types.js";
+import type { AlignmentTextToken, BoundaryOffsetSpace, SpeechAlignmentToken } from "./types.js";
 export interface SpeechSourceTokenization {
     speechText: string;
     spokenText: string;
@@ -14,9 +14,17 @@ export interface ResolvedSpeechBoundary {
     length: number;
     confidence: number;
 }
+export declare const tokenizeAlignmentText: (text: string) => AlignmentTextToken[];
 export declare const tokenizeSpeechSource: (args: {
     speechText: string;
 }) => SpeechSourceTokenization;
+/**
+ * A provider boundary word in the form spoken tokens compare in, or null when
+ * the word carries no token (empty, a control tag, punctuation). The word goes
+ * through the same SSML extraction as the chunk, so an entity-encoded word
+ * normalizes to the text it encodes.
+ */
+export declare const normalizeBoundaryWord: (word?: string) => string | null;
 export declare const resolveBoundaryToSpeechToken: (args: {
     tokenization: SpeechSourceTokenization;
     position: number;