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

package/dist/services/ToolkitCoordinator.d.ts

@@ -296,7 +296,7 @@ export interface ToolkitServiceBundle {
  *   assessmentId: 'demo-three-questions',
  *   tools: {
  *     providers: {
- *       textToSpeech: { enabled: true, defaultVoice: 'en-US' },
+ *       textToSpeech: { enabled: true, backend: 'browser' },
  *       answerEliminator: { enabled: true, strategy: 'strikethrough' }
  *     },
  *     placement: {
@@ -414,6 +414,17 @@ export declare class ToolkitCoordinator {
      * frozen snapshot.
      */
     private boundCurrentItemRef;
+    /**
+     * Whether {@link decideFeaturePolicy} has already reported serving a decision
+     * with no assessment bound.
+     *
+     * One report per coordinator, not per decision: a feature policy is consulted
+     * once per capability per card, so a per-decision warning would bury itself.
+     * Never reset — {@link updateAssessment} arriving later fixes the deployment,
+     * and re-arming would report the same gap again on the next unbound coordinator
+     * lifetime for no new information.
+     */
+    private reportedUnboundFeaturePolicy;
     private static resolveConfig;
     constructor(config: ToolkitCoordinatorConfig);
     /**
@@ -668,6 +679,12 @@ export declare class ToolkitCoordinator {
      * Thin shim over the owned tool-policy engine; see
      * {@link ToolPolicyEngine.decideFeature} for the contract, including why
      * `pnpEnforcement` is not consulted.
+     *
+     * Reports once per coordinator when it is asked about a feature with no
+     * assessment bound. A host in that state gets a correct denial for every
+     * capability it asks about, which is indistinguishable from a student who was
+     * properly declined — so without this, forgetting {@link updateAssessment}
+     * presents as an accommodation that silently never appears.
      */
     decideFeaturePolicy(featureId: string): FeaturePolicyDecision;
     /**

package/dist/services/ToolkitCoordinator.js

@@ -70,7 +70,7 @@ const SECTION_SCOPED_EVENT_TYPES = [
  *   assessmentId: 'demo-three-questions',
  *   tools: {
  *     providers: {
- *       textToSpeech: { enabled: true, defaultVoice: 'en-US' },
+ *       textToSpeech: { enabled: true, backend: 'browser' },
  *       answerEliminator: { enabled: true, strategy: 'strikethrough' }
  *     },
  *     placement: {
@@ -188,6 +188,17 @@ export class ToolkitCoordinator {
      * frozen snapshot.
      */
     boundCurrentItemRef = null;
+    /**
+     * Whether {@link decideFeaturePolicy} has already reported serving a decision
+     * with no assessment bound.
+     *
+     * One report per coordinator, not per decision: a feature policy is consulted
+     * once per capability per card, so a per-decision warning would bury itself.
+     * Never reset — {@link updateAssessment} arriving later fixes the deployment,
+     * and re-arming would report the same gap again on the next unbound coordinator
+     * lifetime for no new information.
+     */
+    reportedUnboundFeaturePolicy = false;
     static resolveConfig(config) {
         const strictness = normalizeToolConfigStrictness(config.toolConfigStrictness);
         // An empty registry when the host supplies none. This package no longer
@@ -1542,9 +1553,20 @@ export class ToolkitCoordinator {
      * Thin shim over the owned tool-policy engine; see
      * {@link ToolPolicyEngine.decideFeature} for the contract, including why
      * `pnpEnforcement` is not consulted.
+     *
+     * Reports once per coordinator when it is asked about a feature with no
+     * assessment bound. A host in that state gets a correct denial for every
+     * capability it asks about, which is indistinguishable from a student who was
+     * properly declined — so without this, forgetting {@link updateAssessment}
+     * presents as an accommodation that silently never appears.
      */
     decideFeaturePolicy(featureId) {
-        return this.policyEngine.decideFeature(featureId);
+        const decision = this.policyEngine.decideFeature(featureId);
+        if (!decision.assessmentBound && !this.reportedUnboundFeaturePolicy) {
+            this.reportedUnboundFeaturePolicy = true;
+            console.warn(`[ToolkitCoordinator] Feature policy was asked about "${featureId}" with no assessment bound, so every capability will be declined for want of a profile to read. Call updateAssessment(...) with the assessment (its personalNeedsProfile, settings.districtPolicy and settings.testAdministration are what policy reads) before relying on any accommodation. Reported once per coordinator.`);
+        }
+        return decision;
     }
     /**
      * Subscribe to policy-engine change events. Fires whenever the

package/dist/services/catalog-owner.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Identity and traversal rules for one mounted accessibility-catalog owner.
+ *
+ * The resolver is the public lifecycle boundary. This supporting module keeps
+ * its owner identity and direct-lookup helper separate from the runtime event
+ * adapter, while keeping the entity walk private to the resolver package.
+ */
+import type { AccessibilityCatalog } from "@pie-players/pie-players-shared/types";
+export type CatalogOwnerKind = "global" | "passage" | "itemModel";
+interface CatalogOwnerScopeContext {
+    assessmentId?: string;
+    sectionId?: string;
+}
+/** A valid resolver scope for a global, passage, or item/model owner. */
+export type CatalogOwnerContext = (CatalogOwnerScopeContext & {
+    ownerKind: "global";
+    canonicalItemId?: never;
+    itemId?: never;
+    passageId?: never;
+    modelId?: never;
+}) | (CatalogOwnerScopeContext & {
+    ownerKind: "passage";
+    passageId: string;
+    canonicalItemId?: never;
+    itemId?: never;
+    modelId?: never;
+}) | (CatalogOwnerScopeContext & {
+    ownerKind: "itemModel";
+    itemId: string;
+    canonicalItemId?: string;
+    modelId?: string;
+    passageId?: never;
+});
+export interface CatalogOwnerRegistrationEntry {
+    context: CatalogOwnerContext;
+    catalogs: AccessibilityCatalog[];
+}
+/** The entity shape catalogs hang off: an item, or a passage. */
+export interface CatalogSourceEntity {
+    accessibilityCatalogs?: AccessibilityCatalog[];
+    config?: {
+        extractedCatalogs?: AccessibilityCatalog[];
+        models?: Array<{
+            id?: string;
+            accessibilityCatalogs?: AccessibilityCatalog[];
+        }>;
+    };
+}
+/** Who is rendering the entity — everything owner scoping is derived from. */
+export interface CatalogOwnerIdentity {
+    kind: "item" | "passage";
+    /** The rendered instance id. */
+    itemId: string;
+    canonicalItemId?: string;
+    assessmentId?: string;
+    sectionId?: string;
+}
+/**
+ * Build the lookup context for a direct resolver client such as inline TTS.
+ *
+ * Owner registration uses the same function, so direct readers cannot drift
+ * from the context the resolver files the entity under.
+ */
+export declare function catalogOwnerContextFor(owner: CatalogOwnerIdentity): CatalogOwnerContext;
+/**
+ * Collect every catalog group carried by one owner in registration-precedence
+ * order. This is deliberately not exported from the package root: callers
+ * register the owner once through `AccessibilityCatalogResolver.registerOwner`.
+ */
+export declare function collectOwnerCatalogRegistrations(entity: CatalogSourceEntity | null | undefined, owner: CatalogOwnerIdentity): CatalogOwnerRegistrationEntry[];
+export {};

package/dist/services/catalog-owner.js

@@ -0,0 +1,64 @@
+/**
+ * Identity and traversal rules for one mounted accessibility-catalog owner.
+ *
+ * The resolver is the public lifecycle boundary. This supporting module keeps
+ * its owner identity and direct-lookup helper separate from the runtime event
+ * adapter, while keeping the entity walk private to the resolver package.
+ */
+const hasCatalogs = (catalogs) => Array.isArray(catalogs) && catalogs.length > 0;
+/**
+ * Build the lookup context for a direct resolver client such as inline TTS.
+ *
+ * Owner registration uses the same function, so direct readers cannot drift
+ * from the context the resolver files the entity under.
+ */
+export function catalogOwnerContextFor(owner) {
+    if (owner.kind === "passage") {
+        return {
+            ownerKind: "passage",
+            assessmentId: owner.assessmentId,
+            sectionId: owner.sectionId,
+            passageId: owner.canonicalItemId || owner.itemId,
+        };
+    }
+    return {
+        ownerKind: "itemModel",
+        assessmentId: owner.assessmentId,
+        sectionId: owner.sectionId,
+        itemId: owner.itemId,
+        canonicalItemId: owner.canonicalItemId || owner.itemId,
+    };
+}
+/**
+ * Collect every catalog group carried by one owner in registration-precedence
+ * order. This is deliberately not exported from the package root: callers
+ * register the owner once through `AccessibilityCatalogResolver.registerOwner`.
+ */
+export function collectOwnerCatalogRegistrations(entity, owner) {
+    if (!entity)
+        return [];
+    const context = catalogOwnerContextFor(owner);
+    const registrations = [];
+    if (hasCatalogs(entity.accessibilityCatalogs)) {
+        registrations.push({ context, catalogs: entity.accessibilityCatalogs });
+    }
+    if (hasCatalogs(entity.config?.extractedCatalogs)) {
+        registrations.push({
+            context,
+            catalogs: entity.config.extractedCatalogs,
+        });
+    }
+    if (owner.kind === "passage")
+        return registrations;
+    if (context.ownerKind !== "itemModel")
+        return registrations;
+    for (const model of entity.config?.models ?? []) {
+        if (!hasCatalogs(model.accessibilityCatalogs))
+            continue;
+        registrations.push({
+            context: { ...context, modelId: model.id },
+            catalogs: model.accessibilityCatalogs,
+        });
+    }
+    return registrations;
+}

package/dist/services/framework-error.d.ts

@@ -1,5 +1,5 @@
 import type { ToolConfigDiagnostic } from "./tool-config-validation.js";
-export type FrameworkErrorKind = "tool-config" | "runtime-init" | "runtime-dispose" | "coordinator-init" | "provider-init" | "provider-register" | "tts-init" | "tool-state-load" | "tool-state-save" | "section-controller-init" | "section-controller-dispose" | "unknown";
+export type FrameworkErrorKind = "tool-config" | "runtime-init" | "runtime-dispose" | "coordinator-init" | "provider-init" | "provider-register" | "tts-init" | "tool-state-load" | "tool-state-save" | "section-controller-init" | "section-controller-dispose" | "tool-surface" | "unknown";
 export type FrameworkErrorSeverity = "warning" | "error";
 export interface FrameworkErrorModel {
     kind: FrameworkErrorKind;

package/dist/services/interfaces.d.ts

@@ -8,8 +8,11 @@
  * Part of PIE Assessment Toolkit.
  */
 import type { I18nServiceApi } from "@pie-players/pie-players-shared/i18n";
-import type { AccessibilityCatalogResolver, CatalogChangeListener, CatalogLookupContext, CatalogLookupOptions, CatalogOwnerContext, CatalogStatistics, CatalogType, ResolvedCatalog } from "./AccessibilityCatalogResolver.js";
+import type { AccessibilityCatalog } from "@pie-players/pie-players-shared/types";
+import type { AccessibilityCatalogResolver, CatalogChangeListener, CatalogLookupContext, CatalogLookupOptions, CatalogOwnerRegistration, CatalogOwnerView, CatalogStatistics, CatalogType, ResolvedCatalog } from "./AccessibilityCatalogResolver.js";
+import type { CatalogOwnerContext } from "./catalog-owner.js";
 import type { FrameworkErrorListener } from "./framework-error-bus.js";
+import type { FrameworkErrorModel } from "./framework-error.js";
 import type { HighlightColor, HighlightType } from "./HighlightCoordinator.js";
 import type { SectionControllerHandle, SectionItemEventSubscriptionArgs, SectionScopedEventSubscriptionArgs, SectionEventSubscriptionArgs, ToolkitCoordinatorHooks, ToolkitInitStatus } from "./ToolkitCoordinator.js";
 import type { ThemeConfig } from "./ThemeProvider.js";
@@ -291,11 +294,15 @@ export interface AccessibilityCatalogResolverApi {
     /**
      * Add item-level catalogs (called when rendering a new item)
      */
-    addItemCatalogs(catalogs: any[]): void;
+    addItemCatalogs(catalogs: AccessibilityCatalog[]): void;
     /**
      * Register catalogs scoped to a mounted content owner.
      */
-    registerCatalogs?(context: CatalogOwnerContext, catalogs: any[]): () => void;
+    registerCatalogs(context: CatalogOwnerContext, catalogs: AccessibilityCatalog[]): () => void;
+    /** Register every catalog carried by one mounted item or passage. */
+    registerOwner(registration: CatalogOwnerRegistration): () => void;
+    /** Bind read and change observation to one catalog owner. */
+    forOwner(context: CatalogOwnerContext): CatalogOwnerView;
     /**
      * Clear item-level catalogs (called when leaving an item)
      */
@@ -586,6 +593,11 @@ export interface ToolkitCoordinatorApi {
      * `<pie-assessment-toolkit>` consume the same bus.
      */
     subscribeFrameworkErrors(listener: FrameworkErrorListener): () => void;
+    /**
+     * Report a pre-built framework warning or error through the canonical bus.
+     * Optional so structural host coordinators remain assignable.
+     */
+    reportFrameworkError?(model: FrameworkErrorModel): void;
     /**
      * Resolve the visible tool set for a given placement level + scope.
      * Returns the engine's full decision (visible tools, diagnostics,

package/dist/services/tts/browser-provider.js

@@ -7,6 +7,8 @@
  * Part of PIE Assessment Toolkit.
  */
 import { segmentSentences as segmentTextToSentences } from "./text-segmentation.js";
+const NATIVE_START_TIMEOUT_MS = 5_000;
+const VOICE_INVENTORY_TIMEOUT_MS = 2_000;
 const normalizeLanguageCode = (value) => String(value || "")
     .trim()
     .toLowerCase();
@@ -16,11 +18,11 @@ const browserLanguage = () => {
         : "";
     return normalizeLanguageCode(navigatorLanguage || "en-US");
 };
-const findBrowserVoice = (voices, preferredName) => {
-    if (preferredName) {
-        const explicit = voices.find((voice) => voice.name === preferredName);
-        if (explicit)
-            return explicit;
+const findBrowserVoice = (voices, preferredVoice) => {
+    if (preferredVoice) {
+        return (voices.find((voice) => voice.voiceURI === preferredVoice) ||
+            voices.find((voice) => voice.name === preferredVoice) ||
+            null);
     }
     const language = browserLanguage();
     const languagePrefix = language.split("-")[0] || "en";
@@ -95,9 +97,98 @@ class BrowserTTSProviderImpl {
     _isPlaying = false;
     _isPaused = false;
     speakRunId = 0;
+    settlePendingVoiceWait = null;
+    settlePendingChunk = null;
+    onPlaybackStart = undefined;
     constructor(config) {
         this.config = config;
     }
+    waitForBrowserVoices(runId, configuredVoice) {
+        return new Promise((resolve, reject) => {
+            const synth = speechSynthesis;
+            const canUseEventTarget = typeof synth.addEventListener === "function" &&
+                typeof synth.removeEventListener === "function";
+            const previousHandler = canUseEventTarget ? null : synth.onvoiceschanged;
+            let settled = false;
+            let timeout = null;
+            let pendingSettlement = null;
+            const cleanup = () => {
+                if (timeout !== null) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                }
+                if (canUseEventTarget) {
+                    synth.removeEventListener("voiceschanged", onVoicesChanged);
+                }
+                else if (synth.onvoiceschanged === propertyHandler) {
+                    synth.onvoiceschanged = previousHandler;
+                }
+                if (pendingSettlement &&
+                    this.settlePendingVoiceWait === pendingSettlement) {
+                    this.settlePendingVoiceWait = null;
+                }
+            };
+            const finish = (voicesAvailable, error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(voicesAvailable);
+                }
+            };
+            const inspectVoiceInventory = () => {
+                if (runId !== this.speakRunId) {
+                    finish(false);
+                    return;
+                }
+                if (synth.getVoices().length > 0)
+                    finish(true);
+            };
+            const onVoicesChanged = () => inspectVoiceInventory();
+            const propertyHandler = (event) => {
+                try {
+                    previousHandler?.call(synth, event);
+                }
+                finally {
+                    inspectVoiceInventory();
+                }
+            };
+            pendingSettlement = () => finish(false);
+            this.settlePendingVoiceWait = pendingSettlement;
+            timeout = setTimeout(() => finish(false, new Error(`Configured browser voice "${configuredVoice}" could not be resolved because the browser did not publish its voice inventory within ${VOICE_INVENTORY_TIMEOUT_MS / 1_000} seconds.`)), VOICE_INVENTORY_TIMEOUT_MS);
+            if (canUseEventTarget) {
+                synth.addEventListener("voiceschanged", onVoicesChanged);
+            }
+            else {
+                synth.onvoiceschanged = propertyHandler;
+            }
+            // Close the getVoices()/listener-registration race without polling.
+            inspectVoiceInventory();
+        });
+    }
+    async resolveBrowserVoice(runId) {
+        const configuredVoice = typeof this.config?.voice === "string" ? this.config.voice.trim() : "";
+        let voices = speechSynthesis.getVoices();
+        if (configuredVoice && voices.length === 0) {
+            const voicesAvailable = await this.waitForBrowserVoices(runId, configuredVoice);
+            if (!voicesAvailable || runId !== this.speakRunId) {
+                return { shouldContinue: false, voice: null };
+            }
+            voices = speechSynthesis.getVoices();
+        }
+        if (runId !== this.speakRunId) {
+            return { shouldContinue: false, voice: null };
+        }
+        const voice = findBrowserVoice(voices, configuredVoice || undefined);
+        if (configuredVoice && !voice) {
+            throw new Error(`Configured browser voice "${configuredVoice}" is unavailable. Select a voice exposed by this browser using its voiceURI or name.`);
+        }
+        return { shouldContinue: true, voice };
+    }
     async speak(text) {
         if (!this.config) {
             throw new Error("TTS not initialized");
@@ -105,12 +196,15 @@ class BrowserTTSProviderImpl {
         // Invalidate any in-flight run and cancel current utterance.
         this.stop();
         const runId = this.speakRunId;
+        const voiceResolution = await this.resolveBrowserVoice(runId);
+        if (!voiceResolution.shouldContinue)
+            return;
         const chunks = this.splitIntoChunks(text);
         for (const chunk of chunks) {
             if (runId !== this.speakRunId) {
                 break;
             }
-            const shouldContinue = await this.speakChunk(chunk.text, chunk.offset, runId);
+            const shouldContinue = await this.speakChunk(chunk.text, chunk.offset, runId, voiceResolution.voice);
             if (!shouldContinue) {
                 break;
             }
@@ -122,6 +216,9 @@ class BrowserTTSProviderImpl {
         }
         this.stop();
         const runId = this.speakRunId;
+        const voiceResolution = await this.resolveBrowserVoice(runId);
+        if (!voiceResolution.shouldContinue)
+            return;
         for (const segment of segments) {
             if (runId !== this.speakRunId)
                 break;
@@ -129,7 +226,7 @@ class BrowserTTSProviderImpl {
             for (const chunk of chunks) {
                 if (runId !== this.speakRunId)
                     break;
-                const shouldContinue = await this.speakChunk(chunk.text, segment.startOffset + chunk.offset, runId);
+                const shouldContinue = await this.speakChunk(chunk.text, segment.startOffset + chunk.offset, runId, voiceResolution.voice);
                 if (!shouldContinue)
                     break;
             }
@@ -214,7 +311,7 @@ class BrowserTTSProviderImpl {
         const match = slice.match(/^\s*([^\s]+)/);
         return match?.[1]?.length || 1;
     }
-    async speakChunk(chunkText, chunkOffset, runId) {
+    async speakChunk(chunkText, chunkOffset, runId, voice) {
         return new Promise((resolve, reject) => {
             if (runId !== this.speakRunId) {
                 resolve(false);
@@ -223,47 +320,99 @@ class BrowserTTSProviderImpl {
             const utterance = new SpeechSynthesisUtterance(chunkText);
             this.utterance = utterance;
             // Apply config
-            const voice = findBrowserVoice(speechSynthesis.getVoices(), this.config?.voice);
             if (voice && shouldAssignBrowserVoice(voice))
                 utterance.voice = voice;
             if (this.config?.rate)
                 utterance.rate = this.config.rate;
             if (this.config?.pitch)
                 utterance.pitch = this.config.pitch;
+            let didStart = false;
+            let settled = false;
+            let startTimeout = null;
+            let pendingSettlement = null;
             const clearOwnedUtterance = () => {
                 if (this.utterance === utterance) {
                     this.utterance = null;
                 }
             };
+            const clearStartTimeout = () => {
+                if (startTimeout !== null) {
+                    clearTimeout(startTimeout);
+                    startTimeout = null;
+                }
+            };
+            const detachHandlers = () => {
+                utterance.onstart = null;
+                utterance.onend = null;
+                utterance.onerror = null;
+                utterance.onpause = null;
+                utterance.onresume = null;
+                utterance.onboundary = null;
+            };
+            const settle = (shouldContinue, error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearStartTimeout();
+                detachHandlers();
+                clearOwnedUtterance();
+                if (pendingSettlement &&
+                    this.settlePendingChunk === pendingSettlement) {
+                    this.settlePendingChunk = null;
+                }
+                if (runId === this.speakRunId) {
+                    this._isPlaying = false;
+                    this._isPaused = false;
+                }
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(shouldContinue);
+                }
+            };
+            const browserEngineStartError = (reason) => new Error(reason === "ended"
+                ? "Browser speech synthesis ended before audio started. The browser speech engine may be unavailable or stuck; try another voice or restart the browser."
+                : `Browser speech synthesis did not start within ${NATIVE_START_TIMEOUT_MS / 1_000} seconds. The browser speech engine may be unavailable or stuck; try another voice or restart the browser.`);
+            pendingSettlement = () => settle(false);
+            this.settlePendingChunk = pendingSettlement;
             utterance.onstart = () => {
-                if (runId !== this.speakRunId)
+                if (runId !== this.speakRunId) {
+                    settle(false);
                     return;
+                }
+                didStart = true;
+                clearStartTimeout();
                 this._isPlaying = true;
                 this._isPaused = false;
+                try {
+                    this.onPlaybackStart?.();
+                }
+                catch (error) {
+                    console.error("Browser TTS playback-start callback failed", error);
+                }
             };
             utterance.onend = () => {
-                clearOwnedUtterance();
                 if (runId !== this.speakRunId) {
-                    resolve(false);
+                    settle(false);
                     return;
                 }
-                this._isPlaying = false;
-                this._isPaused = false;
-                resolve(true);
+                if (!didStart) {
+                    settle(false, browserEngineStartError("ended"));
+                    return;
+                }
+                settle(true);
             };
             utterance.onerror = (event) => {
-                clearOwnedUtterance();
                 if (runId !== this.speakRunId) {
-                    resolve(false);
+                    settle(false);
                     return;
                 }
-                this._isPlaying = false;
-                this._isPaused = false;
                 if (event.error === "interrupted" || event.error === "canceled") {
-                    resolve(false);
+                    settle(false);
                     return;
                 }
-                reject(new Error(`Speech synthesis error: ${event.error}`));
+                settle(false, new Error(`Speech synthesis error: ${event.error}`));
             };
             utterance.onpause = () => {
                 if (runId !== this.speakRunId)
@@ -300,7 +449,20 @@ class BrowserTTSProviderImpl {
                 console.log("[BrowserProvider] Calling onWordBoundary with word:", word, "at position:", absoluteBoundaryStart);
                 this.onWordBoundary(word, absoluteBoundaryStart, wordLength);
             };
-            speechSynthesis.speak(utterance);
+            startTimeout = setTimeout(() => {
+                if (settled || didStart || runId !== this.speakRunId)
+                    return;
+                settle(false, browserEngineStartError("timedOut"));
+                speechSynthesis.cancel();
+            }, NATIVE_START_TIMEOUT_MS);
+            try {
+                speechSynthesis.speak(utterance);
+            }
+            catch (error) {
+                settle(false, error instanceof Error
+                    ? error
+                    : new Error("Browser speech synthesis failed to queue speech"));
+            }
         });
     }
     pause() {
@@ -314,8 +476,12 @@ class BrowserTTSProviderImpl {
         }
     }
     stop() {
+        const utterance = this.utterance;
+        const shouldCancel = this._isPlaying || utterance !== null;
         this.speakRunId += 1;
-        if (this._isPlaying || this.utterance) {
+        this.settlePendingVoiceWait?.();
+        this.settlePendingChunk?.();
+        if (shouldCancel) {
             speechSynthesis.cancel();
         }
         this.utterance = null;