@pixelzx/genesis 2026.6.28 → 2026.7.8

package/dist/speech-provider-CcbYv8ap.js

@@ -0,0 +1,216 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { n as resolvePreferredGenesisTmpDir } from "./tmp-genesis-dir-h5HSqKoN.js";
+import { l as normalizeResolvedSecretInputString } from "./types.secrets-BbgGt42I.js";
+import { t as asFiniteNumber } from "./number-coercion-DHdCxKPW.js";
+import { u as runFfmpeg } from "./runner.entries-DZUGr24v.js";
+import { n as asObject } from "./provider-http-errors-BjlTaQX1.js";
+import "./secret-input-X94ng2dE.js";
+import "./media-runtime-BetXjDy_.js";
+import "./speech-core-DBt6KWUE.js";
+import { a as normalizeMinimaxTtsBaseUrl, i as minimaxTTS, n as MINIMAX_TTS_MODELS, r as MINIMAX_TTS_VOICES } from "./tts-BytN2Ql4.js";
+import path from "node:path";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+//#region extensions/minimax/speech-provider.ts
+function normalizeMinimaxProviderConfig(rawConfig) {
+	const raw = asObject(asObject(rawConfig.providers)?.minimax) ?? asObject(rawConfig.minimax);
+	return {
+		apiKey: normalizeResolvedSecretInputString({
+			value: raw?.apiKey,
+			path: "messages.tts.providers.minimax.apiKey"
+		}),
+		baseUrl: normalizeMinimaxTtsBaseUrl(normalizeOptionalString(raw?.baseUrl) ?? normalizeOptionalString(process.env.MINIMAX_API_HOST) ?? "https://api.minimax.io"),
+		model: normalizeOptionalString(raw?.model) ?? normalizeOptionalString(process.env.MINIMAX_TTS_MODEL) ?? "speech-2.8-hd",
+		voiceId: normalizeOptionalString(raw?.voiceId) ?? normalizeOptionalString(process.env.MINIMAX_TTS_VOICE_ID) ?? "English_expressive_narrator",
+		speed: asFiniteNumber(raw?.speed),
+		vol: asFiniteNumber(raw?.vol),
+		pitch: asFiniteNumber(raw?.pitch)
+	};
+}
+function readMinimaxProviderConfig(config) {
+	const normalized = normalizeMinimaxProviderConfig({});
+	return {
+		apiKey: normalizeOptionalString(config.apiKey) ?? normalized.apiKey,
+		baseUrl: normalizeOptionalString(config.baseUrl) ?? normalized.baseUrl,
+		model: normalizeOptionalString(config.model) ?? normalized.model,
+		voiceId: normalizeOptionalString(config.voiceId) ?? normalized.voiceId,
+		speed: asFiniteNumber(config.speed) ?? normalized.speed,
+		vol: asFiniteNumber(config.vol) ?? normalized.vol,
+		pitch: asFiniteNumber(config.pitch) ?? normalized.pitch
+	};
+}
+function readMinimaxOverrides(overrides) {
+	if (!overrides) return {};
+	return {
+		model: normalizeOptionalString(overrides.model),
+		voiceId: normalizeOptionalString(overrides.voiceId),
+		speed: asFiniteNumber(overrides.speed),
+		vol: asFiniteNumber(overrides.vol),
+		pitch: asFiniteNumber(overrides.pitch)
+	};
+}
+function parseDirectiveToken(ctx) {
+	switch (ctx.key) {
+		case "voice":
+		case "voiceid":
+		case "voice_id":
+		case "minimax_voice":
+		case "minimaxvoice":
+			if (!ctx.policy.allowVoice) return { handled: true };
+			return {
+				handled: true,
+				overrides: { voiceId: ctx.value }
+			};
+		case "model":
+		case "minimax_model":
+		case "minimaxmodel":
+			if (!ctx.policy.allowModelId) return { handled: true };
+			return {
+				handled: true,
+				overrides: { model: ctx.value }
+			};
+		case "speed": {
+			if (!ctx.policy.allowVoiceSettings) return { handled: true };
+			const speed = Number(ctx.value);
+			if (!Number.isFinite(speed) || speed < .5 || speed > 2) return {
+				handled: true,
+				warnings: [`invalid MiniMax speed "${ctx.value}" (0.5-2.0)`]
+			};
+			return {
+				handled: true,
+				overrides: { speed }
+			};
+		}
+		case "vol":
+		case "volume": {
+			if (!ctx.policy.allowVoiceSettings) return { handled: true };
+			const vol = Number(ctx.value);
+			if (!Number.isFinite(vol) || vol <= 0 || vol > 10) return {
+				handled: true,
+				warnings: [`invalid MiniMax volume "${ctx.value}" (0-10, exclusive)`]
+			};
+			return {
+				handled: true,
+				overrides: { vol }
+			};
+		}
+		case "pitch": {
+			if (!ctx.policy.allowVoiceSettings) return { handled: true };
+			const pitch = Number(ctx.value);
+			if (!Number.isFinite(pitch) || pitch < -12 || pitch > 12) return {
+				handled: true,
+				warnings: [`invalid MiniMax pitch "${ctx.value}" (-12 to 12)`]
+			};
+			return {
+				handled: true,
+				overrides: { pitch }
+			};
+		}
+		default: return { handled: false };
+	}
+}
+async function transcodeMp3ToOpus(audioBuffer, timeoutMs) {
+	const tempRoot = resolvePreferredGenesisTmpDir();
+	await mkdir(tempRoot, {
+		recursive: true,
+		mode: 448
+	});
+	const tempDir = await mkdtemp(path.join(tempRoot, "tts-minimax-"));
+	try {
+		const inputPath = path.join(tempDir, "input.mp3");
+		const outputPath = path.join(tempDir, "voice.opus");
+		await writeFile(inputPath, audioBuffer, { mode: 384 });
+		await runFfmpeg([
+			"-hide_banner",
+			"-loglevel",
+			"error",
+			"-y",
+			"-i",
+			inputPath,
+			"-vn",
+			"-c:a",
+			"libopus",
+			"-b:a",
+			"64k",
+			"-ar",
+			"48000",
+			"-ac",
+			"1",
+			outputPath
+		], { timeoutMs });
+		return await readFile(outputPath);
+	} finally {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function buildMinimaxSpeechProvider() {
+	return {
+		id: "minimax",
+		label: "MiniMax",
+		autoSelectOrder: 40,
+		models: MINIMAX_TTS_MODELS,
+		voices: MINIMAX_TTS_VOICES,
+		resolveConfig: ({ rawConfig }) => normalizeMinimaxProviderConfig(rawConfig),
+		parseDirectiveToken,
+		resolveTalkConfig: ({ baseTtsConfig, talkProviderConfig }) => {
+			return {
+				...normalizeMinimaxProviderConfig(baseTtsConfig),
+				...talkProviderConfig.apiKey === void 0 ? {} : { apiKey: normalizeResolvedSecretInputString({
+					value: talkProviderConfig.apiKey,
+					path: "talk.providers.minimax.apiKey"
+				}) },
+				...normalizeOptionalString(talkProviderConfig.baseUrl) == null ? {} : { baseUrl: normalizeMinimaxTtsBaseUrl(normalizeOptionalString(talkProviderConfig.baseUrl)) },
+				...normalizeOptionalString(talkProviderConfig.modelId) == null ? {} : { model: normalizeOptionalString(talkProviderConfig.modelId) },
+				...normalizeOptionalString(talkProviderConfig.voiceId) == null ? {} : { voiceId: normalizeOptionalString(talkProviderConfig.voiceId) },
+				...asFiniteNumber(talkProviderConfig.speed) == null ? {} : { speed: asFiniteNumber(talkProviderConfig.speed) },
+				...asFiniteNumber(talkProviderConfig.vol) == null ? {} : { vol: asFiniteNumber(talkProviderConfig.vol) },
+				...asFiniteNumber(talkProviderConfig.pitch) == null ? {} : { pitch: asFiniteNumber(talkProviderConfig.pitch) }
+			};
+		},
+		resolveTalkOverrides: ({ params }) => ({
+			...normalizeOptionalString(params.voiceId) == null ? {} : { voiceId: normalizeOptionalString(params.voiceId) },
+			...normalizeOptionalString(params.modelId) == null ? {} : { model: normalizeOptionalString(params.modelId) },
+			...asFiniteNumber(params.speed) == null ? {} : { speed: asFiniteNumber(params.speed) },
+			...asFiniteNumber(params.vol) == null ? {} : { vol: asFiniteNumber(params.vol) },
+			...asFiniteNumber(params.pitch) == null ? {} : { pitch: asFiniteNumber(params.pitch) }
+		}),
+		listVoices: async () => MINIMAX_TTS_VOICES.map((voice) => ({
+			id: voice,
+			name: voice
+		})),
+		isConfigured: ({ providerConfig }) => Boolean(readMinimaxProviderConfig(providerConfig).apiKey || process.env.MINIMAX_API_KEY),
+		synthesize: async (req) => {
+			const config = readMinimaxProviderConfig(req.providerConfig);
+			const overrides = readMinimaxOverrides(req.providerOverrides);
+			const apiKey = config.apiKey || process.env.MINIMAX_API_KEY;
+			if (!apiKey) throw new Error("MiniMax API key missing");
+			const audioBuffer = await minimaxTTS({
+				text: req.text,
+				apiKey,
+				baseUrl: config.baseUrl,
+				model: overrides.model ?? config.model,
+				voiceId: overrides.voiceId ?? config.voiceId,
+				speed: overrides.speed ?? config.speed,
+				vol: overrides.vol ?? config.vol,
+				pitch: overrides.pitch ?? config.pitch,
+				timeoutMs: req.timeoutMs
+			});
+			if (req.target === "voice-note") return {
+				audioBuffer: await transcodeMp3ToOpus(audioBuffer, req.timeoutMs),
+				outputFormat: "opus",
+				fileExtension: ".opus",
+				voiceCompatible: true
+			};
+			return {
+				audioBuffer,
+				outputFormat: "mp3",
+				fileExtension: ".mp3",
+				voiceCompatible: false
+			};
+		}
+	};
+}
+//#endregion
+export { buildMinimaxSpeechProvider as t };

package/dist/speech-provider-Cr1h-_-X.js

@@ -0,0 +1,170 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { l as normalizeResolvedSecretInputString } from "./types.secrets-BbgGt42I.js";
+import { t as asFiniteNumber } from "./number-coercion-DHdCxKPW.js";
+import "./text-runtime-DVUvIDNC.js";
+import "./secret-input-X94ng2dE.js";
+import "./speech-mBRh7fGL.js";
+import "./model-definitions-C_zUrDs9.js";
+import { a as xaiTTS, i as normalizeXaiTtsBaseUrl, n as isValidXaiTtsVoice, r as normalizeXaiLanguageCode, t as XAI_TTS_VOICES } from "./tts-BG_1G2S6.js";
+//#region extensions/xai/speech-provider.ts
+const XAI_SPEECH_RESPONSE_FORMATS = [
+	"mp3",
+	"wav",
+	"pcm",
+	"mulaw",
+	"alaw"
+];
+function normalizeXaiSpeechResponseFormat(value) {
+	const next = normalizeLowercaseStringOrEmpty(value);
+	if (!next) return;
+	if (XAI_SPEECH_RESPONSE_FORMATS.some((format) => format === next)) return next;
+	throw new Error(`Invalid xAI speech responseFormat: ${next}`);
+}
+function resolveSpeechResponseFormat(target, configuredFormat) {
+	if (configuredFormat) return configuredFormat;
+	return "mp3";
+}
+function responseFormatToFileExtension(format) {
+	switch (format) {
+		case "wav": return ".wav";
+		case "pcm": return ".pcm";
+		case "mulaw": return ".mulaw";
+		case "alaw": return ".alaw";
+		default: return ".mp3";
+	}
+}
+function normalizeXaiProviderConfig(rawConfig) {
+	const xai = (rawConfig?.providers)?.xai ?? rawConfig?.xai ?? rawConfig;
+	return {
+		apiKey: normalizeResolvedSecretInputString({
+			value: xai?.apiKey,
+			path: "messages.tts.providers.xai.apiKey"
+		}),
+		baseUrl: normalizeXaiTtsBaseUrl(normalizeOptionalString(xai?.baseUrl) ?? normalizeOptionalString(process.env.XAI_BASE_URL) ?? "https://api.x.ai/v1"),
+		voiceId: normalizeOptionalString(xai?.voiceId ?? xai?.voice) ?? "eve",
+		language: normalizeXaiLanguageCode(normalizeOptionalString(xai?.language ?? xai?.languageCode)),
+		speed: asFiniteNumber(xai?.speed),
+		responseFormat: normalizeXaiSpeechResponseFormat(xai?.responseFormat)
+	};
+}
+function readXaiProviderConfig(config) {
+	const normalized = normalizeXaiProviderConfig({});
+	return {
+		apiKey: normalizeOptionalString(config.apiKey) ?? normalized.apiKey,
+		baseUrl: normalizeOptionalString(config.baseUrl) ?? normalized.baseUrl,
+		voiceId: normalizeOptionalString(config.voiceId ?? config.voice) ?? normalized.voiceId,
+		language: normalizeXaiLanguageCode(normalizeOptionalString(config.language ?? config.languageCode)) ?? normalized.language,
+		speed: asFiniteNumber(config.speed) ?? normalized.speed,
+		responseFormat: normalizeXaiSpeechResponseFormat(config.responseFormat) ?? normalized.responseFormat
+	};
+}
+function readXaiOverrides(overrides) {
+	if (!overrides) return {};
+	return {
+		voiceId: normalizeOptionalString(overrides.voiceId ?? overrides.voice),
+		language: normalizeXaiLanguageCode(normalizeOptionalString(overrides.language)),
+		speed: asFiniteNumber(overrides.speed)
+	};
+}
+function parseDirectiveToken(ctx) {
+	const providerConfig = ctx.providerConfig;
+	const baseUrl = normalizeOptionalString(providerConfig?.baseUrl);
+	switch (ctx.key) {
+		case "voice":
+		case "voice_id":
+		case "voiceid":
+		case "xai_voice":
+		case "xaivoice":
+			if (!ctx.policy.allowVoice) return { handled: true };
+			if (!isValidXaiTtsVoice(ctx.value, baseUrl)) return {
+				handled: true,
+				warnings: [`invalid xAI voice "${ctx.value}"`]
+			};
+			return {
+				handled: true,
+				overrides: { voiceId: ctx.value }
+			};
+		default: return { handled: false };
+	}
+}
+function buildXaiSpeechProvider() {
+	return {
+		id: "xai",
+		label: "xAI",
+		autoSelectOrder: 25,
+		models: [],
+		voices: XAI_TTS_VOICES,
+		resolveConfig: ({ rawConfig }) => normalizeXaiProviderConfig(rawConfig),
+		parseDirectiveToken,
+		resolveTalkConfig: ({ baseTtsConfig, talkProviderConfig }) => {
+			const base = normalizeXaiProviderConfig(baseTtsConfig);
+			const responseFormat = normalizeXaiSpeechResponseFormat(talkProviderConfig.responseFormat);
+			return {
+				...base,
+				...talkProviderConfig.apiKey === void 0 ? {} : { apiKey: normalizeResolvedSecretInputString({
+					value: talkProviderConfig.apiKey,
+					path: "talk.providers.xai.apiKey"
+				}) },
+				...normalizeOptionalString(talkProviderConfig.baseUrl) == null ? {} : { baseUrl: normalizeXaiTtsBaseUrl(normalizeOptionalString(talkProviderConfig.baseUrl)) },
+				...normalizeOptionalString(talkProviderConfig.voiceId) == null ? {} : { voiceId: normalizeOptionalString(talkProviderConfig.voiceId) },
+				...normalizeXaiLanguageCode(normalizeOptionalString(talkProviderConfig.language ?? talkProviderConfig.languageCode)) == null ? {} : { language: normalizeXaiLanguageCode(normalizeOptionalString(talkProviderConfig.language ?? talkProviderConfig.languageCode)) },
+				...asFiniteNumber(talkProviderConfig.speed) == null ? {} : { speed: asFiniteNumber(talkProviderConfig.speed) },
+				...responseFormat == null ? {} : { responseFormat }
+			};
+		},
+		resolveTalkOverrides: ({ params }) => ({
+			...normalizeOptionalString(params.voiceId ?? params.voice) == null ? {} : { voiceId: normalizeOptionalString(params.voiceId ?? params.voice) },
+			...normalizeXaiLanguageCode(normalizeOptionalString(params.language ?? params.languageCode)) == null ? {} : { language: normalizeXaiLanguageCode(normalizeOptionalString(params.language ?? params.languageCode)) },
+			...asFiniteNumber(params.speed) == null ? {} : { speed: asFiniteNumber(params.speed) }
+		}),
+		listVoices: async () => XAI_TTS_VOICES.map((voice) => ({
+			id: voice,
+			name: voice
+		})),
+		isConfigured: ({ providerConfig }) => Boolean(readXaiProviderConfig(providerConfig).apiKey || process.env.XAI_API_KEY),
+		synthesize: async (req) => {
+			const config = readXaiProviderConfig(req.providerConfig);
+			const overrides = readXaiOverrides(req.providerOverrides);
+			const apiKey = config.apiKey || process.env.XAI_API_KEY;
+			if (!apiKey) throw new Error("xAI API key missing");
+			const responseFormat = resolveSpeechResponseFormat(req.target, config.responseFormat);
+			return {
+				audioBuffer: await xaiTTS({
+					text: req.text,
+					apiKey,
+					baseUrl: config.baseUrl,
+					voiceId: overrides.voiceId ?? config.voiceId,
+					language: overrides.language ?? config.language,
+					speed: overrides.speed ?? config.speed,
+					responseFormat,
+					timeoutMs: req.timeoutMs
+				}),
+				outputFormat: responseFormat,
+				fileExtension: responseFormatToFileExtension(responseFormat),
+				voiceCompatible: false
+			};
+		},
+		synthesizeTelephony: async (req) => {
+			const config = readXaiProviderConfig(req.providerConfig);
+			const apiKey = config.apiKey || process.env.XAI_API_KEY;
+			if (!apiKey) throw new Error("xAI API key missing");
+			const outputFormat = "pcm";
+			return {
+				audioBuffer: await xaiTTS({
+					text: req.text,
+					apiKey,
+					baseUrl: config.baseUrl,
+					voiceId: config.voiceId,
+					language: config.language,
+					speed: config.speed,
+					responseFormat: outputFormat,
+					timeoutMs: req.timeoutMs
+				}),
+				outputFormat,
+				sampleRate: 24e3
+			};
+		}
+	};
+}
+//#endregion
+export { buildXaiSpeechProvider as t };

package/dist/speech-provider-Gif_hcpc.js

@@ -0,0 +1,209 @@
+import { c as normalizeOptionalString } from "./string-coerce-DPP_aYVc.js";
+import { n as resolvePreferredGenesisTmpDir } from "./tmp-genesis-dir-h5HSqKoN.js";
+import { t as asFiniteNumber } from "./number-coercion-DHdCxKPW.js";
+import { a as isDebugProxyGlobalFetchPatchInstalled, t as captureHttpExchange } from "./runtime-B3WJIlyv.js";
+import { v as ssrfPolicyFromHttpBaseUrlAllowedHostname } from "./ssrf-BR9EvI4i.js";
+import { n as fetchWithSsrFGuard } from "./fetch-guard-CsgToyd0.js";
+import { i as assertOkOrThrowProviderError, n as asObject, t as asBoolean } from "./provider-http-errors-BjlTaQX1.js";
+import { r as isVoiceCompatibleAudio } from "./audio-BHTUgu36.js";
+import "./proxy-capture-BrRWZdtQ.js";
+import "./ssrf-runtime-DXdCQqiX.js";
+import "./media-runtime-BetXjDy_.js";
+import "./provider-http-BpPt7Muz.js";
+import "./speech-mBRh7fGL.js";
+import { n as inferEdgeExtension, r as require_drm, t as edgeTTS } from "./tts-CG4pj-nW.js";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+//#region extensions/microsoft/speech-provider.ts
+var import_drm = require_drm();
+const DEFAULT_EDGE_VOICE = "en-US-MichelleNeural";
+const DEFAULT_EDGE_LANG = "en-US";
+const DEFAULT_EDGE_OUTPUT_FORMAT = "audio-24khz-48kbitrate-mono-mp3";
+function normalizeMicrosoftProviderConfig(rawConfig) {
+	const providers = asObject(rawConfig.providers);
+	const rawEdge = asObject(rawConfig.edge);
+	const rawMicrosoft = asObject(rawConfig.microsoft);
+	const rawProviderMicrosoft = asObject(providers?.microsoft);
+	const raw = {
+		...rawEdge,
+		...rawMicrosoft,
+		...rawProviderMicrosoft
+	};
+	const outputFormat = normalizeOptionalString(raw.outputFormat);
+	return {
+		enabled: asBoolean(raw.enabled) ?? true,
+		voice: normalizeOptionalString(raw.voice) ?? DEFAULT_EDGE_VOICE,
+		lang: normalizeOptionalString(raw.lang) ?? DEFAULT_EDGE_LANG,
+		outputFormat: outputFormat ?? DEFAULT_EDGE_OUTPUT_FORMAT,
+		outputFormatConfigured: Boolean(outputFormat),
+		pitch: normalizeOptionalString(raw.pitch),
+		rate: normalizeOptionalString(raw.rate),
+		volume: normalizeOptionalString(raw.volume),
+		saveSubtitles: asBoolean(raw.saveSubtitles) ?? false,
+		proxy: normalizeOptionalString(raw.proxy),
+		timeoutMs: asFiniteNumber(raw.timeoutMs)
+	};
+}
+function readMicrosoftProviderConfig(config) {
+	const defaults = normalizeMicrosoftProviderConfig({});
+	return {
+		enabled: asBoolean(config.enabled) ?? defaults.enabled,
+		voice: normalizeOptionalString(config.voice) ?? defaults.voice,
+		lang: normalizeOptionalString(config.lang) ?? defaults.lang,
+		outputFormat: normalizeOptionalString(config.outputFormat) ?? defaults.outputFormat,
+		outputFormatConfigured: asBoolean(config.outputFormatConfigured) ?? defaults.outputFormatConfigured,
+		pitch: normalizeOptionalString(config.pitch) ?? defaults.pitch,
+		rate: normalizeOptionalString(config.rate) ?? defaults.rate,
+		volume: normalizeOptionalString(config.volume) ?? defaults.volume,
+		saveSubtitles: asBoolean(config.saveSubtitles) ?? defaults.saveSubtitles,
+		proxy: normalizeOptionalString(config.proxy) ?? defaults.proxy,
+		timeoutMs: asFiniteNumber(config.timeoutMs) ?? defaults.timeoutMs
+	};
+}
+function buildMicrosoftVoiceHeaders() {
+	const major = import_drm.CHROMIUM_FULL_VERSION.split(".")[0] || "0";
+	return {
+		Authority: "speech.platform.bing.com",
+		Origin: "chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold",
+		Accept: "*/*",
+		"User-Agent": `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36 Edg/${major}.0.0.0`,
+		"Sec-MS-GEC": (0, import_drm.generateSecMsGecToken)(),
+		"Sec-MS-GEC-Version": `1-${import_drm.CHROMIUM_FULL_VERSION}`
+	};
+}
+function formatMicrosoftVoiceDescription(entry) {
+	const personalities = entry.VoiceTag?.VoicePersonalities?.filter(Boolean) ?? [];
+	return personalities.length > 0 ? personalities.join(", ") : void 0;
+}
+function isCjkDominant(text) {
+	const stripped = text.replace(/\s+/g, "");
+	if (stripped.length === 0) return false;
+	let cjkCount = 0;
+	for (const ch of stripped) {
+		const code = ch.codePointAt(0) ?? 0;
+		if (code >= 19968 && code <= 40959 || code >= 13312 && code <= 19903 || code >= 12288 && code <= 12351 || code >= 65280 && code <= 65519) cjkCount += 1;
+	}
+	return cjkCount / stripped.length > .3;
+}
+const DEFAULT_CHINESE_EDGE_VOICE = "zh-CN-XiaoxiaoNeural";
+const DEFAULT_CHINESE_EDGE_LANG = "zh-CN";
+async function listMicrosoftVoices() {
+	const url = `https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list?trustedclienttoken=${import_drm.TRUSTED_CLIENT_TOKEN}`;
+	const headers = buildMicrosoftVoiceHeaders();
+	const { response, release } = await fetchWithSsrFGuard({
+		url,
+		init: { headers },
+		policy: ssrfPolicyFromHttpBaseUrlAllowedHostname("https://speech.platform.bing.com"),
+		auditContext: "microsoft.speech.voices"
+	});
+	try {
+		if (!isDebugProxyGlobalFetchPatchInstalled()) captureHttpExchange({
+			url,
+			method: "GET",
+			requestHeaders: headers,
+			response,
+			transport: "http",
+			meta: {
+				provider: "microsoft",
+				capability: "speech-voices"
+			}
+		});
+		await assertOkOrThrowProviderError(response, "Microsoft voices API error");
+		const voices = await response.json();
+		return Array.isArray(voices) ? voices.map((voice) => ({
+			id: voice.ShortName?.trim() ?? "",
+			name: normalizeOptionalString(voice.FriendlyName) ?? normalizeOptionalString(voice.ShortName),
+			category: voice.VoiceTag?.ContentCategories?.find((value) => value.trim().length > 0),
+			description: formatMicrosoftVoiceDescription(voice),
+			locale: normalizeOptionalString(voice.Locale),
+			gender: normalizeOptionalString(voice.Gender),
+			personalities: voice.VoiceTag?.VoicePersonalities?.filter((value) => value.trim().length > 0)
+		})).filter((voice) => voice.id.length > 0) : [];
+	} finally {
+		await release();
+	}
+}
+function buildMicrosoftSpeechProvider() {
+	return {
+		id: "microsoft",
+		label: "Microsoft",
+		aliases: ["edge"],
+		autoSelectOrder: 30,
+		resolveConfig: ({ rawConfig }) => normalizeMicrosoftProviderConfig(rawConfig),
+		resolveTalkConfig: ({ baseTtsConfig, talkProviderConfig }) => {
+			return {
+				...normalizeMicrosoftProviderConfig(baseTtsConfig),
+				enabled: true,
+				...normalizeOptionalString(talkProviderConfig.voiceId) == null ? {} : { voice: normalizeOptionalString(talkProviderConfig.voiceId) },
+				...normalizeOptionalString(talkProviderConfig.languageCode) == null ? {} : { lang: normalizeOptionalString(talkProviderConfig.languageCode) },
+				...normalizeOptionalString(talkProviderConfig.outputFormat) == null ? {} : { outputFormat: normalizeOptionalString(talkProviderConfig.outputFormat) },
+				...normalizeOptionalString(talkProviderConfig.pitch) == null ? {} : { pitch: normalizeOptionalString(talkProviderConfig.pitch) },
+				...normalizeOptionalString(talkProviderConfig.rate) == null ? {} : { rate: normalizeOptionalString(talkProviderConfig.rate) },
+				...normalizeOptionalString(talkProviderConfig.volume) == null ? {} : { volume: normalizeOptionalString(talkProviderConfig.volume) },
+				...normalizeOptionalString(talkProviderConfig.proxy) == null ? {} : { proxy: normalizeOptionalString(talkProviderConfig.proxy) },
+				...asFiniteNumber(talkProviderConfig.timeoutMs) == null ? {} : { timeoutMs: asFiniteNumber(talkProviderConfig.timeoutMs) }
+			};
+		},
+		resolveTalkOverrides: ({ params }) => ({
+			...normalizeOptionalString(params.voiceId) == null ? {} : { voice: normalizeOptionalString(params.voiceId) },
+			...normalizeOptionalString(params.outputFormat) == null ? {} : { outputFormat: normalizeOptionalString(params.outputFormat) }
+		}),
+		listVoices: async () => await listMicrosoftVoices(),
+		isConfigured: ({ providerConfig }) => readMicrosoftProviderConfig(providerConfig).enabled,
+		synthesize: async (req) => {
+			const config = readMicrosoftProviderConfig(req.providerConfig);
+			const tempRoot = resolvePreferredGenesisTmpDir();
+			mkdirSync(tempRoot, {
+				recursive: true,
+				mode: 448
+			});
+			const tempDir = mkdtempSync(path.join(tempRoot, "tts-microsoft-"));
+			const overrideVoice = normalizeOptionalString(req.providerOverrides?.voice);
+			let voice = overrideVoice ?? config.voice;
+			let lang = config.lang;
+			let outputFormat = normalizeOptionalString(req.providerOverrides?.outputFormat) ?? config.outputFormat;
+			const fallbackOutputFormat = outputFormat !== DEFAULT_EDGE_OUTPUT_FORMAT ? DEFAULT_EDGE_OUTPUT_FORMAT : void 0;
+			if (!overrideVoice && voice === DEFAULT_EDGE_VOICE && isCjkDominant(req.text)) {
+				voice = DEFAULT_CHINESE_EDGE_VOICE;
+				lang = DEFAULT_CHINESE_EDGE_LANG;
+			}
+			try {
+				const runEdge = async (format) => {
+					const fileExtension = inferEdgeExtension(format);
+					const outputPath = path.join(tempDir, `speech${fileExtension}`);
+					await edgeTTS({
+						text: req.text,
+						outputPath,
+						config: {
+							...config,
+							voice,
+							lang,
+							outputFormat: format
+						},
+						timeoutMs: req.timeoutMs
+					});
+					return {
+						audioBuffer: readFileSync(outputPath),
+						outputFormat: format,
+						fileExtension,
+						voiceCompatible: isVoiceCompatibleAudio({ fileName: outputPath })
+					};
+				};
+				try {
+					return await runEdge(outputFormat);
+				} catch (error) {
+					if (!fallbackOutputFormat || fallbackOutputFormat === outputFormat) throw error;
+					outputFormat = fallbackOutputFormat;
+					return await runEdge(outputFormat);
+				}
+			} finally {
+				rmSync(tempDir, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	};
+}
+//#endregion
+export { isCjkDominant as n, listMicrosoftVoices as r, buildMicrosoftSpeechProvider as t };