@andresaya/edge-tts 1.8.1 → 1.9.0

package/dist/config/constants.d.ts

@@ -17,13 +17,12 @@ export declare const Constants: {
         Pragma: string;
         'Cache-Control': string;
         Origin: string;
-        'Sec-WebSocket-Protocol': string;
-        'Sec-WebSocket-Version': string;
         'User-Agent': string;
     };
     VOICE_HEADERS: {
         'Sec-CH-UA': string;
         'Sec-CH-UA-Mobile': string;
+        'Sec-CH-UA-Platform': string;
         Accept: string;
         'Sec-Fetch-Site': string;
         'Sec-Fetch-Mode': string;

package/dist/config/constants.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Constants = void 0;
+const crypto_1 = require("../core/crypto");
 exports.Constants = {
     TRUSTED_CLIENT_TOKEN: '6A5AA1D4EAFF4E9FB37E23D68491D6F4',
     BASE_URL: 'https://speech.platform.bing.com/consumer/speech/synthesize/readaloud',
-    WSS_URL: 'wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1',
+    // NOTE: token goes as Ocp-Apim-Subscription-Key here; Edge user agents only.
+    WSS_URL: 'wss://api.msedgeservices.com/tts/cognitiveservices/websocket/v1',
     VOICES_URL: 'https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list',
-    CHROMIUM_FULL_VERSION: '143.0.3650.75',
-    CHROMIUM_MAJOR_VERSION: '143',
-    VERSION_MS_GEC: '1-143.0.3650',
+    CHROMIUM_FULL_VERSION: '155.0.0.0',
+    CHROMIUM_MAJOR_VERSION: '155',
+    VERSION_MS_GEC: '1-155.0.4283.45',
     token32() {
         const bytes = new Uint8Array(16);
-        crypto.getRandomValues(bytes);
+        (0, crypto_1.webCrypto)().getRandomValues(bytes);
         return Array.from(bytes)
             .map(b => b.toString(16).padStart(2, '0'))
             .join('')
@@ -19,7 +21,7 @@ exports.Constants = {
     },
     getBaseHeaders() {
         return {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36 Edg/143.0.0.0',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36 Edg/155.0.0.0',
             'Accept-Encoding': 'gzip, deflate, br, zstd',
             'Accept-Language': 'en-US,en;q=0.9',
             'Cookie': 'MUID=' + this.token32()
@@ -29,13 +31,12 @@ exports.Constants = {
         'Pragma': 'no-cache',
         'Cache-Control': 'no-cache',
         'Origin': 'chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold',
-        'Sec-WebSocket-Protocol': 'synthesize',
-        'Sec-WebSocket-Version': '13',
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.3650.75 Safari/537.36 Edg/143.0.3650.75'
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36 Edg/155.0.0.0'
     },
     VOICE_HEADERS: {
-        'Sec-CH-UA': '" Not;A Brand";v="99", "Microsoft Edge";v="143", "Chromium";v="143"',
+        'Sec-CH-UA': '"Microsoft Edge";v="155", "Chromium";v="155", "Not(A:Brand";v="24"',
         'Sec-CH-UA-Mobile': '?0',
+        'Sec-CH-UA-Platform': '"Windows"',
         'Accept': '*/*',
         'Sec-Fetch-Site': 'none',
         'Sec-Fetch-Mode': 'cors',

package/dist/core/base.d.ts

@@ -0,0 +1,33 @@
+import { type SocketLike } from './session';
+import type { EdgeTTSOptions, SentenceBoundary, SynthesisOptions, SynthesisResult, Voice, WordBoundary } from './types';
+export declare const NO_AUDIO_MESSAGE: string;
+export declare function noAudioMessage(outputFormat: string): string;
+export declare abstract class EdgeTTSCore {
+    protected audio_stream: Uint8Array[];
+    protected output_format: string;
+    protected word_boundaries: WordBoundary[];
+    protected sentence_boundaries: SentenceBoundary[];
+    protected readonly options: EdgeTTSOptions;
+    private voicesCache?;
+    protected abstract readonly defaultVoice: string;
+    constructor(options?: EdgeTTSOptions);
+    protected abstract openSocket(url: string): SocketLike;
+    protected abstract requestVoices(url: string): Promise<any[]>;
+    protected abstract buildSSML(text: string, voice: string, options: SynthesisOptions): string;
+    protected abstract timestamp(): string;
+    protected abstract socketError(event: unknown, opened: boolean): Error;
+    protected recoverHandshake(): Promise<boolean>;
+    protected signature(): Promise<string>;
+    normalizeVoices(data: any[]): Promise<Voice[]>;
+    getVoices(): Promise<Voice[]>;
+    getVoicesByLanguage(locale: string): Promise<Voice[]>;
+    getVoicesByGender(gender: 'Male' | 'Female'): Promise<Voice[]>;
+    synthesize(text: string, voice?: string, options?: SynthesisOptions): Promise<void>;
+    synthesizeStream(text: string, voice?: string, options?: SynthesisOptions): AsyncGenerator<Uint8Array, void, unknown>;
+    generate(text: string, voice?: string, options?: SynthesisOptions): Promise<SynthesisResult>;
+    getWordBoundaries(): WordBoundary[];
+    getSentenceBoundaries(): SentenceBoundary[];
+    toSRT(): string;
+    toVTT(): string;
+    private run;
+}

package/dist/core/base.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeTTSCore = exports.NO_AUDIO_MESSAGE = void 0;
+exports.noAudioMessage = noAudioMessage;
+const constants_1 = require("../config/constants");
+const clock_1 = require("./clock");
+const errors_1 = require("./errors");
+const protocol_1 = require("./protocol");
+const session_1 = require("./session");
+const subtitles_1 = require("./subtitles");
+const DEFAULT_TIMEOUT = 30_000;
+const DEFAULT_VOICES_CACHE_TTL = 10 * 60_000;
+exports.NO_AUDIO_MESSAGE = "The service returned no audio. Voices are locale specific, so a voice cannot " +
+    "read text written in another script. Check that the voice matches the language " +
+    "of the text.";
+function noAudioMessage(outputFormat) {
+    const supported = Object.values(constants_1.Constants.OUTPUT_FORMAT);
+    if (supported.includes(outputFormat))
+        return exports.NO_AUDIO_MESSAGE;
+    return `${exports.NO_AUDIO_MESSAGE} The output format "${outputFormat}" may also be the cause: ` +
+        `the service is known to support ${supported.join(', ')}.`;
+}
+function collect(text, words, sentences) {
+    const restore = (0, protocol_1.sentenceTextRestorer)(text);
+    return (boundary) => {
+        if (boundary.type === 'WordBoundary')
+            words.push(boundary);
+        else
+            sentences.push({ ...boundary, text: restore(boundary.text) });
+    };
+}
+class EdgeTTSCore {
+    audio_stream = [];
+    output_format = protocol_1.DEFAULT_OUTPUT_FORMAT;
+    word_boundaries = [];
+    sentence_boundaries = [];
+    options;
+    voicesCache;
+    constructor(options = {}) {
+        this.options = { ...options };
+    }
+    async recoverHandshake() {
+        return false;
+    }
+    signature() {
+        return (0, protocol_1.generateSecMsGec)(constants_1.Constants.TRUSTED_CLIENT_TOKEN, (0, clock_1.now)());
+    }
+    async normalizeVoices(data) {
+        return (0, protocol_1.normalizeVoices)(data);
+    }
+    async getVoices() {
+        if (this.voicesCache && this.voicesCache.expires > Date.now()) {
+            return JSON.parse(JSON.stringify(this.voicesCache.voices));
+        }
+        const secMsGEC = await this.signature();
+        const url = `${this.options.voicesUrl ?? constants_1.Constants.VOICES_URL}` +
+            `?TrustedClientToken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}` +
+            `&Sec-MS-GEC=${secMsGEC}` +
+            `&Sec-MS-GEC-Version=${this.options.secMsGecVersion ?? constants_1.Constants.VERSION_MS_GEC}`;
+        const voices = await this.normalizeVoices(await this.requestVoices(url));
+        const ttl = this.options.voicesCacheTtl ?? DEFAULT_VOICES_CACHE_TTL;
+        if (ttl > 0) {
+            this.voicesCache = { expires: Date.now() + ttl, voices: JSON.parse(JSON.stringify(voices)) };
+        }
+        return voices;
+    }
+    async getVoicesByLanguage(locale) {
+        const voices = await this.getVoices();
+        return voices.filter(voice => voice.Locale?.startsWith(locale));
+    }
+    async getVoicesByGender(gender) {
+        const voices = await this.getVoices();
+        return voices.filter(voice => voice.Gender === gender);
+    }
+    async synthesize(text, voice = this.defaultVoice, options = {}) {
+        const audio = [];
+        const words = [];
+        const sentences = [];
+        this.audio_stream = audio;
+        this.word_boundaries = words;
+        this.sentence_boundaries = sentences;
+        this.output_format = options.outputFormat || protocol_1.DEFAULT_OUTPUT_FORMAT;
+        await this.run(text, voice, options, chunk => audio.push(chunk), collect(text, words, sentences));
+    }
+    async *synthesizeStream(text, voice = this.defaultVoice, options = {}) {
+        const audio = [];
+        const words = [];
+        const sentences = [];
+        this.audio_stream = audio;
+        this.word_boundaries = words;
+        this.sentence_boundaries = sentences;
+        this.output_format = options.outputFormat || protocol_1.DEFAULT_OUTPUT_FORMAT;
+        const controller = new AbortController();
+        const forwardAbort = () => controller.abort((0, session_1.abortReason)(options.signal));
+        if (options.signal?.aborted)
+            forwardAbort();
+        else
+            options.signal?.addEventListener('abort', forwardAbort, { once: true });
+        const queue = [];
+        let wake = null;
+        let done = false;
+        let failure;
+        const notify = () => {
+            wake?.();
+            wake = null;
+        };
+        this.run(text, voice, { ...options, signal: controller.signal }, chunk => {
+            audio.push(chunk);
+            queue.push(chunk);
+            notify();
+        }, collect(text, words, sentences)).then(() => { done = true; notify(); }, error => { failure = error; done = true; notify(); });
+        try {
+            while (!done || queue.length > 0) {
+                if (queue.length === 0) {
+                    await new Promise(resolve => (wake = resolve));
+                    continue;
+                }
+                yield queue.shift();
+            }
+            if (failure !== undefined)
+                throw failure;
+        }
+        finally {
+            options.signal?.removeEventListener('abort', forwardAbort);
+            if (!done)
+                controller.abort();
+        }
+    }
+    async generate(text, voice = this.defaultVoice, options = {}) {
+        const chunks = [];
+        const words = [];
+        const sentences = [];
+        await this.run(text, voice, options, chunk => chunks.push(chunk), collect(text, words, sentences));
+        const audio = (0, protocol_1.concatChunks)(chunks);
+        const outputFormat = options.outputFormat || protocol_1.DEFAULT_OUTPUT_FORMAT;
+        if (audio.length === 0)
+            throw new errors_1.EdgeTTSError(noAudioMessage(outputFormat), 'NO_AUDIO');
+        return {
+            audio,
+            format: (0, protocol_1.fileExtension)(outputFormat),
+            outputFormat,
+            wordBoundaries: words,
+            sentenceBoundaries: sentences,
+            duration: (0, protocol_1.estimateDuration)(audio.length, outputFormat),
+        };
+    }
+    getWordBoundaries() {
+        return this.word_boundaries;
+    }
+    getSentenceBoundaries() {
+        return this.sentence_boundaries;
+    }
+    toSRT() {
+        return (0, subtitles_1.toSRT)(this.sentence_boundaries.length > 0 ? this.sentence_boundaries : this.word_boundaries);
+    }
+    toVTT() {
+        return (0, subtitles_1.toVTT)(this.sentence_boundaries.length > 0 ? this.sentence_boundaries : this.word_boundaries);
+    }
+    async run(text, voice, options, onAudio, onBoundary) {
+        const ssml = this.buildSSML(text, voice, options);
+        const outputFormat = options.outputFormat || protocol_1.DEFAULT_OUTPUT_FORMAT;
+        const attempt = async () => {
+            const requestId = (0, protocol_1.generateUUID)();
+            const url = (0, protocol_1.buildSynthesisUrl)(this.options.wssUrl ?? constants_1.Constants.WSS_URL, constants_1.Constants.TRUSTED_CLIENT_TOKEN, await this.signature(), this.options.secMsGecVersion ?? constants_1.Constants.VERSION_MS_GEC, requestId);
+            await (0, session_1.runSession)(() => this.openSocket(url), {
+                configMessage: (0, protocol_1.buildConfigMessage)(this.timestamp(), outputFormat),
+                ssmlMessage: (0, protocol_1.buildSSMLMessage)(requestId, this.timestamp(), ssml),
+                timeout: options.timeout ?? this.options.timeout ?? DEFAULT_TIMEOUT,
+                signal: options.signal,
+                onAudio,
+                onBoundary,
+                toError: (event, opened) => this.socketError(event, opened),
+            });
+        };
+        try {
+            await attempt();
+        }
+        catch (error) {
+            if (!(error instanceof errors_1.EdgeTTSError && error.code === 'HANDSHAKE'))
+                throw error;
+            if (!(await this.recoverHandshake()))
+                throw error;
+            await attempt();
+        }
+    }
+}
+exports.EdgeTTSCore = EdgeTTSCore;

package/dist/core/clock.d.ts

@@ -0,0 +1,3 @@
+export declare function now(): number;
+export declare function adjustClock(serverTimeMs: number): boolean;
+export declare function resetClock(): void;

package/dist/core/clock.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.now = now;
+exports.adjustClock = adjustClock;
+exports.resetClock = resetClock;
+let skewMs = 0;
+function now() {
+    return Date.now() + skewMs;
+}
+// NOTE: the Date header has one-second resolution, so smaller differences are noise.
+function adjustClock(serverTimeMs) {
+    const delta = serverTimeMs - now();
+    if (!Number.isFinite(delta) || Math.abs(delta) < 2000)
+        return false;
+    skewMs += delta;
+    return true;
+}
+function resetClock() {
+    skewMs = 0;
+}

package/dist/core/crypto.d.ts

@@ -0,0 +1,8 @@
+export interface WebCrypto {
+    getRandomValues<T extends Uint8Array>(array: T): T;
+    subtle: {
+        digest(algorithm: string, data: Uint8Array): Promise<ArrayBuffer>;
+    };
+}
+export declare function setWebCrypto(crypto: WebCrypto): void;
+export declare function webCrypto(): WebCrypto;

package/dist/core/crypto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setWebCrypto = setWebCrypto;
+exports.webCrypto = webCrypto;
+let impl;
+function setWebCrypto(crypto) {
+    impl = crypto;
+}
+function webCrypto() {
+    const crypto = impl ?? globalThis.crypto;
+    if (!crypto)
+        throw new Error('Web Crypto is not available in this environment');
+    return crypto;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,9 @@
+export type EdgeTTSErrorCode = 'NO_AUDIO' | 'TIMEOUT' | 'HANDSHAKE' | 'NETWORK' | 'INVALID_OPTION' | 'VOICES';
+export declare class EdgeTTSError extends Error {
+    readonly code: EdgeTTSErrorCode;
+    readonly status?: number;
+    constructor(message: string, code: EdgeTTSErrorCode, options?: {
+        status?: number;
+        cause?: unknown;
+    });
+}

package/dist/core/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeTTSError = void 0;
+class EdgeTTSError extends Error {
+    code;
+    status;
+    constructor(message, code, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'EdgeTTSError';
+        this.code = code;
+        if (options.status !== undefined)
+            this.status = options.status;
+    }
+}
+exports.EdgeTTSError = EdgeTTSError;

package/dist/core/protocol.d.ts

@@ -0,0 +1,23 @@
+import type { SentenceBoundary, Voice, WordBoundary } from './types';
+export declare const DEFAULT_OUTPUT_FORMAT = "audio-24khz-48kbitrate-mono-mp3";
+export declare function buildSynthesisUrl(base: string, token: string, secMsGec: string, version: string, connectionId: string): string;
+export declare function buildConfigMessage(timestamp: string, outputFormat: string): string;
+export declare function buildSSMLMessage(requestId: string, timestamp: string, ssml: string): string;
+export declare function escapeXML(text: string): string;
+export declare function buildSSML(text: string, voice: string, pitch: string, rate: string, volume: string): string;
+export declare function parseTextFrame(text: string): {
+    path: string;
+    body: string;
+};
+export declare function parseBinaryFrame(data: Uint8Array): {
+    path: string;
+    body: Uint8Array;
+};
+export declare function parseMetadata(body: string): (WordBoundary | SentenceBoundary)[];
+export declare function sentenceTextRestorer(source: string): (text: string) => string;
+export declare function generateSecMsGec(trustedClientToken: string, nowMs: number): Promise<string>;
+export declare function generateUUID(): string;
+export declare function fileExtension(format: string): string;
+export declare function estimateDuration(bytes: number, outputFormat: string): number;
+export declare function concatChunks(chunks: Uint8Array[]): Uint8Array;
+export declare function normalizeVoices(data: any[]): Voice[];

package/dist/core/protocol.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OUTPUT_FORMAT = void 0;
+exports.buildSynthesisUrl = buildSynthesisUrl;
+exports.buildConfigMessage = buildConfigMessage;
+exports.buildSSMLMessage = buildSSMLMessage;
+exports.escapeXML = escapeXML;
+exports.buildSSML = buildSSML;
+exports.parseTextFrame = parseTextFrame;
+exports.parseBinaryFrame = parseBinaryFrame;
+exports.parseMetadata = parseMetadata;
+exports.sentenceTextRestorer = sentenceTextRestorer;
+exports.generateSecMsGec = generateSecMsGec;
+exports.generateUUID = generateUUID;
+exports.fileExtension = fileExtension;
+exports.estimateDuration = estimateDuration;
+exports.concatChunks = concatChunks;
+exports.normalizeVoices = normalizeVoices;
+const crypto_1 = require("./crypto");
+exports.DEFAULT_OUTPUT_FORMAT = 'audio-24khz-48kbitrate-mono-mp3';
+const decoder = new TextDecoder();
+function buildSynthesisUrl(base, token, secMsGec, version, connectionId) {
+    return `${base}?Ocp-Apim-Subscription-Key=${token}&Sec-MS-GEC=${secMsGec}&Sec-MS-GEC-Version=${version}&ConnectionId=${connectionId}`;
+}
+function buildConfigMessage(timestamp, outputFormat) {
+    return `X-Timestamp:${timestamp}\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
+        `{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":true,"wordBoundaryEnabled":true},"outputFormat":"${outputFormat}"}}}}`;
+}
+function buildSSMLMessage(requestId, timestamp, ssml) {
+    return `X-RequestId:${requestId}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${timestamp}\r\nPath:ssml\r\n\r\n${ssml}`;
+}
+function escapeXML(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function buildSSML(text, voice, pitch, rate, volume) {
+    return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="https://www.w3.org/2001/mstts" xml:lang="en-US">
+                    <voice name="${voice}">
+                        <prosody pitch="${pitch}" rate="${rate}" volume="${volume}">
+                            ${escapeXML(text)}
+                        </prosody>
+                    </voice>
+                </speak>`;
+}
+function headerPath(head) {
+    return /Path:([^\r\n]*)/i.exec(head)?.[1]?.trim() ?? '';
+}
+function parseTextFrame(text) {
+    const split = text.indexOf('\r\n\r\n');
+    if (split === -1)
+        return { path: headerPath(text), body: '' };
+    return { path: headerPath(text.slice(0, split)), body: text.slice(split + 4) };
+}
+function parseBinaryFrame(data) {
+    if (data.length < 2)
+        return { path: '', body: new Uint8Array(0) };
+    const headerLength = (data[0] << 8) | data[1];
+    return {
+        path: headerPath(decoder.decode(data.subarray(2, 2 + headerLength))),
+        body: data.slice(2 + headerLength),
+    };
+}
+function parseMetadata(body) {
+    let metadata;
+    try {
+        metadata = JSON.parse(body);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(metadata?.Metadata))
+        return [];
+    const boundaries = [];
+    for (const item of metadata.Metadata) {
+        if (item?.Type !== 'WordBoundary' && item?.Type !== 'SentenceBoundary')
+            continue;
+        boundaries.push({
+            type: item.Type,
+            offset: item.Data.Offset,
+            duration: item.Data.Duration,
+            text: item.Data.text?.Text,
+        });
+    }
+    return boundaries;
+}
+const OPENING_PUNCTUATION = '¿¡«"\'“‘([';
+// NOTE: the service drops opening punctuation such as ¿ and ¡ from sentence text.
+function sentenceTextRestorer(source) {
+    let cursor = 0;
+    return (text) => {
+        const index = text ? source.indexOf(text, cursor) : -1;
+        if (index === -1)
+            return text;
+        let start = index;
+        while (start > cursor && OPENING_PUNCTUATION.includes(source[start - 1]))
+            start--;
+        cursor = index + text.length;
+        return source.slice(start, cursor);
+    };
+}
+async function generateSecMsGec(trustedClientToken, nowMs) {
+    const ticks = Math.floor(nowMs / 1000) + 11644473600;
+    const rounded = ticks - (ticks % 300);
+    const windowsTicks = rounded * 10_000_000;
+    const data = new TextEncoder().encode(`${windowsTicks}${trustedClientToken}`);
+    const hashBuffer = await (0, crypto_1.webCrypto)().subtle.digest('SHA-256', data);
+    return Array.from(new Uint8Array(hashBuffer))
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('')
+        .toUpperCase();
+}
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+function fileExtension(format) {
+    if (format.includes('mp3'))
+        return 'mp3';
+    if (format.includes('opus') && format.includes('webm'))
+        return 'webm';
+    if (format.includes('opus') && format.includes('ogg'))
+        return 'ogg';
+    if (format.includes('wav') || format.includes('riff'))
+        return 'wav';
+    if (format.includes('pcm') && format.includes('raw'))
+        return 'pcm';
+    if (format.includes('alaw'))
+        return 'alaw';
+    if (format.includes('mulaw'))
+        return 'mulaw';
+    if (format.includes('truesilk'))
+        return 'silk';
+    if (format.includes('g722'))
+        return 'g722';
+    if (format.includes('amr'))
+        return 'amr';
+    return 'audio';
+}
+// NOTE: MP3 is CBR; formats without a bitrate (opus) assume 48 kbit/s.
+function estimateDuration(bytes, outputFormat) {
+    const kbps = Number(/(\d+)kbitrate/.exec(outputFormat)?.[1] ?? 48);
+    return (bytes * 8) / (kbps * 1000);
+}
+function concatChunks(chunks) {
+    const result = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+function normalizeVoices(data) {
+    const out = [];
+    for (const v of data || []) {
+        const short = v?.ShortName || "";
+        const locale = v?.Locale || "";
+        // base: remove locale prefix and Neural/NeuralHD suffix
+        let base = short.replace(/^[a-z]{2}-[A-Z]{2}-/, "");
+        base = base.replace(/NeuralHD$/, "").replace(/Neural$/, "").trim();
+        // VoiceType: if NeuralHD/Neural in Name or ShortName
+        const mix = `${v?.Name || ""} ${short}`;
+        const voiceType = v?.VoiceType || (/NeuralHD/i.test(mix) ? "NeuralHD" : "Neural");
+        // LocaleName: prefer LocaleName -> LanguageName -> locale
+        const localeName = v?.LocaleName || (locale || null);
+        // DisplayName: prefer DisplayName -> FriendlyName -> base -> short
+        let display = v?.DisplayName || v?.FriendlyName || base || short;
+        display = display.replace(/^Microsoft\s+/i, "");
+        display = display.split(" - ")[0].trim();
+        display = display.replace(/\s*Online\s*\(Natural\)\s*/i, " ");
+        display = display.replace(/\s*Online\s*/i, " ");
+        display = display.replace(/\s+/g, " ").trim();
+        // VoiceTag parsing
+        const tag = (v?.VoiceTag && typeof v.VoiceTag === "object") ? v.VoiceTag : {};
+        const tailored = Array.isArray(tag.TailoredScenarios)
+            ? tag.TailoredScenarios
+            : (Array.isArray(tag.ContentCategories) ? tag.ContentCategories : []);
+        const personalities = Array.isArray(tag.VoicePersonalities)
+            ? tag.VoicePersonalities
+            : [];
+        out.push({
+            Name: short || (v?.Name || ""),
+            DisplayName: display,
+            LocalName: display,
+            ShortName: short || (v?.Name || ""),
+            Gender: v?.Gender ?? null,
+            Locale: locale || null,
+            LocaleName: localeName,
+            SecondaryLocaleList: Array.isArray(v?.SecondaryLocaleList) ? v.SecondaryLocaleList : [],
+            VoiceType: voiceType,
+            VoiceTag: {
+                TailoredScenarios: tailored,
+                VoicePersonalities: personalities,
+            },
+            FriendlyName: `${display} (${voiceType}) - ${localeName}`,
+        });
+    }
+    return out;
+}

package/dist/core/session.d.ts

@@ -0,0 +1,24 @@
+import type { SentenceBoundary, WordBoundary } from './types';
+export interface SocketLike {
+    binaryType: string;
+    readonly readyState: number;
+    onopen: ((event: any) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onerror: ((event: any) => void) | null;
+    onclose: ((event: any) => void) | null;
+    send(data: string): void;
+    close(): void;
+}
+export interface SessionOptions {
+    configMessage: string;
+    ssmlMessage: string;
+    timeout: number;
+    signal?: AbortSignal;
+    onAudio(chunk: Uint8Array): void;
+    onBoundary(boundary: WordBoundary | SentenceBoundary): void;
+    toError(event: unknown, opened: boolean): Error;
+}
+export declare function abortReason(signal: AbortSignal): unknown;
+export declare function runSession(open: () => SocketLike, options: SessionOptions): Promise<void>;