Happy Audio Gen

{
  "name": "happy-audio-gen",
  "version": "0.1.0",
  "description": "Universal TTS / voice generation skill — OpenAI TTS, ElevenLabs, Bailian qwen-tts, MiniMax, SiliconFlow CosyVoice, PlayHT",
  "type": "module",
  "private": true,
  "engines": {
    "bun": ">=1.1.0"
  },
  "scripts": {
    "gen": "bun scripts/main.ts"
  }
}

import path from "node:path";
import { readFile } from "node:fs/promises";
import { fileURLToPath } from "node:url";
import type { AudioFormat, CliArgs, Provider, ProviderModule } from "./types";
import { ConfigError, ProviderError } from "./types";
import { inferFormatFromPath, validateAudioMagic, writeBytesToFile } from "./utils/output";

const KNOWN_PROVIDERS: Provider[] = [
  "openai",
  "elevenlabs",
  "bailian",
  "minimax",
  "siliconflow",
  "playht",
];

const IMPLEMENTED: Set<Provider> = new Set(KNOWN_PROVIDERS);

function printUsage(): void {
  console.log(`happy-audio-gen — universal TTS / voice generation CLI

Usage:
  bun scripts/main.ts --text "Hello world" --out ./hello.mp3
  bun scripts/main.ts --textfiles script.md --out ./narration.mp3
  bun scripts/main.ts --text "..." --voice alloy --provider openai --out out.mp3

Options:
  -t, --text <text>          Text to speak (double-quote)
  --textfiles <files...>     Read text from files (concatenated)
  --out <path>               Output file path (REQUIRED). Extension sets the format (mp3/wav/ogg/flac).
  --provider <id>            openai | elevenlabs | bailian | minimax | siliconflow | playht
  -m, --model <id>           Provider-specific model id
  --voice <id>               Voice id or name
  --format <fmt>             Override format (mp3/wav/pcm/opus/ogg/flac)
  --rate <n>                 Speaking rate (1.0 default; 0.5–2.0 where supported)
  --pitch <n>                Pitch adjustment where supported
  --volume <n>               Volume adjustment where supported
  --language <code>          e.g. en, zh, ja (provider-dependent)
  --instruction <text>       Voice direction (gpt-4o-mini-tts style)
  --poll-timeout <seconds>   Default 300 (only used by async provider flows, e.g. Bailian voice-design)
  --poll-interval <seconds>  Default 3
  --json                     Emit JSON result
  --setup                    Print first-time setup guide
  -h, --help                 Show this message

Environment variables (set at least one):
  OPENAI_API_KEY, ELEVENLABS_API_KEY, DASHSCOPE_API_KEY, MINIMAX_API_KEY,
  SILICONFLOW_API_KEY, PLAYHT_USER_ID + PLAYHT_API_KEY

See references/providers.md and references/config/first-time-setup.md for details.
`);
}

async function printSetupGuide(): Promise<void> {
  const here = path.dirname(fileURLToPath(import.meta.url));
  const guidePath = path.resolve(here, "../references/config/first-time-setup.md");
  try {
    const guide = await readFile(guidePath, "utf8");
    console.log(guide);
  } catch {
    console.log("Export OPENAI_API_KEY (or another provider env var) and rerun with --text ... --out ...");
  }
}

function parseArgs(argv: string[]): CliArgs {
  const args: CliArgs = {
    text: null,
    textFiles: [],
    outputPath: null,
    provider: null,
    model: null,
    voice: null,
    format: null,
    rate: null,
    pitch: null,
    volume: null,
    language: null,
    instruction: null,
    pollTimeoutMs: 300_000,
    pollIntervalMs: 3_000,
    json: false,
    setup: false,
    help: false,
  };

  const tokens = [...argv];
  while (tokens.length > 0) {
    const token = tokens.shift()!;
    switch (token) {
      case "-t":
      case "--text":
        args.text = tokens.shift() ?? null;
        break;
      case "--textfiles":
        while (tokens.length > 0 && !tokens[0]!.startsWith("--") && tokens[0] !== "-t") {
          args.textFiles.push(tokens.shift()!);
        }
        break;
      case "--out":
      case "--output":
        args.outputPath = tokens.shift() ?? null;
        break;
      case "--provider":
        args.provider = tokens.shift() as Provider | null;
        break;
      case "-m":
      case "--model":
        args.model = tokens.shift() ?? null;
        break;
      case "--voice":
        args.voice = tokens.shift() ?? null;
        break;
      case "--format":
        args.format = tokens.shift() as AudioFormat | null;
        break;
      case "--rate":
        args.rate = Number(tokens.shift() || 1);
        break;
      case "--pitch":
        args.pitch = Number(tokens.shift() || 0);
        break;
      case "--volume":
        args.volume = Number(tokens.shift() || 1);
        break;
      case "--language":
      case "--lang":
        args.language = tokens.shift() ?? null;
        break;
      case "--instruction":
      case "--direction":
        args.instruction = tokens.shift() ?? null;
        break;
      case "--poll-timeout":
        args.pollTimeoutMs = Math.max(10, Number(tokens.shift() || 300)) * 1000;
        break;
      case "--poll-interval":
        args.pollIntervalMs = Math.max(1, Number(tokens.shift() || 3)) * 1000;
        break;
      case "--json":
        args.json = true;
        break;
      case "--setup":
        args.setup = true;
        break;
      case "-h":
      case "--help":
        args.help = true;
        break;
      default:
        if (!token.startsWith("-") && args.text === null && args.textFiles.length === 0) {
          args.text = token;
        } else {
          console.error(`Unknown argument: ${token}`);
          args.help = true;
        }
    }
  }
  return args;
}

async function resolveText(args: CliArgs): Promise<string> {
  if (args.text && args.textFiles.length === 0) return args.text;
  if (args.textFiles.length > 0) {
    const parts: string[] = [];
    if (args.text) parts.push(args.text);
    for (const file of args.textFiles) {
      parts.push(await readFile(file, "utf8"));
    }
    return parts.join("\n\n").trim();
  }
  throw new ConfigError("No text provided. Use --text or --textfiles.");
}

function detectProvider(explicit: Provider | null): Provider {
  if (explicit) {
    if (!KNOWN_PROVIDERS.includes(explicit)) {
      throw new ConfigError(`Unknown provider: ${explicit}. Known: ${KNOWN_PROVIDERS.join(", ")}`);
    }
    return explicit;
  }
  if (process.env.OPENAI_API_KEY) return "openai";
  if (process.env.ELEVENLABS_API_KEY) return "elevenlabs";
  if (process.env.DASHSCOPE_API_KEY) return "bailian";
  if (process.env.MINIMAX_API_KEY) return "minimax";
  if (process.env.SILICONFLOW_API_KEY) return "siliconflow";
  if (process.env.PLAYHT_USER_ID && process.env.PLAYHT_API_KEY) return "playht";
  throw new ConfigError(
    "No provider selected and no audio-capable API key detected. Pass --provider or set one of the env vars listed in --help."
  );
}

async function loadProvider(provider: Provider): Promise<ProviderModule> {
  const mod = (await import(`./providers/${provider}.ts`)) as ProviderModule;
  if (typeof mod.defaultModel !== "function" || typeof mod.generate !== "function") {
    throw new ConfigError(`Provider module '${provider}' missing required exports.`);
  }
  return mod;
}

async function run(argv: string[]): Promise<number> {
  const args = parseArgs(argv);

  if (args.help) {
    printUsage();
    return 0;
  }
  if (args.setup) {
    await printSetupGuide();
    return 0;
  }
  if (!args.outputPath) {
    console.error("--out is required (output file path).");
    printUsage();
    return 2;
  }

  const text = await resolveText(args);
  const provider = detectProvider(args.provider);
  const mod = await loadProvider(provider);
  const model = args.model ?? mod.defaultModel();
  if (!args.voice) args.voice = mod.defaultVoice();
  if (!args.format) args.format = inferFormatFromPath(args.outputPath);

  const bytes = await mod.generate(text, model, args);
  await writeBytesToFile(bytes, args.outputPath);

  const kind = validateAudioMagic(bytes);
  if (args.json) {
    console.log(
      JSON.stringify(
        {
          success: true,
          provider,
          model,
          voice: args.voice,
          output: path.resolve(args.outputPath),
          size_bytes: bytes.byteLength,
          format: kind,
        },
        null,
        2
      )
    );
  } else {
    console.log(
      `✓ Generated ${kind.toUpperCase()} (${(bytes.byteLength / 1024).toFixed(1)} KB) via ${provider}/${model} voice=${args.voice}`
    );
    console.log(`  ${path.resolve(args.outputPath)}`);
  }
  return 0;
}

run(process.argv.slice(2))
  .then((code) => process.exit(code))
  .catch((err) => {
    if (err instanceof ProviderError) {
      console.error(`[${err.provider}] ${err.message}`);
    } else if (err instanceof ConfigError) {
      console.error(`config: ${err.message}`);
    } else if (err instanceof Error) {
      console.error(err.stack || err.message);
    } else {
      console.error(String(err));
    }
    process.exit(1);
  });

import type { CliArgs } from "../types";
import { ProviderError } from "../types";
import { splitForTts } from "../utils/text_chunk";
import { concatenateBytes } from "../utils/output";

const API_BASE =
  process.env.DASHSCOPE_BASE_URL || "https://dashscope.aliyuncs.com/api/v1";

const MAX_CHARS_PER_CALL = 200; // qwen-tts family recommends <=200 Chinese chars per call

export function defaultModel(): string {
  return process.env.DASHSCOPE_TTS_MODEL || "qwen-tts";
}

export function defaultVoice(): string {
  return process.env.DASHSCOPE_TTS_VOICE || "Cherry";
}

function requireApiKey(): string {
  const key = process.env.DASHSCOPE_API_KEY;
  if (!key) {
    throw new ProviderError(
      "DASHSCOPE_API_KEY not set. Get one at https://dashscope.console.aliyun.com/apiKey",
      "bailian"
    );
  }
  return key;
}

type TtsResponse = {
  output?: {
    audio?: { data?: string; url?: string; expires_at?: number };
    finish_reason?: string;
  };
  code?: string;
  message?: string;
};

async function synthesizeOne(apiKey: string, model: string, voice: string, chunk: string): Promise<Uint8Array> {
  const body = {
    model,
    input: { text: chunk, voice },
  };
  const res = await fetch(`${API_BASE}/services/audio/tts/speech-synthesis`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const text = await res.text();
    throw new ProviderError(`Bailian TTS ${res.status}: ${text}`, "bailian");
  }

  const payload = (await res.json()) as TtsResponse;
  const audio = payload.output?.audio;
  if (!audio) {
    throw new ProviderError(
      `Bailian returned no audio: ${payload.message ?? payload.code ?? JSON.stringify(payload)}`,
      "bailian"
    );
  }
  if (audio.data) {
    return Uint8Array.from(Buffer.from(audio.data, "base64"));
  }
  if (audio.url) {
    const r = await fetch(audio.url);
    if (!r.ok) {
      throw new ProviderError(`Bailian audio download ${r.status}`, "bailian");
    }
    return new Uint8Array(await r.arrayBuffer());
  }
  throw new ProviderError("Bailian response contained no audio data or url", "bailian");
}

export async function generate(text: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();
  const voice = args.voice || defaultVoice();
  const chunks = splitForTts(text, MAX_CHARS_PER_CALL);

  const pieces: Uint8Array[] = [];
  for (const chunk of chunks) {
    pieces.push(await synthesizeOne(apiKey, model, voice, chunk));
  }

  if (pieces.length === 1) return pieces[0]!;
  // Simple byte concat. For MP3 this works for same-sample-rate segments; for higher fidelity output
  // users should split pieces into separate files and stitch with ffmpeg.
  return concatenateBytes(pieces);
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";

const API_BASE = process.env.ELEVENLABS_BASE_URL || "https://api.elevenlabs.io/v1";

export function defaultModel(): string {
  return process.env.ELEVENLABS_TTS_MODEL || "eleven_multilingual_v2";
}

export function defaultVoice(): string {
  // "Rachel" — ElevenLabs' ubiquitous default voice id
  return process.env.ELEVENLABS_VOICE || "21m00Tcm4TlvDq8ikWAM";
}

function requireApiKey(): string {
  const key = process.env.ELEVENLABS_API_KEY || process.env.ELEVEN_API_KEY;
  if (!key) {
    throw new ProviderError(
      "ELEVENLABS_API_KEY not set. Get one at https://elevenlabs.io/app/settings/api-keys",
      "elevenlabs"
    );
  }
  return key;
}

function acceptHeader(format: string | null): string {
  if (format === "wav") return "audio/wav";
  if (format === "ogg") return "audio/ogg";
  if (format === "pcm") return "audio/pcm";
  if (format === "flac") return "audio/flac";
  return "audio/mpeg"; // mp3
}

export async function generate(text: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();
  const voiceId = args.voice || defaultVoice();

  const voiceSettings: Record<string, unknown> = {};
  if (args.rate != null) voiceSettings.speed = args.rate;
  // We leave stability / similarity / style at ElevenLabs defaults.

  const body = {
    text,
    model_id: model,
    voice_settings: voiceSettings,
  };

  const res = await fetch(`${API_BASE}/text-to-speech/${encodeURIComponent(voiceId)}`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Accept: acceptHeader(args.format),
      "xi-api-key": apiKey,
    },
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const errBody = await res.text();
    throw new ProviderError(`ElevenLabs ${res.status}: ${errBody}`, "elevenlabs");
  }

  return new Uint8Array(await res.arrayBuffer());
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";

const API_BASE = process.env.MINIMAX_BASE_URL || "https://api.minimaxi.com/v1";

export function defaultModel(): string {
  return process.env.MINIMAX_TTS_MODEL || "speech-02-hd";
}

export function defaultVoice(): string {
  return process.env.MINIMAX_VOICE || "male-qn-qingse";
}

function requireApiKey(): string {
  const key = process.env.MINIMAX_API_KEY;
  if (!key) {
    throw new ProviderError(
      "MINIMAX_API_KEY not set. Get one at https://platform.minimaxi.com",
      "minimax"
    );
  }
  return key;
}

type TtsResponse = {
  data?: { audio?: string; status?: number };
  audio_file?: string;
  base_resp?: { status_code?: number; status_msg?: string };
};

function mapFormat(fmt: string | null): string {
  if (fmt === "wav") return "wav";
  if (fmt === "pcm") return "pcm";
  if (fmt === "flac") return "flac";
  return "mp3";
}

export async function generate(text: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const body: Record<string, unknown> = {
    model,
    text,
    stream: false,
    voice_setting: {
      voice_id: args.voice,
      speed: args.rate ?? 1,
      pitch: args.pitch ?? 0,
      vol: args.volume ?? 1,
    },
    audio_setting: {
      sample_rate: 32000,
      bitrate: 128000,
      format: mapFormat(args.format),
      channel: 1,
    },
  };
  if (args.language) (body as Record<string, unknown>).language_boost = args.language;

  const res = await fetch(`${API_BASE}/t2a_v2`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const errBody = await res.text();
    throw new ProviderError(`MiniMax TTS ${res.status}: ${errBody}`, "minimax");
  }

  const payload = (await res.json()) as TtsResponse;
  if (payload.base_resp && payload.base_resp.status_code && payload.base_resp.status_code !== 0) {
    throw new ProviderError(
      `MiniMax TTS ${payload.base_resp.status_code}: ${payload.base_resp.status_msg ?? "(no detail)"}`,
      "minimax"
    );
  }

  const hex = payload.data?.audio ?? payload.audio_file;
  if (!hex) {
    throw new ProviderError(`MiniMax returned no audio: ${JSON.stringify(payload)}`, "minimax");
  }
  // Payload is hex-encoded bytes.
  return Uint8Array.from(Buffer.from(hex, "hex"));
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";

const API_BASE = process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";

export function defaultModel(): string {
  return process.env.OPENAI_TTS_MODEL || "gpt-4o-mini-tts";
}

export function defaultVoice(): string {
  return process.env.OPENAI_TTS_VOICE || "alloy";
}

function requireApiKey(): string {
  const key = process.env.OPENAI_API_KEY;
  if (!key) {
    throw new ProviderError(
      "OPENAI_API_KEY not set. Get one at https://platform.openai.com/api-keys",
      "openai"
    );
  }
  return key;
}

export async function generate(text: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const body: Record<string, unknown> = {
    model,
    voice: args.voice,
    input: text,
    response_format: args.format ?? "mp3",
  };
  if (args.rate != null && args.rate > 0) body.speed = args.rate;
  if (args.instruction) body.instructions = args.instruction;

  const res = await fetch(`${API_BASE}/audio/speech`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const textBody = await res.text();
    throw new ProviderError(`OpenAI TTS ${res.status}: ${textBody}`, "openai");
  }

  const buf = await res.arrayBuffer();
  return new Uint8Array(buf);
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";

const API_BASE = process.env.PLAYHT_BASE_URL || "https://api.play.ht/api/v2";

export function defaultModel(): string {
  return process.env.PLAYHT_MODEL || "PlayHT2.0";
}

export function defaultVoice(): string {
  // A ubiquitous PlayHT voice manifest URL.
  return (
    process.env.PLAYHT_VOICE ||
    "s3://voice-cloning-zero-shot/d9ff78ba-d016-47f6-b0ef-dd630f59414e/female-cs/manifest.json"
  );
}

function requireCredentials(): { userId: string; apiKey: string } {
  const userId = process.env.PLAYHT_USER_ID;
  const apiKey = process.env.PLAYHT_API_KEY || process.env.PLAY_HT_API_KEY;
  if (!userId || !apiKey) {
    throw new ProviderError(
      "PLAYHT_USER_ID and PLAYHT_API_KEY must both be set. Get them at https://play.ht/app/api-access",
      "playht"
    );
  }
  return { userId, apiKey };
}

function mapFormat(fmt: string | null): string {
  if (fmt === "wav") return "wav";
  if (fmt === "ogg") return "ogg";
  if (fmt === "flac") return "flac";
  return "mp3";
}

export async function generate(text: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const { userId, apiKey } = requireCredentials();

  const body: Record<string, unknown> = {
    text,
    voice: args.voice,
    voice_engine: model,
    output_format: mapFormat(args.format),
  };
  if (args.rate != null) body.speed = args.rate;
  if (args.language) body.language = args.language;

  const res = await fetch(`${API_BASE}/tts/stream`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Accept: "audio/mpeg",
      Authorization: `Bearer ${apiKey}`,
      "X-USER-ID": userId,
    },
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const errBody = await res.text();
    throw new ProviderError(`PlayHT TTS ${res.status}: ${errBody}`, "playht");
  }

  return new Uint8Array(await res.arrayBuffer());
}

import type { CliArgs } from "../types";
import { ProviderError } from "../types";

const API_BASE = process.env.SILICONFLOW_BASE_URL || "https://api.siliconflow.cn/v1";

export function defaultModel(): string {
  return process.env.SILICONFLOW_TTS_MODEL || "FunAudioLLM/CosyVoice2-0.5B";
}

export function defaultVoice(): string {
  return process.env.SILICONFLOW_VOICE || "FunAudioLLM/CosyVoice2-0.5B:alex";
}

function requireApiKey(): string {
  const key = process.env.SILICONFLOW_API_KEY;
  if (!key) {
    throw new ProviderError(
      "SILICONFLOW_API_KEY not set. Get one at https://cloud.siliconflow.cn/account/ak",
      "siliconflow"
    );
  }
  return key;
}

export async function generate(text: string, model: string, args: CliArgs): Promise<Uint8Array> {
  const apiKey = requireApiKey();

  const body: Record<string, unknown> = {
    model,
    input: text,
    voice: args.voice,
    response_format: args.format ?? "mp3",
  };
  if (args.rate != null) body.speed = args.rate;
  if (args.instruction) body.instructions = args.instruction;

  const res = await fetch(`${API_BASE}/audio/speech`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify(body),
  });

  if (!res.ok) {
    const errBody = await res.text();
    throw new ProviderError(`SiliconFlow TTS ${res.status}: ${errBody}`, "siliconflow");
  }

  return new Uint8Array(await res.arrayBuffer());
}

export type Provider =
  | "openai"
  | "elevenlabs"
  | "bailian"
  | "minimax"
  | "siliconflow"
  | "playht";

export type AudioFormat = "mp3" | "wav" | "pcm" | "opus" | "ogg" | "flac";

export type CliArgs = {
  text: string | null;
  textFiles: string[];
  outputPath: string | null;
  provider: Provider | null;
  model: string | null;
  voice: string | null;
  format: AudioFormat | null;
  rate: number | null;
  pitch: number | null;
  volume: number | null;
  language: string | null;
  instruction: string | null; // voice instruction for gpt-4o-mini-tts
  pollTimeoutMs: number;
  pollIntervalMs: number;
  json: boolean;
  setup: boolean;
  help: boolean;
};

export type ExtendConfig = {
  version?: number;
  default_provider?: Provider;
  default_format?: AudioFormat;
  default_language?: string;
  default_save_dir?: string;
  default_model?: Partial<Record<Provider, string>>;
  default_voice?: Partial<Record<Provider, string>>;
  providers?: Partial<
    Record<
      Provider,
      {
        api_key_env?: string;
        api_key_source?: string;
        base_url?: string;
      }
    >
  >;
};

export type ProviderModule = {
  defaultModel: () => string;
  defaultVoice: () => string;
  generate: (text: string, model: string, args: CliArgs) => Promise<Uint8Array>;
};

export class ConfigError extends Error {
  code = "CONFIG_ERROR";
}

export class ProviderError extends Error {
  constructor(message: string, public provider: Provider) {
    super(message);
  }
  code = "PROVIDER_ERROR";
}

import path from "node:path";
import { mkdir, writeFile } from "node:fs/promises";
import type { AudioFormat } from "../types";

export async function writeBytesToFile(bytes: Uint8Array, outputPath: string): Promise<void> {
  const dir = path.dirname(outputPath);
  await mkdir(dir, { recursive: true });
  await writeFile(outputPath, bytes);
}

export function inferFormatFromPath(outputPath: string, fallback: AudioFormat = "mp3"): AudioFormat {
  const ext = path.extname(outputPath).toLowerCase().replace(/^\./, "");
  if (ext === "mp3" || ext === "wav" || ext === "pcm" || ext === "opus" || ext === "ogg" || ext === "flac") {
    return ext;
  }
  return fallback;
}

export function validateAudioMagic(bytes: Uint8Array): "mp3" | "wav" | "ogg" | "flac" | "unknown" {
  if (bytes.length < 4) return "unknown";
  // MP3: starts with ID3 or MPEG sync 0xFFEx
  if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) return "mp3";
  if (bytes[0] === 0xff && (bytes[1] === 0xfb || bytes[1] === 0xf3 || bytes[1] === 0xf2)) return "mp3";
  // WAV: RIFF....WAVE
  if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46) return "wav";
  // OGG: OggS
  if (bytes[0] === 0x4f && bytes[1] === 0x67 && bytes[2] === 0x67 && bytes[3] === 0x53) return "ogg";
  // FLAC: fLaC
  if (bytes[0] === 0x66 && bytes[1] === 0x4c && bytes[2] === 0x61 && bytes[3] === 0x43) return "flac";
  return "unknown";
}

export function concatenateBytes(parts: Uint8Array[]): Uint8Array {
  let total = 0;
  for (const p of parts) total += p.length;
  const out = new Uint8Array(total);
  let offset = 0;
  for (const p of parts) {
    out.set(p, offset);
    offset += p.length;
  }
  return out;
}

// Split long text into segments small enough for a per-call TTS limit.
// Prefer splitting on sentence boundaries (Chinese 。!? + English . ! ?).
// Falls back to hard cut at `maxChars` if no punctuation is found.

const SENTENCE_END = /([.!?。!?…\n])\s*/g;

export function splitForTts(text: string, maxChars: number): string[] {
  const trimmed = text.trim();
  if (trimmed.length <= maxChars) return [trimmed];

  const sentences: string[] = [];
  let lastIndex = 0;
  for (const match of trimmed.matchAll(SENTENCE_END)) {
    const endIndex = (match.index ?? 0) + match[0].length;
    const chunk = trimmed.slice(lastIndex, endIndex).trim();
    if (chunk.length > 0) sentences.push(chunk);
    lastIndex = endIndex;
  }
  if (lastIndex < trimmed.length) {
    const tail = trimmed.slice(lastIndex).trim();
    if (tail.length > 0) sentences.push(tail);
  }
  if (sentences.length === 0) {
    // No punctuation found — fall back to hard chunking.
    const chunks: string[] = [];
    for (let i = 0; i < trimmed.length; i += maxChars) {
      chunks.push(trimmed.slice(i, i + maxChars));
    }
    return chunks;
  }

  // Greedily pack sentences into buckets <= maxChars.
  const buckets: string[] = [];
  let current = "";
  for (const s of sentences) {
    if (s.length > maxChars) {
      if (current.length > 0) {
        buckets.push(current);
        current = "";
      }
      for (let i = 0; i < s.length; i += maxChars) {
        buckets.push(s.slice(i, i + maxChars));
      }
      continue;
    }
    if ((current + s).length <= maxChars) {
      current = current.length > 0 ? `${current} ${s}` : s;
    } else {
      buckets.push(current);
      current = s;
    }
  }
  if (current.length > 0) buckets.push(current);
  return buckets;
}