runonweb 0.0.1

package/src/tts/kitten.ts

@@ -0,0 +1,280 @@
+import type { ProgressCallback } from '../core/index.ts'
+import { splitUtterances } from './split.ts'
+import { toFloat32 } from './wav.ts'
+import type { SpeakChunk } from './types.ts'
+
+const HF = 'https://huggingface.co/KittenML/kitten-tts-nano-0.8-int8/resolve/main'
+const CACHE = 'runonweb-kitten-tts'
+const ORT_WASM = 'https://cdn.jsdelivr.net/npm/onnxruntime-web@1.30.0/dist/'
+const SAMPLE_RATE = 24_000
+const AUDIO_TRIM = 5_000
+
+const VOICE_ALIASES: Record<string, string> = {
+  bella: 'expr-voice-2-f',
+  jasper: 'expr-voice-2-m',
+  luna: 'expr-voice-3-f',
+  bruno: 'expr-voice-3-m',
+  rosie: 'expr-voice-4-f',
+  hugo: 'expr-voice-4-m',
+  kiki: 'expr-voice-5-f',
+  leo: 'expr-voice-5-m',
+}
+
+const SPEED_PRIORS: Record<string, number> = {
+  'expr-voice-2-f': 0.8,
+  'expr-voice-2-m': 0.8,
+  'expr-voice-3-m': 0.8,
+  'expr-voice-3-f': 0.8,
+  'expr-voice-4-m': 0.9,
+  'expr-voice-4-f': 0.8,
+  'expr-voice-5-m': 0.8,
+  'expr-voice-5-f': 0.8,
+}
+
+const PAD = '$'
+const PUNCTUATION = ';:,.!?¡¿—…"«»"" '
+const LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+const LETTERS_IPA =
+  "ɑɐɒæɓʙβɔɕçɗɖðʤəɘɚɛɜɝɞɟʄɡɠɢʛɦɧħɥʜɨɪʝɭɬɫɮʟɱɯɰŋɳɲɴøɵɸθœɶʘɹɺɾɻʀʁɽʂʃʈʧʉʊʋⱱʌɣɤʍχʎʏʑʐʒʔʡʕʢǀǁǂǃˈˌːˑʼʴʰʱʲʷˠˤ˞↓↑→↗↘''ᵻ"
+const SYMBOLS = [PAD, ...PUNCTUATION, ...LETTERS, ...LETTERS_IPA]
+const SYMBOL_TO_ID = new Map(SYMBOLS.map((s, i) => [s, i]))
+
+type OrtApi = {
+  env: { wasm: { wasmPaths: string; numThreads: number; simd?: boolean } }
+  Tensor: new (type: string, data: Float32Array | BigInt64Array, dims: number[]) => unknown
+  InferenceSession: {
+    create: (
+      model: ArrayBuffer,
+      options?: { executionProviders?: string[] }
+    ) => Promise<{ run: (feeds: Record<string, unknown>) => Promise<Record<string, { data: Float32Array }>> }>
+  }
+}
+
+type VoiceEntry = { data: Float32Array; shape: number[] }
+
+export type LoadedKitten = {
+  session: Awaited<ReturnType<OrtApi['InferenceSession']['create']>>
+  voices: Record<string, VoiceEntry>
+  ort: OrtApi
+}
+
+export async function loadKitten(onProgress?: ProgressCallback): Promise<LoadedKitten> {
+  onProgress?.({ status: 'loading', progress: 0 })
+  const [model, voicesBuf] = await Promise.all([
+    fetchCached(`${HF}/kitten_tts_nano_v0_8.onnx`, 'kitten.onnx', onProgress),
+    fetchCached(`${HF}/voices.npz`, 'voices.npz', onProgress),
+  ])
+  const [ort, voices] = await Promise.all([loadOrt(), loadNpz(voicesBuf)])
+  const session = await ort.InferenceSession.create(model, { executionProviders: ['wasm'] })
+  onProgress?.({ status: 'ready', progress: 100 })
+  return { session, voices, ort }
+}
+
+export async function* streamKitten(
+  loaded: LoadedKitten,
+  text: string,
+  voice: string,
+  speed: number
+): AsyncGenerator<SpeakChunk> {
+  for (const piece of splitUtterances(text)) {
+    const audio = await inferKitten(loaded, piece, voice, speed)
+    yield { audio, samplingRate: SAMPLE_RATE, text: piece }
+  }
+}
+
+export function disposeKitten(loaded: LoadedKitten | null) {
+  const session = loaded?.session as { release?: () => Promise<void> } | undefined
+  void session?.release?.()
+}
+
+async function inferKitten(loaded: LoadedKitten, text: string, voiceId: string, speed: number): Promise<Float32Array> {
+  const key = VOICE_ALIASES[voiceId] ?? voiceId
+  const voice = loaded.voices[key]
+  if (!voice) throw new Error(`Unknown Kitten voice: ${voiceId}`)
+
+  const phonemes = await phonemizeEnglish(ensurePunctuation(text))
+  const tokenIds = cleanPhonemes(phonemes)
+  const [numStyles, styleDim] = voice.shape
+  const refId = Math.min(tokenIds.length, (numStyles ?? 1) - 1)
+  const dim = styleDim ?? 256
+  const style = voice.data.slice(refId * dim, (refId + 1) * dim)
+  const scaled = speed * (SPEED_PRIORS[key] ?? 1)
+
+  const feeds = {
+    input_ids: new loaded.ort.Tensor('int64', BigInt64Array.from(tokenIds.map(BigInt)), [1, tokenIds.length]),
+    style: new loaded.ort.Tensor('float32', new Float32Array(style), [1, dim]),
+    speed: new loaded.ort.Tensor('float32', new Float32Array([scaled]), [1]),
+  }
+  const results = await loaded.session.run(feeds)
+  const output = results[Object.keys(results)[0] ?? '']
+  const data = toFloat32(output?.data ?? [])
+  return data.slice(0, Math.max(0, data.length - AUDIO_TRIM))
+}
+
+function cleanPhonemes(phonemes: string): number[] {
+  const ids: number[] = []
+  for (const ch of phonemes) {
+    const id = SYMBOL_TO_ID.get(ch)
+    if (id !== undefined) ids.push(id)
+  }
+  return [0, ...ids, 10, 0]
+}
+
+function ensurePunctuation(text: string): string {
+  const t = text.trim()
+  if (!t) return t
+  return /[.!?,;:]$/.test(t) ? t : `${t},`
+}
+
+async function phonemizeEnglish(text: string): Promise<string> {
+  const { phonemize } = await import('phonemizer')
+  const chunks = text.split(/([;:,.!?¡¿—…"«»"()\n]+)/)
+  let out = ''
+  for (const chunk of chunks) {
+    if (!chunk) continue
+    if (/^[;:,.!?¡¿—…"«»"()\s]+$/.test(chunk)) {
+      out += chunk
+      continue
+    }
+    const ipa = await phonemize(chunk, 'en-us')
+    out += ipa.join(' ').replace(/_/g, '')
+  }
+  return out.trim()
+}
+
+async function loadOrt(): Promise<OrtApi> {
+  const ort = (await import('onnxruntime-web')) as unknown as OrtApi
+  ort.env.wasm.wasmPaths = ORT_WASM
+  ort.env.wasm.numThreads = 1
+  return ort
+}
+
+async function fetchCached(url: string, file: string, onProgress?: ProgressCallback): Promise<ArrayBuffer> {
+  const cache = await caches.open(CACHE).catch(() => null)
+  const hit = await cache?.match(url)
+  if (hit) {
+    onProgress?.({ status: 'progress', progress: 100, file })
+    return hit.arrayBuffer()
+  }
+
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`Could not load ${file} (${res.status})`)
+
+  const total = Number(res.headers.get('content-length') ?? 0)
+  if (!res.body || !total) {
+    const buf = await res.arrayBuffer()
+    await cache?.put(url, new Response(buf.slice(0)))
+    return buf
+  }
+
+  const reader = res.body.getReader()
+  const chunks: Uint8Array[] = []
+  let received = 0
+  for (;;) {
+    const { done, value } = await reader.read()
+    if (done) break
+    chunks.push(value)
+    received += value.byteLength
+    onProgress?.({ status: 'progress', progress: (received / total) * 100, file })
+  }
+
+  const out = new Uint8Array(received)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  await cache?.put(url, new Response(out.buffer.slice(0)))
+  return out.buffer
+}
+
+async function loadNpz(buffer: ArrayBuffer): Promise<Record<string, VoiceEntry>> {
+  const view = new DataView(buffer)
+  const bytes = new Uint8Array(buffer)
+  const voices: Record<string, VoiceEntry> = {}
+
+  const eocd = findEocd(view, bytes.length)
+  const count = view.getUint16(eocd + 10, true)
+  let central = view.getUint32(eocd + 16, true)
+
+  for (let i = 0; i < count; i++) {
+    if (view.getUint32(central, true) !== 0x02014b50) break
+    const method = view.getUint16(central + 10, true)
+    const compSize = view.getUint32(central + 20, true)
+    const rawSize = view.getUint32(central + 24, true)
+    const nameLen = view.getUint16(central + 28, true)
+    const extraLen = view.getUint16(central + 30, true)
+    const commentLen = view.getUint16(central + 32, true)
+    const localOff = view.getUint32(central + 42, true)
+    const name = new TextDecoder().decode(bytes.subarray(central + 46, central + 46 + nameLen))
+    central += 46 + nameLen + extraLen + commentLen
+    if (!name.endsWith('.npy')) continue
+
+    const localNameLen = view.getUint16(localOff + 26, true)
+    const localExtraLen = view.getUint16(localOff + 28, true)
+    const dataStart = localOff + 30 + localNameLen + localExtraLen
+    const compressed = bytes.subarray(dataStart, dataStart + compSize)
+    const raw =
+      method === 0 ? copyBytes(compressed) : method === 8 ? await inflateRaw(compressed, rawSize) : null
+    if (!raw) throw new Error(`Unsupported zip method ${method} in voices.npz`)
+    const key = name.replace(/\.npy$/, '').split('/').pop() ?? name
+    voices[key] = parseNpy(copyBytes(raw).buffer)
+  }
+
+  if (!Object.keys(voices).length) throw new Error('voices.npz contained no arrays')
+  return voices
+}
+
+function findEocd(view: DataView, length: number): number {
+  for (let i = length - 22; i >= Math.max(0, length - 22 - 0xffff); i--) {
+    if (view.getUint32(i, true) === 0x06054b50) return i
+  }
+  throw new Error('voices.npz is not a valid zip')
+}
+
+function copyBytes(src: Uint8Array): Uint8Array<ArrayBuffer> {
+  const out = new Uint8Array(new ArrayBuffer(src.byteLength))
+  out.set(src)
+  return out
+}
+
+async function inflateRaw(data: Uint8Array, outLen: number): Promise<Uint8Array> {
+  const stream = new DecompressionStream('deflate-raw')
+  const writer = stream.writable.getWriter()
+  await writer.write(Uint8Array.from(data))
+  await writer.close()
+  const reader = stream.readable.getReader()
+  const chunks: Uint8Array[] = []
+  let received = 0
+  for (;;) {
+    const { done, value } = await reader.read()
+    if (done) break
+    chunks.push(value)
+    received += value.byteLength
+  }
+  const out = new Uint8Array(outLen || received)
+  let offset = 0
+  for (const chunk of chunks) {
+    out.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  return out
+}
+
+function parseNpy(buf: ArrayBuffer): VoiceEntry {
+  const bytes = new Uint8Array(buf)
+  const major = bytes[6] ?? 1
+  const headerLen =
+    major >= 2 ? new DataView(buf, 8, 4).getUint32(0, true) : new DataView(buf, 8, 2).getUint16(0, true)
+  const headerOffset = major >= 2 ? 12 : 10
+  const header = new TextDecoder().decode(bytes.subarray(headerOffset, headerOffset + headerLen))
+  const shapeStr = header.match(/'shape'\s*:\s*\(([^)]*)\)/)?.[1]?.trim() ?? ''
+  const shape = shapeStr === '' ? [1] : shapeStr.split(',').map((s) => Number(s.trim())).filter((n) => !Number.isNaN(n))
+  const start = headerOffset + headerLen
+  const avail = buf.byteLength - start
+  const usable = avail - (avail % 4)
+  const data = new Float32Array(buf.slice(start, start + usable))
+  return { data, shape }
+}
+
+export { SAMPLE_RATE as KITTEN_SAMPLE_RATE }

package/src/tts/kokoro.ts

@@ -0,0 +1,140 @@
+import type { Device, ProgressCallback, ResolvedDevice } from '../core/index.ts'
+import { resolveDevice, toProgressInfo } from '../core/index.ts'
+import { phonemizeLang } from './phonemes.ts'
+import { splitUtterances } from './split.ts'
+import { toFloat32 } from './wav.ts'
+import { kokoroPhonemeLang } from './voices.ts'
+import type { SpeakChunk } from './types.ts'
+
+/**
+ * Kokoro 82M (StyleTTS 2) on Transformers.js directly. No `kokoro-js`, so the app ships one
+ * copy of Transformers.js. Voice style vectors come from the same Hugging Face repo.
+ */
+const DEFAULT_MODEL = 'onnx-community/Kokoro-82M-v1.0-ONNX'
+const SAMPLE_RATE = 24_000
+const STYLE_DIM = 256
+const MAX_STYLE_INDEX = 509
+const VOICE_CACHE = 'runonweb-kokoro-voices'
+
+type Tensorish = { data: Float32Array | number[]; dims: number[] }
+
+type KokoroModel = {
+  (inputs: Record<string, unknown>): Promise<{ waveform: Tensorish }>
+  dispose?: () => Promise<void>
+}
+
+type KokoroTokenizer = (text: string, options?: { truncation?: boolean }) => { input_ids: { dims: number[] } }
+
+export type LoadedKokoro = {
+  model: KokoroModel
+  tokenizer: KokoroTokenizer
+  modelId: string
+  device: ResolvedDevice
+}
+
+export async function loadKokoro(options: {
+  model?: string
+  device?: Device
+  onProgress?: ProgressCallback
+}): Promise<LoadedKokoro> {
+  const device = await resolveDevice(options.device ?? 'auto')
+  options.onProgress?.({ status: 'loading', progress: 0 })
+
+  const { StyleTextToSpeech2Model, AutoTokenizer, env } = await import('@huggingface/transformers')
+  env.allowLocalModels = false
+  const modelId = options.model ?? DEFAULT_MODEL
+  const progress_callback = (data: Record<string, unknown>) => {
+    options.onProgress?.(toProgressInfo(data))
+  }
+
+  const [model, tokenizer] = await Promise.all([
+    StyleTextToSpeech2Model.from_pretrained(modelId, {
+      device,
+      // fp16 / q4f16 produce NaN on the Transformers.js 4 WebGPU runtime; fp32 is clean and fast.
+      dtype: device === 'webgpu' ? 'fp32' : 'q8',
+      progress_callback,
+    }),
+    AutoTokenizer.from_pretrained(modelId, { progress_callback }),
+  ])
+
+  options.onProgress?.({ status: 'ready', progress: 100 })
+  return {
+    model: model as unknown as KokoroModel,
+    tokenizer: tokenizer as unknown as KokoroTokenizer,
+    modelId,
+    device,
+  }
+}
+
+export async function* streamKokoro(
+  kokoro: LoadedKokoro,
+  text: string,
+  voice: string,
+  speed: number
+): AsyncGenerator<SpeakChunk> {
+  const lang = kokoroPhonemeLang(voice) ?? (voice.startsWith('b') ? 'en-gb' : 'en-us')
+  for (const piece of splitUtterances(text)) {
+    const phonemes = await phonemizeLang(piece, lang)
+    if (!phonemes) throw new Error(`Could not phonemize text for ${lang}`)
+    const audio = await synthesize(kokoro, phonemes, voice, speed)
+    yield { audio, samplingRate: SAMPLE_RATE, text: piece }
+  }
+}
+
+async function synthesize(kokoro: LoadedKokoro, phonemes: string, voice: string, speed: number): Promise<Float32Array> {
+  const { Tensor } = await import('@huggingface/transformers')
+  const { input_ids } = kokoro.tokenizer(phonemes, { truncation: true })
+  const numTokens = Math.min(Math.max((input_ids.dims.at(-1) ?? 2) - 2, 0), MAX_STYLE_INDEX)
+  const styles = await loadVoice(kokoro.modelId, voice)
+  const style = styles.slice(numTokens * STYLE_DIM, (numTokens + 1) * STYLE_DIM)
+
+  const { waveform } = await kokoro.model({
+    input_ids,
+    style: new Tensor('float32', style, [1, STYLE_DIM]),
+    speed: new Tensor('float32', [speed], [1]),
+  })
+  return toFloat32(waveform.data)
+}
+
+const voiceCache = new Map<string, Promise<Float32Array>>()
+
+/** Fetch `voices/<id>.bin` (510×256 float32 styles indexed by token count) and keep it in the Cache API. */
+function loadVoice(modelId: string, voice: string): Promise<Float32Array> {
+  const key = `${modelId}/${voice}`
+  let pending = voiceCache.get(key)
+  if (!pending) {
+    pending = fetchVoice(modelId, voice).catch((err) => {
+      voiceCache.delete(key)
+      throw err
+    })
+    voiceCache.set(key, pending)
+  }
+  return pending
+}
+
+async function fetchVoice(modelId: string, voice: string): Promise<Float32Array> {
+  const url = `https://huggingface.co/${modelId}/resolve/main/voices/${voice}.bin`
+  let cache: Cache | null = null
+  try {
+    cache = await caches.open(VOICE_CACHE)
+    const hit = await cache.match(url)
+    if (hit) return new Float32Array(await hit.arrayBuffer())
+  } catch {
+    cache = null
+  }
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`Voice "${voice}" not found (${res.status})`)
+  const buffer = await res.arrayBuffer()
+  try {
+    await cache?.put(url, new Response(buffer.slice(0), { headers: { 'content-type': 'application/octet-stream' } }))
+  } catch {
+    // Cache is best-effort.
+  }
+  return new Float32Array(buffer)
+}
+
+export function disposeKokoro(kokoro: LoadedKokoro | null) {
+  void kokoro?.model.dispose?.()
+}
+
+export { DEFAULT_MODEL as KOKORO_MODEL, SAMPLE_RATE as KOKORO_SAMPLE_RATE }

package/src/tts/phonemes.ts

@@ -0,0 +1,150 @@
+import { kokoroPhonemeLang } from './voices.ts'
+
+const ESPEAK_JS = 'https://cdn.jsdelivr.net/npm/espeak-ng@1.0.2/dist/espeak-ng.js'
+const ESPEAK_WASM = 'https://cdn.jsdelivr.net/npm/espeak-ng@1.0.2/dist/espeak-ng.wasm'
+
+type ESpeakInstance = {
+  FS: { readFile: (name: string, opts: { encoding: string }) => string }
+}
+
+type ESpeakFactory = (opts: {
+  locateFile?: (file: string) => string
+  arguments?: string[]
+}) => Promise<ESpeakInstance>
+
+let factory: ESpeakFactory | null = null
+
+/**
+ * Convert text to IPA for Kokoro. English uses `phonemizer` with Kokoro's text normalization
+ * and phoneme fixes (ported from kokoro-js); ES/FR load eSpeak-NG WASM on demand.
+ */
+export async function phonemizeLang(text: string, lang: string): Promise<string> {
+  if (lang === 'en-us' || lang === 'en-gb' || lang === 'en') {
+    return phonemizeEnglish(text, lang === 'en-us' ? 'a' : 'b')
+  }
+  return phonemizeEspeak(text, lang)
+}
+
+const PUNCT = ';:,.!?¡¿—…"«»“”(){}[]'
+const PUNCT_RE = new RegExp(`(\\s*[${PUNCT.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}]+\\s*)+`, 'g')
+
+async function phonemizeEnglish(text: string, variant: 'a' | 'b'): Promise<string> {
+  const { phonemize } = await import('phonemizer')
+  const normalized = normalizeEnglish(text)
+  const lang = variant === 'a' ? 'en-us' : 'en'
+
+  // Phonemize the text between punctuation runs; keep the punctuation verbatim.
+  const parts: string[] = []
+  let last = 0
+  for (const m of normalized.matchAll(PUNCT_RE)) {
+    const idx = m.index ?? 0
+    if (last < idx) parts.push((await phonemize(normalized.slice(last, idx), lang)).join(' '))
+    if (m[0].length > 0) parts.push(m[0])
+    last = idx + m[0].length
+  }
+  if (last < normalized.length) parts.push((await phonemize(normalized.slice(last), lang)).join(' '))
+
+  let ps = parts
+    .join('')
+    .replace(/kəkˈoːɹoʊ/g, 'kˈoʊkəɹoʊ')
+    .replace(/kəkˈɔːɹəʊ/g, 'kˈəʊkəɹəʊ')
+    .replace(/ʲ/g, 'j')
+    .replace(/r/g, 'ɹ')
+    .replace(/x/g, 'k')
+    .replace(/ɬ/g, 'l')
+    .replace(/(?<=[a-zɹː])(?=hˈʌndɹɪd)/g, ' ')
+    .replace(/ z(?=[;:,.!?¡¿—…"«»“” ]|$)/g, 'z')
+  if (variant === 'a') ps = ps.replace(/(?<=nˈaɪn)ti(?!ː)/g, 'di')
+  return ps.replace(/\s+/g, ' ').trim()
+}
+
+function normalizeEnglish(text: string): string {
+  return text
+    .replace(/[‘’]/g, "'")
+    .replace(/«/g, '“')
+    .replace(/»/g, '”')
+    .replace(/[“”]/g, '"')
+    .replace(/\(/g, '«')
+    .replace(/\)/g, '»')
+    .replace(/、/g, ', ')
+    .replace(/。/g, '. ')
+    .replace(/！/g, '! ')
+    .replace(/，/g, ', ')
+    .replace(/：/g, ': ')
+    .replace(/；/g, '; ')
+    .replace(/？/g, '? ')
+    .replace(/[^\S \n]/g, ' ')
+    .replace(/  +/, ' ')
+    .replace(/(?<=\n) +(?=\n)/g, '')
+    .replace(/\bD[Rr]\.(?= [A-Z])/g, 'Doctor')
+    .replace(/\b(?:Mr\.|MR\.(?= [A-Z]))/g, 'Mister')
+    .replace(/\b(?:Ms\.|MS\.(?= [A-Z]))/g, 'Miss')
+    .replace(/\b(?:Mrs\.|MRS\.(?= [A-Z]))/g, 'Mrs')
+    .replace(/\betc\.(?! [A-Z])/gi, 'etc')
+    .replace(/\b(y)eah?\b/gi, "$1e'a")
+    .replace(/\d*\.\d+|\b\d{4}s?\b|(?<!:)\b(?:[1-9]|1[0-2]):[0-5]\d\b(?!:)/g, splitNum)
+    .replace(/(?<=\d),(?=\d)/g, '')
+    .replace(/[$£]\d+(?:\.\d+)?(?: hundred| thousand| (?:[bm]|tr)illion)*\b|[$£]\d+\.\d\d?\b/gi, flipMoney)
+    .replace(/\d*\.\d+/g, pointNum)
+    .replace(/(?<=\d)-(?=\d)/g, ' to ')
+    .replace(/(?<=\d)S/g, ' S')
+    .replace(/(?<=[BCDFGHJ-NP-TV-Z])'?s\b/g, "'S")
+    .replace(/(?<=X')S\b/g, 's')
+    .replace(/(?:[A-Za-z]\.){2,} [a-z]/g, (m) => m.replace(/\./g, '-'))
+    .replace(/(?<=[A-Z])\.(?=[A-Z])/gi, '-')
+    .trim()
+}
+
+function splitNum(match: string): string {
+  if (match.includes('.')) return match
+  if (match.includes(':')) {
+    const [h, m] = match.split(':').map(Number)
+    if (m === 0) return `${h} o'clock`
+    if (m! < 10) return `${h} oh ${m}`
+    return `${h} ${m}`
+  }
+  const year = parseInt(match.slice(0, 4), 10)
+  if (year < 1100 || year % 1000 < 10) return match
+  const left = match.slice(0, 2)
+  const right = parseInt(match.slice(2, 4), 10)
+  const suffix = match.endsWith('s') ? 's' : ''
+  if (year % 1000 >= 100 && year % 1000 <= 999) {
+    if (right === 0) return `${left} hundred${suffix}`
+    if (right < 10) return `${left} oh ${right}${suffix}`
+  }
+  return `${left} ${right}${suffix}`
+}
+
+function flipMoney(match: string): string {
+  const unit = match[0] === '$' ? 'dollar' : 'pound'
+  if (isNaN(Number(match.slice(1)))) return `${match.slice(1)} ${unit}s`
+  if (!match.includes('.')) {
+    const s = match.slice(1) === '1' ? '' : 's'
+    return `${match.slice(1)} ${unit}${s}`
+  }
+  const [whole, frac] = match.slice(1).split('.')
+  const cents = parseInt((frac ?? '').padEnd(2, '0'), 10)
+  const centUnit = match[0] === '$' ? (cents === 1 ? 'cent' : 'cents') : cents === 1 ? 'penny' : 'pence'
+  return `${whole} ${unit}${whole === '1' ? '' : 's'} and ${cents} ${centUnit}`
+}
+
+function pointNum(match: string): string {
+  const [whole, frac] = match.split('.')
+  return `${whole} point ${(frac ?? '').split('').join(' ')}`
+}
+
+async function phonemizeEspeak(text: string, lang: string): Promise<string> {
+  if (!factory) {
+    const mod = (await import(/* @vite-ignore */ ESPEAK_JS)) as { default: ESpeakFactory }
+    factory = mod.default
+  }
+  const instance = await factory({
+    locateFile: (file) => (file.endsWith('.wasm') ? ESPEAK_WASM : file),
+    arguments: ['--phonout', 'generated', '-q', '-b=1', '--ipa=3', '-v', lang, text],
+  })
+  return instance.FS.readFile('generated', { encoding: 'utf8' }).replace(/\s+/g, ' ').trim()
+}
+
+export function needsExternalPhonemes(voiceId: string): boolean {
+  return kokoroPhonemeLang(voiceId) != null
+}

package/src/tts/sizes.ts

@@ -0,0 +1,30 @@
+export type TTSSize = 'tiny' | 'small' | 'multi'
+
+export const TTS_SIZES: Record<
+  TTSSize,
+  { label: string; engine: string; params: string; downloadMB: string; quality: string }
+> = {
+  tiny: {
+    label: 'Tiny',
+    engine: 'KittenTTS',
+    params: '15M',
+    downloadMB: '~28 MB',
+    quality: '8 English voices',
+  },
+  small: {
+    label: 'Small',
+    engine: 'Kokoro 82M',
+    params: '82M',
+    downloadMB: '~326 MB · WASM ~92 MB',
+    quality: 'English · Spanish · French',
+  },
+  multi: {
+    label: 'Multi',
+    engine: 'Supertonic 2',
+    params: '66M',
+    downloadMB: '~262 MB',
+    quality: 'en · ko · es · pt · fr · 44.1 kHz',
+  },
+}
+
+export const DEFAULT_TTS_SIZE: TTSSize = 'small'

package/src/tts/split.ts

@@ -0,0 +1,31 @@
+const MAX_CHARS = 240
+
+/** Split text into sentence-sized chunks for streaming synthesis. */
+export function splitUtterances(text: string): string[] {
+  const trimmed = text.trim()
+  if (!trimmed) return []
+
+  const sentences = trimmed.split(/(?<=[.!?…])\s+|\n+/).map((s) => s.trim()).filter(Boolean)
+  const out: string[] = []
+
+  for (const sentence of sentences) {
+    if (sentence.length <= MAX_CHARS) {
+      out.push(sentence)
+      continue
+    }
+    const words = sentence.split(/\s+/)
+    let buf = ''
+    for (const word of words) {
+      const next = buf ? `${buf} ${word}` : word
+      if (next.length > MAX_CHARS && buf) {
+        out.push(buf)
+        buf = word
+      } else {
+        buf = next
+      }
+    }
+    if (buf) out.push(buf)
+  }
+
+  return out
+}