@markusylisiurunen/tau 0.3.55 → 0.3.57

package/dist/core/utils/gemini_speech.js

@@ -5,15 +5,15 @@ const DEFAULT_GEMINI_SPEECH_REWRITE_MODEL = "gemini-3.7-flash";
 const DEFAULT_GEMINI_SPEECH_REWRITE_THINKING_LEVEL = "low";
 const DEFAULT_GEMINI_SPEECH_TTS_MODEL = "gemini-3.1-flash-tts-preview";
 const DEFAULT_GEMINI_TTS_VOICE_NAME = "Despina";
-const DEFAULT_TTS_SAMPLE_RATE_HZ = 24000;
-const DEFAULT_TTS_CHANNEL_COUNT = 1;
-const DEFAULT_TTS_BITS_PER_SAMPLE = 16;
+export const GEMINI_SPEECH_SAMPLE_RATE_HZ = 24000;
+export const GEMINI_SPEECH_CHANNEL_COUNT = 1;
+export const GEMINI_SPEECH_BITS_PER_SAMPLE = 16;
 const DEFAULT_TTS_MAX_ATTEMPTS = 3;
 const SPEECH_REWRITE_TIMEOUT_MS = 60_000;
-const PROGRESSIVE_TTS_CONCURRENCY = 6;
 const COMPLETE_TTS_CONCURRENCY = 3;
-const PROGRESSIVE_SPEECH_CHUNK_CHARACTERS = 500;
-const COMPLETE_SPEECH_CHUNK_CHARACTERS = 1000;
+const MAX_SPEECH_SEGMENT_SECONDS = 120;
+const ESTIMATED_SPEECH_CHARACTERS_PER_SECOND = 17;
+const MAX_SPEECH_SEGMENT_WEIGHT = MAX_SPEECH_SEGMENT_SECONDS * ESTIMATED_SPEECH_CHARACTERS_PER_SECOND;
 const MAX_SPEECH_SOURCE_CHARACTERS = 10_000;
 const MAX_SPOKEN_TEXT_CHARACTERS = 10_000;
 const MAX_SPEECH_PCM_BYTES = 32 * 1024 * 1024;
@@ -48,77 +48,26 @@ class GeminiTtsOutputLimitError extends Error {
         this.name = "GeminiTtsOutputLimitError";
     }
 }
-export async function* streamGeminiSpeechAudio(options) {
-    const sourceText = options.sourceText.trim();
-    if (!sourceText) {
-        throw new Error("speech source text was empty");
-    }
-    if (exceedsUnicodeCharacterLimit(sourceText, MAX_SPEECH_SOURCE_CHARACTERS)) {
-        throw new Error("speech source text exceeds 10,000 characters");
-    }
-    const apiKey = options.apiKey.trim();
-    if (!apiKey) {
-        throw new Error("missing Gemini API key");
-    }
-    const fetchImpl = options.fetchImpl ?? fetch;
-    const rewriteModel = options.rewriteModel ?? DEFAULT_GEMINI_SPEECH_REWRITE_MODEL;
-    const ttsModel = options.ttsModel ?? DEFAULT_GEMINI_SPEECH_TTS_MODEL;
-    const voiceName = options.voiceName ?? DEFAULT_GEMINI_TTS_VOICE_NAME;
+export async function* generateGeminiSpeechAudio(options) {
     const abortController = createLinkedAbortController(options.signal);
     let completed = false;
     try {
-        await options.onStageChange?.("rewriting");
-        const rewriteController = createLinkedAbortController(abortController.signal);
-        const rewriteTimeout = setTimeout(() => rewriteController.abort(), SPEECH_REWRITE_TIMEOUT_MS);
-        rewriteTimeout.unref?.();
-        let spokenText;
-        try {
-            spokenText = await rewriteTextForSpeech({
-                apiKey,
-                model: rewriteModel,
-                sourceText,
-                fetchImpl,
-                signal: rewriteController.signal,
-            });
-        }
-        catch (error) {
-            if (!abortController.signal.aborted && rewriteController.signal.aborted) {
-                throw new Error("speech rewrite timed out after 1 minute");
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(rewriteTimeout);
-            rewriteController.dispose();
-        }
-        if (exceedsUnicodeCharacterLimit(spokenText, MAX_SPOKEN_TEXT_CHARACTERS)) {
-            throw new Error("rewritten speech text exceeds 10,000 characters");
-        }
-        const spokenChunks = splitSpeechChunks(spokenText, options.deliveryMode);
-        await options.onStageChange?.("generating");
-        await options.onChunkProgress?.({ ready: 0, total: spokenChunks.length });
-        for await (const chunk of synthesizeSpeechAudioChunksInOrder({
-            apiKey,
-            model: ttsModel,
-            voiceName,
-            spokenChunks,
-            fetchImpl,
+        const prepared = await prepareGeminiSpeech(options, abortController.signal);
+        for await (const chunk of synthesizeSpeechAudioSegmentsInOrder({
+            ...prepared,
             signal: abortController.signal,
-            maxAttempts: options.maxTtsAttempts ?? DEFAULT_TTS_MAX_ATTEMPTS,
-            concurrency: options.deliveryMode === "progressive"
-                ? PROGRESSIVE_TTS_CONCURRENCY
-                : COMPLETE_TTS_CONCURRENCY,
-            onChunkProgress: options.onChunkProgress,
+            concurrency: COMPLETE_TTS_CONCURRENCY,
+            onSegmentProgress: options.onSegmentProgress,
             abortOnFailure: () => abortController.abort(),
         })) {
             yield {
                 index: chunk.index,
-                total: spokenChunks.length,
+                total: prepared.spokenSegments.length,
                 audio: encodeWaveFile({
                     pcmAudio: chunk.pcmAudio,
-                    sampleRateHz: DEFAULT_TTS_SAMPLE_RATE_HZ,
-                    channelCount: DEFAULT_TTS_CHANNEL_COUNT,
-                    bitsPerSample: DEFAULT_TTS_BITS_PER_SAMPLE,
+                    sampleRateHz: GEMINI_SPEECH_SAMPLE_RATE_HZ,
+                    channelCount: GEMINI_SPEECH_CHANNEL_COUNT,
+                    bitsPerSample: GEMINI_SPEECH_BITS_PER_SAMPLE,
                 }),
                 mimeType: "audio/wav",
             };
@@ -132,6 +81,119 @@ export async function* streamGeminiSpeechAudio(options) {
         abortController.dispose();
     }
 }
+export async function* streamGeminiSpeechPcm(options) {
+    const abortController = createLinkedAbortController(options.signal);
+    let completed = false;
+    let totalPcmBytes = 0;
+    try {
+        const prepared = await prepareGeminiSpeech(options, abortController.signal);
+        const total = prepared.spokenSegments.length;
+        const accountAudio = (audio) => {
+            totalPcmBytes += audio.length;
+            if (totalPcmBytes > MAX_SPEECH_PCM_BYTES) {
+                throw new Error("generated speech audio exceeds the 32 MiB limit");
+            }
+        };
+        const prefetch = (index) => collectStreamingSpeechSegment({
+            ...prepared,
+            spokenText: prepared.spokenSegments[index],
+            signal: abortController.signal,
+            accountAudio,
+        }).then((audio) => ({ audio }), (error) => ({ error }));
+        let ready = 0;
+        const firstStream = streamSpeechSegmentWithRetries({
+            ...prepared,
+            spokenText: prepared.spokenSegments[0],
+            signal: abortController.signal,
+            initialBufferBytes: Math.max(0, Math.trunc(options.initialBufferBytes ?? 0)),
+        });
+        const firstIterator = firstStream[Symbol.asyncIterator]();
+        let nextAudio = firstIterator.next();
+        let prefetched = total > 1 ? prefetch(1) : undefined;
+        while (true) {
+            const next = await nextAudio;
+            if (next.done) {
+                break;
+            }
+            accountAudio(next.value);
+            yield { index: 0, total, audio: next.value };
+            nextAudio = firstIterator.next();
+        }
+        ready += 1;
+        await options.onSegmentProgress?.({ ready, total });
+        for (let index = 1; index < total; index += 1) {
+            const outcome = await prefetched;
+            if ("error" in outcome) {
+                throw outcome.error instanceof Error
+                    ? outcome.error
+                    : new Error("Gemini TTS request failed");
+            }
+            prefetched = index + 1 < total ? prefetch(index + 1) : undefined;
+            yield { index, total, audio: outcome.audio };
+            ready += 1;
+            await options.onSegmentProgress?.({ ready, total });
+        }
+        completed = true;
+    }
+    finally {
+        if (!completed) {
+            abortController.abort();
+        }
+        abortController.dispose();
+    }
+}
+async function prepareGeminiSpeech(options, signal) {
+    const sourceText = options.sourceText.trim();
+    if (!sourceText) {
+        throw new Error("speech source text was empty");
+    }
+    if (exceedsUnicodeCharacterLimit(sourceText, MAX_SPEECH_SOURCE_CHARACTERS)) {
+        throw new Error("speech source text exceeds 10,000 characters");
+    }
+    const apiKey = options.apiKey.trim();
+    if (!apiKey) {
+        throw new Error("missing Gemini API key");
+    }
+    const fetchImpl = options.fetchImpl ?? fetch;
+    await options.onStageChange?.("rewriting");
+    const rewriteController = createLinkedAbortController(signal);
+    const rewriteTimeout = setTimeout(() => rewriteController.abort(), SPEECH_REWRITE_TIMEOUT_MS);
+    rewriteTimeout.unref?.();
+    let spokenText;
+    try {
+        spokenText = await rewriteTextForSpeech({
+            apiKey,
+            model: options.rewriteModel ?? DEFAULT_GEMINI_SPEECH_REWRITE_MODEL,
+            sourceText,
+            fetchImpl,
+            signal: rewriteController.signal,
+        });
+    }
+    catch (error) {
+        if (!signal.aborted && rewriteController.signal.aborted) {
+            throw new Error("speech rewrite timed out after 1 minute");
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(rewriteTimeout);
+        rewriteController.dispose();
+    }
+    if (exceedsUnicodeCharacterLimit(spokenText, MAX_SPOKEN_TEXT_CHARACTERS)) {
+        throw new Error("rewritten speech text exceeds 10,000 characters");
+    }
+    const spokenSegments = splitSpeechSegments(spokenText);
+    await options.onStageChange?.("generating");
+    await options.onSegmentProgress?.({ ready: 0, total: spokenSegments.length });
+    return {
+        apiKey,
+        model: options.ttsModel ?? DEFAULT_GEMINI_SPEECH_TTS_MODEL,
+        voiceName: options.voiceName ?? DEFAULT_GEMINI_TTS_VOICE_NAME,
+        spokenSegments,
+        fetchImpl,
+        maxAttempts: options.maxTtsAttempts ?? DEFAULT_TTS_MAX_ATTEMPTS,
+    };
+}
 async function rewriteTextForSpeech(args) {
     const payload = await requestGeminiGenerateContent({
         apiKey: args.apiKey,
@@ -161,8 +223,8 @@ async function rewriteTextForSpeech(args) {
     }
     return rewrittenText;
 }
-async function* synthesizeSpeechAudioChunksInOrder(args) {
-    const total = args.spokenChunks.length;
+async function* synthesizeSpeechAudioSegmentsInOrder(args) {
+    const total = args.spokenSegments.length;
     const results = new Array(total);
     const concurrency = Math.max(1, Math.trunc(args.concurrency));
     let nextIndex = 0;
@@ -202,14 +264,9 @@ async function* synthesizeSpeechAudioChunksInOrder(args) {
                 return;
             }
             try {
-                const pcmAudio = await synthesizeSpeechAudioChunk({
-                    apiKey: args.apiKey,
-                    model: args.model,
-                    voiceName: args.voiceName,
-                    spokenText: args.spokenChunks[index],
-                    fetchImpl: args.fetchImpl,
-                    signal: args.signal,
-                    maxAttempts: args.maxAttempts,
+                const pcmAudio = await synthesizeSpeechAudioSegment({
+                    ...args,
+                    spokenText: args.spokenSegments[index],
                 });
                 totalPcmBytes += pcmAudio.length;
                 if (totalPcmBytes > MAX_SPEECH_PCM_BYTES) {
@@ -217,12 +274,12 @@ async function* synthesizeSpeechAudioChunksInOrder(args) {
                 }
                 results[index] = pcmAudio;
                 ready += 1;
-                await args.onChunkProgress?.({ ready, total });
+                await args.onSegmentProgress?.({ ready, total });
                 wake();
             }
-            catch (err) {
+            catch (error) {
                 if (failure === undefined) {
-                    failure = err;
+                    failure = error;
                 }
                 args.abortOnFailure?.();
                 wake();
@@ -252,40 +309,19 @@ async function* synthesizeSpeechAudioChunksInOrder(args) {
         args.signal?.removeEventListener("abort", onAbort);
     }
 }
-async function synthesizeSpeechAudioChunk(args) {
+async function synthesizeSpeechAudioSegment(args) {
     const maxAttempts = Math.max(1, Math.trunc(args.maxAttempts));
     let lastError;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         try {
             const payload = await requestGeminiGenerateContent({
                 apiKey: args.apiKey,
                 model: args.model,
                 fetchImpl: args.fetchImpl,
                 signal: args.signal,
-                body: {
-                    contents: [
-                        {
-                            parts: [
-                                {
-                                    text: buildSpeechSynthesisPrompt(args.spokenText),
-                                },
-                            ],
-                        },
-                    ],
-                    generationConfig: {
-                        responseModalities: ["AUDIO"],
-                        maxOutputTokens: TTS_MAX_OUTPUT_TOKENS,
-                        speechConfig: {
-                            voiceConfig: {
-                                prebuiltVoiceConfig: {
-                                    voiceName: args.voiceName,
-                                },
-                            },
-                        },
-                    },
-                },
+                body: buildSpeechSynthesisRequest(args.spokenText, args.voiceName),
             });
-            assertGeminiTtsDidNotReachOutputLimit(payload);
+            assertGeminiTtsCompleted(payload);
             const audioData = extractGeminiInlineAudioData(payload);
             if (!audioData) {
                 throw new GeminiTtsResponseError("Gemini TTS response did not include audio data");
@@ -302,8 +338,139 @@ async function synthesizeSpeechAudioChunk(args) {
     }
     throw lastError instanceof Error ? lastError : new Error("Gemini TTS request failed");
 }
+async function* streamSpeechSegmentWithRetries(args) {
+    const maxAttempts = Math.max(1, Math.trunc(args.maxAttempts));
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const bufferedAudio = [];
+        let bufferedAudioBytes = 0;
+        let emittedAudio = false;
+        try {
+            for await (const audio of requestGeminiSpeechStream(args)) {
+                if (!emittedAudio && bufferedAudioBytes < args.initialBufferBytes) {
+                    bufferedAudio.push(audio);
+                    bufferedAudioBytes += audio.length;
+                    if (bufferedAudioBytes < args.initialBufferBytes) {
+                        continue;
+                    }
+                    emittedAudio = true;
+                    yield Buffer.concat(bufferedAudio);
+                    continue;
+                }
+                emittedAudio = true;
+                yield audio;
+            }
+            if (bufferedAudio.length > 0 && !emittedAudio) {
+                emittedAudio = true;
+                yield Buffer.concat(bufferedAudio);
+            }
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            if (emittedAudio ||
+                args.signal?.aborted ||
+                !isRetryableTtsError(error) ||
+                attempt >= maxAttempts) {
+                throw error;
+            }
+            await waitForRetryDelay(attempt, args.signal);
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Gemini TTS request failed");
+}
+async function collectStreamingSpeechSegment(args) {
+    const maxAttempts = Math.max(1, Math.trunc(args.maxAttempts));
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const chunks = [];
+        try {
+            for await (const audio of requestGeminiSpeechStream(args)) {
+                chunks.push(audio);
+            }
+        }
+        catch (error) {
+            lastError = error;
+            if (args.signal?.aborted || !isRetryableTtsError(error) || attempt >= maxAttempts) {
+                throw error;
+            }
+            await waitForRetryDelay(attempt, args.signal);
+            continue;
+        }
+        const audio = Buffer.concat(chunks);
+        args.accountAudio(audio);
+        return audio;
+    }
+    throw lastError instanceof Error ? lastError : new Error("Gemini TTS request failed");
+}
+async function* requestGeminiSpeechStream(args) {
+    const response = await requestGeminiResponse({
+        apiKey: args.apiKey,
+        model: args.model,
+        method: "streamGenerateContent?alt=sse",
+        fetchImpl: args.fetchImpl,
+        signal: args.signal,
+        body: buildSpeechSynthesisRequest(args.spokenText, args.voiceName),
+    });
+    if (!response.body) {
+        throw new GeminiTtsResponseError("Gemini TTS streaming response did not include a body");
+    }
+    let receivedAudio = false;
+    let completed = false;
+    for await (const payload of parseGeminiSse(response.body)) {
+        const finishReason = getGeminiFinishReason(payload);
+        if (finishReason) {
+            assertGeminiTtsFinishReason(finishReason);
+            completed = finishReason === "STOP";
+        }
+        for (const audioData of extractGeminiInlineAudioDataParts(payload)) {
+            receivedAudio = true;
+            yield Buffer.from(audioData, "base64");
+        }
+    }
+    if (!receivedAudio) {
+        throw new GeminiTtsResponseError("Gemini TTS response did not include audio data");
+    }
+    if (!completed) {
+        throw new GeminiTtsResponseError("Gemini TTS stream ended without a stop response");
+    }
+}
+function buildSpeechSynthesisRequest(spokenText, voiceName) {
+    return {
+        contents: [
+            {
+                parts: [
+                    {
+                        text: buildSpeechSynthesisPrompt(spokenText),
+                    },
+                ],
+            },
+        ],
+        generationConfig: {
+            responseModalities: ["AUDIO"],
+            maxOutputTokens: TTS_MAX_OUTPUT_TOKENS,
+            speechConfig: {
+                voiceConfig: {
+                    prebuiltVoiceConfig: {
+                        voiceName,
+                    },
+                },
+            },
+        },
+    };
+}
 async function requestGeminiGenerateContent(args) {
-    const response = await args.fetchImpl(`${GEMINI_GENERATE_CONTENT_BASE_URL}/${encodeURIComponent(args.model)}:generateContent`, {
+    const response = await requestGeminiResponse({ ...args, method: "generateContent" });
+    const responseText = await response.text();
+    try {
+        return responseText ? JSON.parse(responseText) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function requestGeminiResponse(args) {
+    const response = await args.fetchImpl(`${GEMINI_GENERATE_CONTENT_BASE_URL}/${encodeURIComponent(args.model)}:${args.method}`, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
@@ -312,6 +479,9 @@ async function requestGeminiGenerateContent(args) {
         body: JSON.stringify(args.body),
         signal: args.signal,
     });
+    if (response.ok) {
+        return response;
+    }
     const responseText = await response.text();
     let payload;
     try {
@@ -320,15 +490,69 @@ async function requestGeminiGenerateContent(args) {
     catch {
         payload = undefined;
     }
-    if (!response.ok) {
-        const parsed = errorPayloadSchema.safeParse(payload);
-        const fallbackMessage = responseText.trim() || `HTTP ${response.status}`;
-        const message = parsed.success
-            ? (parsed.data.error?.message ?? fallbackMessage)
-            : fallbackMessage;
-        throw new GeminiApiError(message, response.status);
+    const parsed = errorPayloadSchema.safeParse(payload);
+    const fallbackMessage = responseText.trim() || `HTTP ${response.status}`;
+    const message = parsed.success
+        ? (parsed.data.error?.message ?? fallbackMessage)
+        : fallbackMessage;
+    throw new GeminiApiError(message, response.status);
+}
+async function* parseGeminiSse(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffered = "";
+    let completed = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            buffered += decoder.decode(value, { stream: !done });
+            let boundary = findSseEventBoundary(buffered);
+            while (boundary) {
+                const event = buffered.slice(0, boundary.index);
+                buffered = buffered.slice(boundary.index + boundary.length);
+                const payload = parseSseEvent(event);
+                if (payload !== undefined) {
+                    yield payload;
+                }
+                boundary = findSseEventBoundary(buffered);
+            }
+            if (done) {
+                const payload = parseSseEvent(buffered);
+                if (payload !== undefined) {
+                    yield payload;
+                }
+                completed = true;
+                return;
+            }
+        }
+    }
+    finally {
+        if (!completed) {
+            await reader.cancel().catch(() => { });
+        }
+        reader.releaseLock();
+    }
+}
+function findSseEventBoundary(text) {
+    const match = /\r?\n\r?\n/u.exec(text);
+    return match ? { index: match.index, length: match[0].length } : undefined;
+}
+function parseSseEvent(event) {
+    const data = event
+        .split(/\r?\n/u)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n")
+        .trim();
+    if (!data || data === "[DONE]") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        throw new GeminiTtsResponseError("Gemini TTS returned malformed streaming data");
     }
-    return payload;
 }
 function extractGeminiText(payload) {
     if (!isObject(payload) || !Array.isArray(payload.candidates)) {
@@ -350,18 +574,39 @@ function extractGeminiText(payload) {
     }
     return "";
 }
-function assertGeminiTtsDidNotReachOutputLimit(payload) {
-    if (!isObject(payload) || !Array.isArray(payload.candidates)) {
-        return;
+function assertGeminiTtsCompleted(payload) {
+    const finishReason = getGeminiFinishReason(payload);
+    if (finishReason) {
+        assertGeminiTtsFinishReason(finishReason);
     }
-    if (payload.candidates.some((candidate) => isObject(candidate) && candidate.finishReason === "MAX_TOKENS")) {
+}
+function assertGeminiTtsFinishReason(finishReason) {
+    if (finishReason === "MAX_TOKENS") {
         throw new GeminiTtsOutputLimitError();
     }
+    if (finishReason !== "STOP") {
+        throw new GeminiTtsResponseError(`Gemini TTS stopped with finish reason '${finishReason}'`);
+    }
 }
-function extractGeminiInlineAudioData(payload) {
+function getGeminiFinishReason(payload) {
     if (!isObject(payload) || !Array.isArray(payload.candidates)) {
         return undefined;
     }
+    for (const candidate of payload.candidates) {
+        if (isObject(candidate) && typeof candidate.finishReason === "string") {
+            return candidate.finishReason;
+        }
+    }
+    return undefined;
+}
+function extractGeminiInlineAudioData(payload) {
+    return extractGeminiInlineAudioDataParts(payload)[0];
+}
+function extractGeminiInlineAudioDataParts(payload) {
+    if (!isObject(payload) || !Array.isArray(payload.candidates)) {
+        return [];
+    }
+    const audioData = [];
     for (const candidate of payload.candidates) {
         if (!isObject(candidate) ||
             !isObject(candidate.content) ||
@@ -376,11 +621,11 @@ function extractGeminiInlineAudioData(payload) {
             }
             const data = part.inlineData.data.trim();
             if (data) {
-                return data;
+                audioData.push(data);
             }
         }
     }
-    return undefined;
+    return audioData;
 }
 function buildSpeechRewritePrompt(sourceText) {
     return [
@@ -422,46 +667,86 @@ function exceedsUnicodeCharacterLimit(text, limit) {
     }
     return false;
 }
-function splitSpeechChunks(spokenText, deliveryMode) {
+function splitSpeechSegments(spokenText) {
     const normalizedText = spokenText
         .trim()
         .split(/\n\s*\n/gu)
         .map((paragraph) => paragraph.replace(/\s+/gu, " ").trim())
         .filter(Boolean)
         .join("\n\n");
-    const maxCharacters = deliveryMode === "progressive"
-        ? PROGRESSIVE_SPEECH_CHUNK_CHARACTERS
-        : COMPLETE_SPEECH_CHUNK_CHARACTERS;
-    const chunks = [];
-    let remaining = Array.from(normalizedText);
-    while (remaining.length > maxCharacters) {
-        const boundary = findSpeechChunkBoundary(remaining, maxCharacters);
-        chunks.push(remaining.slice(0, boundary).join("").trim());
-        remaining = Array.from(remaining.slice(boundary).join("").trim());
-    }
-    if (remaining.length > 0) {
-        chunks.push(remaining.join(""));
-    }
-    return chunks.length > 0 ? chunks : [spokenText.trim()];
+    const characters = Array.from(normalizedText);
+    const cumulativeWeights = [0];
+    for (const character of characters) {
+        cumulativeWeights.push(cumulativeWeights.at(-1) + speechCharacterWeight(character));
+    }
+    const totalWeight = cumulativeWeights.at(-1);
+    const minimumSegmentCounts = minimumSpeechSegmentCounts(cumulativeWeights);
+    const segmentCount = minimumSegmentCounts[0];
+    if (segmentCount === 1) {
+        return [normalizedText];
+    }
+    const boundaries = [0];
+    for (let segment = 1; segment < segmentCount; segment += 1) {
+        const previousBoundary = boundaries.at(-1);
+        const previousWeight = cumulativeWeights[previousBoundary];
+        const remainingSegments = segmentCount - segment;
+        const idealWeight = (totalWeight * segment) / segmentCount;
+        const maximumBoundary = characters.length - remainingSegments;
+        const candidates = Array.from({ length: maximumBoundary - previousBoundary }, (_, offset) => previousBoundary + offset + 1).filter((index) => cumulativeWeights[index] - previousWeight <= MAX_SPEECH_SEGMENT_WEIGHT &&
+            minimumSegmentCounts[index] <= remainingSegments);
+        const naturalCandidates = candidates.filter((index) => isNaturalSpeechBoundary(characters, index));
+        const wordCandidates = candidates.filter((index) => /\s/u.test(characters[index] ?? ""));
+        boundaries.push(selectSpeechBoundary(naturalCandidates, wordCandidates.length > 0 ? wordCandidates : candidates, cumulativeWeights, idealWeight));
+    }
+    boundaries.push(characters.length);
+    return boundaries
+        .slice(1)
+        .map((boundary, index) => characters.slice(boundaries[index], boundary).join("").trim());
 }
-function findSpeechChunkBoundary(characters, maxCharacters) {
-    const preferredMinimum = Math.floor(maxCharacters * 0.6);
-    for (let index = maxCharacters; index >= preferredMinimum; index -= 1) {
-        if (characters[index] === "\n" && characters[index + 1] === "\n") {
-            return index;
-        }
-    }
-    for (let index = maxCharacters; index >= preferredMinimum; index -= 1) {
-        if (isSpeechSentenceBoundary(characters[index - 1] ?? "", characters[index] ?? "")) {
-            return index;
+function speechCharacterWeight(character) {
+    return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u.test(character)
+        ? 3
+        : 1;
+}
+function minimumSpeechSegmentCounts(cumulativeWeights) {
+    const counts = new Array(cumulativeWeights.length).fill(0);
+    let boundary = cumulativeWeights.length - 1;
+    for (let index = cumulativeWeights.length - 2; index >= 0; index -= 1) {
+        while (cumulativeWeights[boundary] - cumulativeWeights[index] > MAX_SPEECH_SEGMENT_WEIGHT) {
+            boundary -= 1;
         }
+        counts[index] = counts[boundary] + 1;
     }
-    for (let index = maxCharacters; index >= 1; index -= 1) {
-        if (/\s/u.test(characters[index] ?? "")) {
-            return index;
+    return counts;
+}
+function isNaturalSpeechBoundary(characters, index) {
+    const previous = characters[index - 1] ?? "";
+    const next = characters[index] ?? "";
+    return (previous === "\n" && next === "\n") || isSpeechSentenceBoundary(previous, next);
+}
+function selectSpeechBoundary(naturalCandidates, fallbackCandidates, cumulativeWeights, idealWeight) {
+    const fallback = closestSpeechBoundary(fallbackCandidates, cumulativeWeights, idealWeight);
+    if (naturalCandidates.length === 0) {
+        return fallback;
+    }
+    const natural = closestSpeechBoundary(naturalCandidates, cumulativeWeights, idealWeight);
+    const naturalDistance = Math.abs(cumulativeWeights[natural] - idealWeight);
+    const fallbackDistance = Math.abs(cumulativeWeights[fallback] - idealWeight);
+    return naturalDistance <= fallbackDistance + MAX_SPEECH_SEGMENT_WEIGHT * 0.05
+        ? natural
+        : fallback;
+}
+function closestSpeechBoundary(candidates, cumulativeWeights, idealWeight) {
+    let closest = candidates[0];
+    let closestDistance = Math.abs(cumulativeWeights[closest] - idealWeight);
+    for (const candidate of candidates.slice(1)) {
+        const distance = Math.abs(cumulativeWeights[candidate] - idealWeight);
+        if (distance < closestDistance) {
+            closest = candidate;
+            closestDistance = distance;
         }
     }
-    return maxCharacters;
+    return closest;
 }
 function isSpeechSentenceBoundary(previous, next) {
     return /[。！？]/u.test(previous) || (/[.!?;:]/u.test(previous) && /\s/u.test(next));