@readium/speech 0.7.0 → 0.8.0

package/build/Fallback/fallbackEngineProvider.d.ts

@@ -0,0 +1,21 @@
+import { ReadiumSpeechEngineProvider } from '../provider';
+import { ReadiumSpeechPlaybackEngine } from '../engine';
+import { ReadiumSpeechVoice } from '../voices/types';
+export interface FallbackEngineProviderOptions {
+    primary: ReadiumSpeechEngineProvider;
+    fallback: ReadiumSpeechEngineProvider;
+    onFailure?: "fallback" | "error" | "fallbackAndRecover";
+    healthCheckIntervalMs?: number;
+}
+export declare class FallbackEngineProvider implements ReadiumSpeechEngineProvider {
+    readonly id: string;
+    readonly name: string;
+    private readonly primary;
+    private readonly fallback;
+    private readonly onFailure;
+    private readonly healthCheckIntervalMs?;
+    constructor(options: FallbackEngineProviderOptions);
+    getVoices(forceRefresh?: boolean): Promise<ReadiumSpeechVoice[]>;
+    createEngine(voice?: ReadiumSpeechVoice | string): Promise<ReadiumSpeechPlaybackEngine>;
+    destroy(): Promise<void>;
+}

package/build/Fallback/fallbackSpeechEngine.d.ts

@@ -0,0 +1,68 @@
+import { ReadiumSpeechPlaybackEngine } from '../engine';
+import { ReadiumSpeechEngineProvider } from '../provider';
+import { ReadiumSpeechPlaybackEvent, ReadiumSpeechPlaybackState } from '../navigator';
+import { ReadiumSpeechUtterance } from '../utterance';
+import { ReadiumSpeechVoice } from '../voices/types';
+export interface FallbackSpeechEngineOptions {
+    primaryEngine: ReadiumSpeechPlaybackEngine;
+    primaryProvider: ReadiumSpeechEngineProvider;
+    fallbackProvider: ReadiumSpeechEngineProvider;
+    onFailure?: "fallback" | "error" | "fallbackAndRecover";
+    healthCheckIntervalMs?: number;
+}
+export declare class FallbackSpeechEngine implements ReadiumSpeechPlaybackEngine {
+    private activeEngine;
+    private readonly primaryProvider;
+    private readonly fallbackProvider;
+    private readonly onFailure;
+    private readonly healthCheckIntervalMs;
+    private hasFallenBack;
+    private healthCheckTimer;
+    private primaryReachable;
+    private currentUtterances;
+    private lastVoiceRequest;
+    private desiredIndex;
+    private desiredPlaying;
+    private engineStarted;
+    private swapInFlight;
+    private teardownEpoch;
+    private loadToken;
+    private readonly events;
+    private unbindActiveEngine;
+    constructor(options: FallbackSpeechEngineOptions);
+    initialize(): Promise<unknown>;
+    loadUtterances(contents: ReadiumSpeechUtterance[], startIndex?: number): void;
+    setVoice(voice: ReadiumSpeechVoice | string): void;
+    getCurrentVoice(): ReadiumSpeechVoice | null;
+    getAvailableVoices(): Promise<ReadiumSpeechVoice[]>;
+    setSpeakInContentLanguage(enabled: boolean): void;
+    getSpeakInContentLanguage(): boolean;
+    speak(utteranceIndex?: number): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    setRate(rate: number): void;
+    getRate(): number;
+    setPitch(pitch: number): void;
+    getPitch(): number;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    private isEngineTrusted;
+    getState(): ReadiumSpeechPlaybackState;
+    getCurrentUtteranceIndex(): number;
+    setCurrentUtteranceIndex(index: number, onComplete?: (success: boolean) => void): void;
+    getUtteranceCount(): number;
+    on(event: ReadiumSpeechPlaybackEvent["type"], callback: (event: ReadiumSpeechPlaybackEvent) => void): () => void;
+    private emitEvent;
+    private bindActiveEngine;
+    private handleError;
+    private copyPlaybackParameters;
+    private startEngineWhenReady;
+    private startHealthCheck;
+    private maybeRecoverNow;
+    private swapToFallback;
+    private recoverToPrimary;
+    private performSwap;
+    private pickBestFallbackVoice;
+    destroy(): Promise<void>;
+}

package/build/Fallback/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fallbackSpeechEngine';
+export * from './fallbackEngineProvider';
+export * from './recoverableFailure';

package/build/Fallback/recoverableFailure.d.ts

@@ -0,0 +1,10 @@
+import { ReadiumSpeechPlaybackEvent } from '../navigator';
+export interface ErrorEventDetail {
+    message: string;
+    recoverable: boolean;
+    status?: number;
+    type?: string;
+    title?: string;
+    instance?: string;
+}
+export declare function isRecoverableFailure(event: ReadiumSpeechPlaybackEvent): boolean;

package/build/SpeechServer/errors.d.ts

@@ -17,4 +17,13 @@ export declare class SpeechServerError extends Error {
         instance?: string;
     });
 }
+export declare class SpeechServerStallError extends SpeechServerError {
+    constructor(message: string);
+}
+export declare class SpeechServerAudioDecodeError extends Error {
+    constructor(message: string);
+}
+export declare class SpeechServerNetworkError extends Error {
+    constructor(message: string);
+}
 export declare function toSpeechServerError(response: Response): Promise<SpeechServerError>;

package/build/SpeechServer/speechServerEngine.d.ts

@@ -15,6 +15,7 @@ export interface SpeechServerEngineOptions {
     readyBufferChars?: number;
     overLengthText?: "split" | "error";
     format?: SpeechServerFormatOptions;
+    timeoutMs?: number;
 }
 export declare class SpeechServerEngine implements ReadiumSpeechPlaybackEngine {
     private endpoints;
@@ -26,17 +27,19 @@ export declare class SpeechServerEngine implements ReadiumSpeechPlaybackEngine {
     private currentUtterances;
     private currentUtteranceIndex;
     private playbackState;
-    private eventListeners;
+    private readonly events;
     private speakInContentLanguage;
     private speakGeneration;
     private loadGeneration;
     private readonly prefetchWindow;
     private readonly readyBufferChars;
     private readonly overLengthText;
+    private readonly timeoutMs;
     private readonly formatOptions;
     private readonly canPlayType;
     private prefetchCache;
     private prefetchChainTail;
+    private activeControllers;
     private audioContext;
     private masterGain;
     private scheduledChunks;
@@ -46,7 +49,8 @@ export declare class SpeechServerEngine implements ReadiumSpeechPlaybackEngine {
     private volume;
     constructor(options: SpeechServerEngineOptions);
     setAvailableVoices(voices: ReadiumSpeechVoice[]): void;
-    loadUtterances(contents: ReadiumSpeechUtterance[]): void;
+    private fetchNetwork;
+    loadUtterances(contents: ReadiumSpeechUtterance[], startIndex?: number): void;
     private bufferUntilReady;
     private indexCoveringChars;
     setVoice(voice: ReadiumSpeechVoice | string): void;
@@ -65,6 +69,7 @@ export declare class SpeechServerEngine implements ReadiumSpeechPlaybackEngine {
     private synthesizeStream;
     private synthesizeChunk;
     private ensureAudioContext;
+    private awaitWithStallDeadline;
     private scheduleChunksStreaming;
     private handleUtteranceEnded;
     private startBoundaryPolling;

package/build/SpeechServer/speechServerEngineProvider.d.ts

@@ -10,7 +10,7 @@ export declare class SpeechServerEngineProvider implements ReadiumSpeechEnginePr
     private fetchImpl;
     private voices;
     constructor(options: SpeechServerEngineProviderOptions);
-    getVoices(): Promise<ReadiumSpeechVoice[]>;
+    getVoices(forceRefresh?: boolean): Promise<ReadiumSpeechVoice[]>;
     createEngine(voice?: ReadiumSpeechVoice | string): Promise<ReadiumSpeechPlaybackEngine>;
     destroy(): Promise<void>;
 }

package/build/SpeechServer/speechServerVoiceMapping.d.ts

@@ -1,3 +1,3 @@
-import { ReadiumSpeechVoice } from '../voices/types';
+import { ReadiumSpeechVoice, TServerVoiceControls } from '../voices/types';
 import { SpeechServerVoice } from './types';
-export declare function mapServerVoice(voice: SpeechServerVoice): ReadiumSpeechVoice;
+export declare function mapServerVoice(voice: SpeechServerVoice, providerControls?: TServerVoiceControls): ReadiumSpeechVoice;

package/build/SpeechServer/types.d.ts

@@ -8,7 +8,6 @@ export interface SpeechServerVoice {
     otherLanguages?: string[];
     gender?: TGender | null;
     quality?: TQuality;
-    controls?: TServerVoiceControls;
 }
 export interface SpeechServerTimingMark {
     name: "word" | "sentence";
@@ -52,5 +51,7 @@ export interface SpeechServerServiceInfo {
     providers: {
         id: string;
         installedLanguages: string[];
+        quality?: TQuality;
+        controls?: TServerVoiceControls;
     }[];
 }

package/build/WebSpeech/WebSpeechVoiceManager.d.ts

@@ -84,11 +84,6 @@ export declare class WebSpeechVoiceManager {
      * @returns A tuple of [language, region] where language is lowercase and region is UPPERCASE
      */
     static extractLangRegionFromBCP47(lang: string): [string, string | undefined];
-    /**
-     * Get display name for a language code
-     * @private
-     */
-    private static getLanguageDisplayName;
     /**
      * Clean voice name by removing specific formatting
      * @private
@@ -188,39 +183,16 @@ export declare class WebSpeechVoiceManager {
      * @returns Filtered array with very low quality voices removed
      */
     filterOutVeryLowQualityVoices(voices?: ReadiumSpeechVoice[]): ReadiumSpeechVoice[];
-    /**
-   * Get the numeric value for a quality level
-   * @param quality Quality level
-   * @returns Numeric value (higher = better quality, 0 for undefined/null)
-   */
-    private static getQualityValue;
-    /**
-     * Sort two voices by quality, using JSON order as fallback for undefined/null quality
-     * @param a First voice
-     * @param b Second voice
-     * @param jsonOrderMaps Optional map of language codes to voice order maps
-     * @param baseLang Base language code to use for looking up the order map
-     * @returns Comparison result (-1, 0, or 1)
-     */
-    private static sortByQuality;
     /**
      * Sort voices by quality, respecting JSON name order, then alphabetically for undefined/null quality
      * @param voices Array of voices to sort
      * @returns Sorted array of voices
      */
     sortVoicesByQuality(voices?: ReadiumSpeechVoice[]): Promise<ReadiumSpeechVoice[]>;
-    /**
-    * Group voices by language based on processed preferred languages
-    */
-    private static groupVoicesByLanguage;
     /**
      * Sort regions by default then alphabetically, sort voices by quality
      */
     private static sortByDefaultRegion;
-    /**
-     * Sort voices alphabetically by language, then region, then quality
-     */
-    private static sortAlphabetically;
     /**
      * Sort voices by language preference, then alphabetically
      * @param voices Array of voices to sort
@@ -228,10 +200,6 @@ export declare class WebSpeechVoiceManager {
      * @returns Sorted array of voices
      */
     sortVoicesByLanguages(preferredLanguages?: string[], voices?: ReadiumSpeechVoice[]): Promise<ReadiumSpeechVoice[]>;
-    /**
-     * Sort languages by region preference, then voices by quality
-     */
-    private static sortByPreferredRegion;
     /**
      * Sort voices by region preference, then alphabetically
      * @param voices Array of voices to sort

package/build/WebSpeech/webSpeechEngine.d.ts

@@ -9,7 +9,7 @@ export declare class WebSpeechEngine implements ReadiumSpeechPlaybackEngine {
     private currentUtterances;
     private currentUtteranceIndex;
     private playbackState;
-    private eventListeners;
+    private readonly events;
     private voiceManager;
     private voices;
     private defaultVoice;
@@ -49,7 +49,7 @@ export declare class WebSpeechEngine implements ReadiumSpeechPlaybackEngine {
     setSpeakInContentLanguage(enabled: boolean): void;
     getSpeakInContentLanguage(): boolean;
     private toPlainText;
-    loadUtterances(contents: ReadiumSpeechUtterance[]): void;
+    loadUtterances(contents: ReadiumSpeechUtterance[], startIndex?: number): void;
     setVoice(voice: ReadiumSpeechVoice | string): Promise<void>;
     getAvailableVoices(): Promise<ReadiumSpeechVoice[]>;
     speak(utteranceIndex?: number): void;

package/build/engine.d.ts

@@ -3,7 +3,7 @@ import { ReadiumSpeechUtterance } from './utterance';
 import { ReadiumSpeechVoice } from './voices/types';
 export interface ReadiumSpeechPlaybackEngine {
     initialize?(): Promise<unknown>;
-    loadUtterances(contents: ReadiumSpeechUtterance[]): void;
+    loadUtterances(contents: ReadiumSpeechUtterance[], startIndex?: number): void;
     setVoice(voice: ReadiumSpeechVoice | string): void;
     getCurrentVoice(): ReadiumSpeechVoice | null;
     getAvailableVoices(): Promise<ReadiumSpeechVoice[]>;