@pie-players/pie-assessment-toolkit 0.3.63 → 0.3.65

package/dist/services/AccessibilityCatalogResolver.d.ts

@@ -1,4 +1,4 @@
-import type { AccessibilityCatalog } from "@pie-players/pie-players-shared/types";
+import type { AccessibilityCatalog, CatalogCard, CatalogCardPayload } from "@pie-players/pie-players-shared/types";
 export type CatalogOwnerKind = "global" | "passage" | "itemModel";
 export interface CatalogOwnerContext {
     ownerKind: CatalogOwnerKind;
@@ -10,10 +10,50 @@ export interface CatalogOwnerContext {
     modelId?: string;
 }
 export type CatalogLookupContext = CatalogOwnerContext;
+/** What changed in the resolver's catalog set. */
+export type CatalogChangeReason = "scoped-registered" | "scoped-removed" | "item-added" | "item-cleared";
+/**
+ * Emitted after the resolver's catalog set changes.
+ *
+ * Carries no resolved cards on purpose — a listener re-queries with its own
+ * lookup context and options, the same way `ToolPolicyChangeEvent` leaves the
+ * new decision to `decideToolPolicy`. `context` is present for the scoped
+ * reasons, so a listener can cheaply ignore owners it does not render.
+ */
+export interface CatalogChangeEvent {
+    reason: CatalogChangeReason;
+    context?: CatalogOwnerContext;
+}
+export type CatalogChangeListener = (event: CatalogChangeEvent) => void;
 /**
  * Supported accessibility catalog types from QTI 3.0 / APIP
  */
-export type CatalogType = "spoken" | "sign-language" | "braille" | "tactile" | "simplified-language" | "audio-description" | "extended-description" | string;
+export type CatalogType = "spoken" | "sign-language" | "transcript" | "braille" | "tactile" | "simplified-language" | "audio-description" | "extended-description" | string;
+/**
+ * The catalog types PIE names, plus the rule for the ones it does not.
+ *
+ * The type above stays open on purpose: QTI treats the support vocabulary as
+ * extensible, and closing it here would reject content PIE has no reason to
+ * reject and could not usefully validate anyway, since catalogs arrive as
+ * authored JSON rather than through this type. Keeping it open cost something
+ * though — the named literals were documentation only, so a card written
+ * `"spokn"` was a perfectly valid `CatalogType` that no reader would ever ask
+ * for, and it failed by being invisible rather than by failing. That is what
+ * `isKnownCatalogType` and the warnings below are for: the openness stays, the
+ * silence does not.
+ */
+export declare const KNOWN_CATALOG_TYPES: ReadonlySet<string>;
+export declare function isKnownCatalogType(type: string): boolean;
+/**
+ * Which of a card's two content slots it fills.
+ *
+ * Not a new field on the card and not a second discriminant: the card already
+ * says which form it is by carrying `content` or `payload`, and the
+ * exactly-one-of invariant is what makes that unambiguous. This names the
+ * distinction so a lookup can ask for one.
+ */
+export type CatalogCardForm = "content" | "payload";
+export declare const catalogCardForm: (card: CatalogCard) => CatalogCardForm;
 /**
  * Lookup options for catalog resolution
  */
@@ -26,6 +66,23 @@ export interface CatalogLookupOptions {
     useFallback?: boolean;
     /** Scope used to resolve local catalog idrefs for rendered content */
     context?: CatalogLookupContext;
+    /**
+     * Preferred content form, when one catalog type legitimately has both on the
+     * same node.
+     *
+     * The case this exists for is a `spoken` node carrying both a reading script
+     * and a recording of it — which is APIP's authoring pattern and what QTI 3's
+     * migration guidance tells you to keep, the script doubling as the source the
+     * audio was generated from and as the fallback when it cannot play. Before
+     * this, both resolution rungs took the first card matching type and language,
+     * so whichever of the two was written second in the array was unreachable and
+     * nothing said so.
+     *
+     * A preference, not a filter: if the requested form is not present, the other
+     * one is still returned. Callers that cannot use a form must check what they
+     * got, exactly as they already must for a card of a type they did not expect.
+     */
+    form?: CatalogCardForm;
 }
 /**
  * Resolved catalog result
@@ -37,8 +94,16 @@ export interface ResolvedCatalog {
     type: CatalogType;
     /** The language code */
     language?: string;
-    /** The content (HTML, URL, or plain text) */
-    content: string;
+    /**
+     * The string form (SSML, HTML, or plain text). Absent on cards whose content
+     * is structured; those carry `payload` instead.
+     */
+    content?: string;
+    /**
+     * The structured form, for catalog types a string cannot express — a signing
+     * video's sources, poster, and time range. Interpreted according to `type`.
+     */
+    payload?: CatalogCardPayload;
     /** Source of the catalog (assessment or item) */
     source: "assessment" | "item";
 }
@@ -89,11 +154,35 @@ export declare class AccessibilityCatalogResolver {
     private scopedCatalogs;
     private defaultLanguage;
     private sanitizedSpokenCache;
+    private catalogChangeListeners;
     constructor(assessmentCatalogs?: AccessibilityCatalog[], defaultLanguage?: string);
     /**
      * Set the default language for fallback resolution
      */
     setDefaultLanguage(language: string): void;
+    /**
+     * Subscribe to catalog registrations and removals.
+     *
+     * Readers that render a catalog — as opposed to TTS, which resolves by DOM
+     * lookup at the moment it speaks — have to compute "is there a card for this
+     * item" before the catalogs exist: registration is driven by an item shell's
+     * mount event, so a card that renders alongside the item legitimately looks
+     * too early. Without a signal the only options are polling on a deadline (no
+     * budget is right: too short strands the accommodation, too long is a visible
+     * delay) or missing the content silently.
+     *
+     * Same contract as `ToolPolicyEngine.onPolicyChange`, deliberately: a listener
+     * plus an unsubscribe, an event that names the `reason` and carries no
+     * resolved state, and subscriber errors swallowed so one bad listener cannot
+     * break registration. Listeners re-query rather than consuming a payload,
+     * which is what keeps the resolver free of assumptions about who is reading.
+     *
+     * Fires after the mutation, so a listener that re-queries sees the new state.
+     *
+     * @returns Unsubscribe function
+     */
+    onCatalogsChange(listener: CatalogChangeListener): () => void;
+    private emitCatalogsChange;
     /**
      * Get the default language
      */
@@ -134,6 +223,13 @@ export declare class AccessibilityCatalogResolver {
     private findMatchingCard;
     /**
      * Get all available alternatives for a catalog identifier
+     *
+     * Every card goes through `resolveCard`, the same projection `getAlternative`
+     * uses, so enumeration cannot describe a card differently from the resolution
+     * that renders it. It was hand-rolled here once and drifted immediately: the
+     * `signLanguage` alias was folded in on the resolution path only, so a card
+     * that arrived under the alias rendered correctly and was still reported as
+     * carrying no payload by anything asking what alternates exist.
      */
     getAllAlternatives(catalogId: string): ResolvedCatalog[];
     /**

package/dist/services/AccessibilityCatalogResolver.js

@@ -1,4 +1,57 @@
 import { sanitizeSsmlString } from "./SSMLExtractor.js";
+/**
+ * The catalog types PIE names, plus the rule for the ones it does not.
+ *
+ * The type above stays open on purpose: QTI treats the support vocabulary as
+ * extensible, and closing it here would reject content PIE has no reason to
+ * reject and could not usefully validate anyway, since catalogs arrive as
+ * authored JSON rather than through this type. Keeping it open cost something
+ * though — the named literals were documentation only, so a card written
+ * `"spokn"` was a perfectly valid `CatalogType` that no reader would ever ask
+ * for, and it failed by being invisible rather than by failing. That is what
+ * `isKnownCatalogType` and the warnings below are for: the openness stays, the
+ * silence does not.
+ */
+export const KNOWN_CATALOG_TYPES = new Set([
+    "spoken",
+    "sign-language",
+    "transcript",
+    "braille",
+    "tactile",
+    "simplified-language",
+    "audio-description",
+    "extended-description",
+]);
+/**
+ * QTI reserves an `ext:` prefix for vendor extensions, and pairs such a card
+ * with a standard one on the same node in its own examples. A prefixed token is
+ * therefore a deliberate extension rather than a typo, and passes without
+ * comment even though PIE ships no consumer for it.
+ */
+const EXTENSION_TYPE_PREFIX = "ext:";
+export function isKnownCatalogType(type) {
+    if (KNOWN_CATALOG_TYPES.has(type))
+        return true;
+    return (type.startsWith(EXTENSION_TYPE_PREFIX) &&
+        type.length > EXTENSION_TYPE_PREFIX.length);
+}
+// One report per distinct token per side, because the interesting information is
+// "this token is not a thing", and repeating it per card or per lookup would bury
+// it under itself.
+const reportedUnknownTypes = new Set();
+function reportUnknownCatalogType(type, side, where) {
+    const key = `${side}|${type}`;
+    if (reportedUnknownTypes.has(key))
+        return;
+    reportedUnknownTypes.add(key);
+    const known = `${Array.from(KNOWN_CATALOG_TYPES).join(", ")}, or an "${EXTENSION_TYPE_PREFIX}" prefixed vendor extension`;
+    if (side === "card") {
+        console.warn(`[AccessibilityCatalogResolver] catalog "${where}" has a card of unknown type "${type}"; it is stored but no reader asks for that type, so the alternate will never be shown. Expected one of: ${known}.`);
+        return;
+    }
+    console.warn(`[AccessibilityCatalogResolver] lookup for unknown catalog type "${type}" on "${where}" cannot match any card. Expected one of: ${known}.`);
+}
+export const catalogCardForm = (card) => card.payload !== undefined ? "payload" : "content";
 /**
  * Accessibility Catalog Resolver Service
  *
@@ -39,6 +92,7 @@ export class AccessibilityCatalogResolver {
     // provider regardless of where indexing happened; the cache keeps it to one
     // pass per unique string (sanitizeSsmlString is idempotent).
     sanitizedSpokenCache = new Map();
+    catalogChangeListeners = new Set();
     constructor(assessmentCatalogs, defaultLanguage = "en-US") {
         this.defaultLanguage = defaultLanguage;
         this.indexCatalogs(assessmentCatalogs ?? [], "assessment");
@@ -49,6 +103,46 @@ export class AccessibilityCatalogResolver {
     setDefaultLanguage(language) {
         this.defaultLanguage = language;
     }
+    /**
+     * Subscribe to catalog registrations and removals.
+     *
+     * Readers that render a catalog — as opposed to TTS, which resolves by DOM
+     * lookup at the moment it speaks — have to compute "is there a card for this
+     * item" before the catalogs exist: registration is driven by an item shell's
+     * mount event, so a card that renders alongside the item legitimately looks
+     * too early. Without a signal the only options are polling on a deadline (no
+     * budget is right: too short strands the accommodation, too long is a visible
+     * delay) or missing the content silently.
+     *
+     * Same contract as `ToolPolicyEngine.onPolicyChange`, deliberately: a listener
+     * plus an unsubscribe, an event that names the `reason` and carries no
+     * resolved state, and subscriber errors swallowed so one bad listener cannot
+     * break registration. Listeners re-query rather than consuming a payload,
+     * which is what keeps the resolver free of assumptions about who is reading.
+     *
+     * Fires after the mutation, so a listener that re-queries sees the new state.
+     *
+     * @returns Unsubscribe function
+     */
+    onCatalogsChange(listener) {
+        this.catalogChangeListeners.add(listener);
+        return () => {
+            this.catalogChangeListeners.delete(listener);
+        };
+    }
+    emitCatalogsChange(event) {
+        // Iterated over a copy: a listener that unsubscribes itself (or another)
+        // while handling the event must not make the loop skip its neighbours.
+        for (const listener of Array.from(this.catalogChangeListeners)) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Subscriber errors must not break registration. Hosts that want
+                // error telemetry should wrap their listener.
+            }
+        }
+    }
     /**
      * Get the default language
      */
@@ -89,6 +183,12 @@ export class AccessibilityCatalogResolver {
                 catalogs: scoped,
             });
         }
+        // Only when something was actually inserted: an all-duplicates call changes
+        // nothing, and waking every reader to re-resolve for that would make the
+        // signal untrustworthy.
+        if (insertedIds.length > 0) {
+            this.emitCatalogsChange({ reason: "scoped-registered", context });
+        }
         return () => {
             const current = this.scopedCatalogs.get(key);
             if (current?.catalogs !== scoped)
@@ -99,6 +199,9 @@ export class AccessibilityCatalogResolver {
             if (current.catalogs.size === 0) {
                 this.scopedCatalogs.delete(key);
             }
+            if (insertedIds.length > 0) {
+                this.emitCatalogsChange({ reason: "scoped-removed", context });
+            }
         };
     }
     /**
@@ -108,12 +211,16 @@ export class AccessibilityCatalogResolver {
         if (!catalogs || catalogs.length === 0)
             return;
         this.indexCatalogs(catalogs, "item");
+        this.emitCatalogsChange({ reason: "item-added" });
     }
     /**
      * Clear item-level catalogs (called when leaving an item)
      */
     clearItemCatalogs() {
+        if (this.itemCatalogs.size === 0)
+            return;
         this.itemCatalogs.clear();
+        this.emitCatalogsChange({ reason: "item-cleared" });
     }
     /**
      * Check if a catalog exists (checks both assessment and item levels)
@@ -129,6 +236,11 @@ export class AccessibilityCatalogResolver {
      * Priority: Item-level catalogs take precedence over assessment-level
      */
     getAlternative(catalogId, options) {
+        // A typo on this side is as silent as one on a card: the lookup simply finds
+        // nothing and the caller reads that as "no alternate authored".
+        if (!isKnownCatalogType(options.type)) {
+            reportUnknownCatalogType(options.type, "lookup", catalogId);
+        }
         const scopedCatalog = options.context
             ? this.scopedCatalogs
                 .get(this.getOwnerKey(options.context))
@@ -172,9 +284,10 @@ export class AccessibilityCatalogResolver {
             catalogId,
             type: card.catalog,
             language: card.language,
-            content: card.catalog === "spoken"
+            content: card.catalog === "spoken" && card.content !== undefined
                 ? this.ensureSpokenSanitized(card.content)
                 : card.content,
+            payload: card.payload,
             source,
         };
     }
@@ -240,92 +353,104 @@ export class AccessibilityCatalogResolver {
         }
         return true;
     }
+    // The single funnel every registration path runs through — the constructor and
+    // `addItemCatalogs` by way of `indexCatalogs`, and `registerCatalogs`
+    // directly — which is why the unknown-type report lives here rather than at
+    // each entry point.
     sanitizeCatalogs(catalogs) {
         return catalogs.map((catalog) => ({
             ...catalog,
-            cards: catalog.cards.map((card) => ({
-                ...card,
-                content: card.catalog === "spoken"
-                    ? sanitizeSsmlString(card.content)
-                    : card.content,
-            })),
+            cards: catalog.cards.map((card) => {
+                if (!isKnownCatalogType(card.catalog)) {
+                    reportUnknownCatalogType(card.catalog, "card", catalog.identifier);
+                }
+                return {
+                    ...card,
+                    content: card.catalog === "spoken" && card.content !== undefined
+                        ? sanitizeSsmlString(card.content)
+                        : card.content,
+                };
+            }),
         }));
     }
     /**
      * Find a matching catalog card based on lookup options
      */
     findMatchingCard(catalog, options) {
-        const { type, language, useFallback = true } = options;
-        // Try exact match (type + language)
+        const { type, language, useFallback = true, form } = options;
+        // Language rungs, most specific first: requested language, then the default
+        // language, then any. Unchanged — only what happens *within* a rung is new.
+        const languageRungs = [];
         if (language) {
-            const exactMatch = catalog.cards.find((card) => card.catalog === type && card.language === language);
-            if (exactMatch)
-                return exactMatch;
+            languageRungs.push((card) => card.language === language);
         }
-        // Try type match with default language (if fallback enabled)
         if (useFallback) {
-            const defaultMatch = catalog.cards.find((card) => card.catalog === type && card.language === this.defaultLanguage);
-            if (defaultMatch)
-                return defaultMatch;
-            // Try type match without language constraint
-            const typeMatch = catalog.cards.find((card) => card.catalog === type);
-            if (typeMatch)
-                return typeMatch;
+            languageRungs.push((card) => card.language === this.defaultLanguage);
+            languageRungs.push(() => true);
+        }
+        for (const matchesLanguage of languageRungs) {
+            const candidates = catalog.cards.filter((card) => card.catalog === type && matchesLanguage(card));
+            if (candidates.length === 0)
+                continue;
+            // Form is preferred inside a language rung and never across them: a
+            // recording in the requested language beats a script in that language,
+            // but a script in the requested language beats a recording in another
+            // one. Getting this backwards would answer a Spanish lookup with English
+            // audio, which is worse than answering it with Spanish text.
+            if (form) {
+                const preferred = candidates.find((card) => catalogCardForm(card) === form);
+                if (preferred)
+                    return preferred;
+            }
+            // No preference expressed, or the preferred form is absent: first match,
+            // which is what every caller got before form preference existed.
+            return candidates[0];
         }
         return null;
     }
     /**
      * Get all available alternatives for a catalog identifier
+     *
+     * Every card goes through `resolveCard`, the same projection `getAlternative`
+     * uses, so enumeration cannot describe a card differently from the resolution
+     * that renders it. It was hand-rolled here once and drifted immediately: the
+     * `signLanguage` alias was folded in on the resolution path only, so a card
+     * that arrived under the alias rendered correctly and was still reported as
+     * carrying no payload by anything asking what alternates exist.
      */
     getAllAlternatives(catalogId) {
         const results = [];
-        // Add item-level alternatives
+        // Type, language *and* form: one catalog identifier legitimately carries
+        // several cards of the same type in different languages, and also a script
+        // and a recording of the same type in the *same* language. Keying on type
+        // and language alone dropped the second of those on the floor, so anything
+        // asking what alternates exist under-reported them.
+        const claimed = new Set();
+        const add = (card, source) => {
+            const key = `${card.catalog}|${card.language ?? ""}|${catalogCardForm(card)}`;
+            if (claimed.has(key))
+                return;
+            claimed.add(key);
+            results.push(this.resolveCard(catalogId, card, source));
+        };
+        // Item-level first, which is also the precedence `getAlternative` applies.
         const itemCatalog = this.itemCatalogs.get(catalogId);
         if (itemCatalog) {
-            for (const card of itemCatalog.cards) {
-                results.push({
-                    catalogId,
-                    type: card.catalog,
-                    language: card.language,
-                    content: card.content,
-                    source: "item",
-                });
-            }
+            for (const card of itemCatalog.cards)
+                add(card, "item");
         }
-        // Add assessment-level alternatives (if not already provided by item)
         const assessmentCatalog = this.assessmentCatalogs.get(catalogId);
         if (assessmentCatalog) {
-            for (const card of assessmentCatalog.cards) {
-                // Only add if not already provided by item catalog
-                const exists = results.some((r) => r.type === card.catalog && r.language === card.language);
-                if (!exists) {
-                    results.push({
-                        catalogId,
-                        type: card.catalog,
-                        language: card.language,
-                        content: card.content,
-                        source: "assessment",
-                    });
-                }
-            }
+            for (const card of assessmentCatalog.cards)
+                add(card, "assessment");
         }
-        // Add scoped (context-registered) alternatives. These resolve as "item"
-        // in getAlternative, so report them the same way here.
+        // Scoped (context-registered) alternatives resolve as "item" in
+        // `getAlternative`, so report them the same way here.
         for (const [id, catalog] of this.scopedCatalogEntries()) {
             if (id !== catalogId)
                 continue;
-            for (const card of catalog.cards) {
-                const exists = results.some((r) => r.type === card.catalog && r.language === card.language);
-                if (!exists) {
-                    results.push({
-                        catalogId,
-                        type: card.catalog,
-                        language: card.language,
-                        content: card.content,
-                        source: "item",
-                    });
-                }
-            }
+            for (const card of catalog.cards)
+                add(card, "item");
         }
         return results;
     }

package/dist/services/SSMLExtractor.js

@@ -377,26 +377,36 @@ export class SSMLExtractor {
                     const language = speakEl.getAttribute("xml:lang") ||
                         speakEl.getAttribute("lang") ||
                         "en-US";
-                    // Get plain text for visual display
-                    const plainText = speakEl.textContent || "";
-                    // Find parent element or create wrapper
-                    let wrapper = speakEl.parentElement;
-                    if (!wrapper || wrapper.tagName === "BODY") {
-                        // SPEAK is at root level - create span wrapper
-                        const span = doc.createElement("span");
-                        speakEl.parentNode?.insertBefore(span, speakEl);
-                        span.appendChild(doc.createTextNode(plainText));
-                        wrapper = span;
-                        speakEl.remove();
+                    // The docking node is the element the author already wrote around
+                    // the visible content this SSML speaks. Nothing is synthesized to
+                    // stand in for it: a `<speak>` with no element around it has no
+                    // content node to be an alternate *for*, and inventing one would
+                    // mean inventing visible content too.
+                    const wrapper = speakEl.parentElement && speakEl.parentElement.tagName !== "BODY"
+                        ? speakEl.parentElement
+                        : null;
+                    // Visible content never keeps the SSML, docked or not.
+                    speakEl.remove();
+                    // Tag the docking node with the QTI-style catalog reference so the
+                    // runtime can resolve this region's spoken content. Same attribute
+                    // authored content uses (`data-catalog-idref`) — one canonical name,
+                    // which is also why an existing value is never replaced: the
+                    // reference names a whole card array, so overwriting it to win the
+                    // spoken type would take that node's braille, simplified-language and
+                    // sign-language cards down with it.
+                    //
+                    // Either way the catalog is still emitted, so a consumer resolving
+                    // through the item's catalog set finds it. What an undocked catalog
+                    // loses is DOM lookup, which is how TTS resolves — a content problem
+                    // only the author can fix, so say so rather than failing silently.
+                    const existingIdRef = wrapper?.getAttribute("data-catalog-idref");
+                    if (!wrapper) {
+                        console.warn(`[SSMLExtractor] "${idPrefix}" has a <speak> with no element around it, so catalog "${catalogId}" has no content node to dock to and TTS will not find it. Wrap the visible content this SSML speaks in an element.`);
                     }
-                    else {
-                        // Just remove <speak> - visual content should be in sibling element
-                        speakEl.remove();
+                    else if (existingIdRef) {
+                        console.warn(`[SSMLExtractor] "${idPrefix}" has an inline <speak> inside a node already docked to catalog "${existingIdRef}"; keeping the existing reference, so catalog "${catalogId}" is not reachable from this node. Give the <speak> its own wrapper element, or author the SSML as a "spoken" card on "${existingIdRef}".`);
                     }
-                    // Tag the wrapper with the QTI-style catalog reference so the
-                    // runtime can resolve this region's spoken content. Same attribute
-                    // authored content uses (`data-catalog-idref`) — one canonical name.
-                    if (wrapper) {
+                    else {
                         wrapper.setAttribute("data-catalog-idref", catalogId);
                     }
                     // Create catalog entry

package/dist/services/TTSService.d.ts

@@ -64,6 +64,7 @@ export declare class TTSService {
     private activeWordBoundaryOffset;
     private seekSegments;
     private playbackChunks;
+    private activeRecordedAudio;
     private sentenceHighlightSegments;
     private currentSeekSegmentIndex;
     private activeSentenceStartOffset;
@@ -108,6 +109,18 @@ export declare class TTSService {
      * @param resolver AccessibilityCatalogResolver instance
      */
     setCatalogResolver(resolver: AccessibilityCatalogResolver): void;
+    /**
+     * Whether a catalog holds spoken content this service could actually speak.
+     *
+     * Exists because `data-catalog-idref` is one attribute with several readers:
+     * a node can be docked to a catalog that carries only a signing card, and the
+     * nearest docked ancestor of a selection is therefore not necessarily the one
+     * holding its authored SSML. A caller resolving a selection climbs ancestors
+     * and asks this before settling on an id — see the TTS tool's
+     * `findSpokenCatalogId`. Without it, a signing card docked on an inner node
+     * silently shadows authored speech on an outer one.
+     */
+    hasSpokenAlternate(catalogId: string, language?: string): boolean;
     private getHighlightResolverRuntime;
     private getNodeElement;
     private isElementWithinScope;
@@ -193,6 +206,18 @@ export declare class TTSService {
     private highlightRenderableActiveTarget;
     private renderHighlightDecision;
     private speakCatalogChunk;
+    /**
+     * Play a recorded spoken alternate, resolving when it finishes.
+     *
+     * Rejects if the clip cannot play, which is what routes playback to the
+     * chunk's `plainFallback` — the reading script — in `speakCatalogChunk`.
+     * Highlighting is the docked node as a block for the clip's duration: a
+     * recording emits no word boundaries, and inventing them from its duration
+     * would highlight the wrong words confidently rather than the right region
+     * vaguely.
+     */
+    private playRecordedAudio;
+    private cancelRecordedAudio;
     private speakCatalogChunkOnce;
     private executeSpeakPlayback;
     private clearHighlightsAndTracking;