@inworld/tts 0.0.0

package/dist/index.cjs

@@ -0,0 +1,1580 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  InworldTTS: () => InworldTTS,
+  InworldTTSError: () => InworldTTSError,
+  MissingApiKeyError: () => MissingApiKeyError,
+  NetworkError: () => NetworkError,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.js
+var DEFAULT_BASE_URL = "https://api.inworld.ai";
+var MAX_CHUNK_SIZE = 1900;
+var MIN_CHUNK_SIZE = 500;
+var CHARS_PER_SECOND = 12;
+var CJK_CHAR_WEIGHT = 3;
+var SPLICE_BREAK_SECONDS = 0.5;
+var SAMPLE_RATE = 48e3;
+var BITS_PER_SAMPLE = 16;
+var CHANNELS = 1;
+var MAX_CONCURRENT_REQUESTS = 2;
+var GENERATE_MAX_CHARS = 2e3;
+var STREAM_MAX_CHARS = 2e3;
+var _env = typeof process !== "undefined" ? process.env : {};
+function debugLog(config, ...args) {
+  if (config.debug || _env.DEBUG === "inworld-tts") {
+    console.debug("[inworld-tts]", ...args);
+  }
+}
+function isRetryable(e) {
+  if (e && (e.name === "AbortError" || e.name === "TimeoutError")) return false;
+  if (e && e.name === "NetworkError") return true;
+  if (e && e.name === "ApiError" && typeof e.code === "number" && e.code >= 500) return true;
+  return false;
+}
+async function withRetry(fn, config) {
+  const retries = config.maxRetries ?? 2;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    if (attempt > 0) {
+      const delay = Math.min(1e3 * 2 ** (attempt - 1), 16e3);
+      debugLog(config, `retry ${attempt}/${retries} after ${delay}ms`);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+    try {
+      return await fn();
+    } catch (e) {
+      if (!isRetryable(e) || attempt >= retries) throw e;
+      debugLog(config, `retryable error (${e.name}): ${e.message}`);
+    }
+  }
+}
+function getBaseUrl(baseUrl) {
+  const base = (baseUrl || _env.INWORLD_BASE_URL || DEFAULT_BASE_URL).replace(/\/$/, "");
+  return base;
+}
+function isRunningInBrowser() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined" && typeof navigator !== "undefined";
+}
+function getTimeoutSignal(ms) {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), ms);
+  return { signal: controller.signal, clear: () => clearTimeout(id) };
+}
+function getJwtExp(token) {
+  let exp = null;
+  try {
+    let b64 = token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
+    while (b64.length % 4) b64 += "=";
+    const payload = JSON.parse(atob(b64));
+    exp = payload.exp ?? null;
+  } catch {
+  }
+  if (exp === null) {
+    console.warn("[inworld-tts] Could not parse token expiry \u2014 token refresh will not be scheduled. Ensure token is a valid JWT.");
+  }
+  return exp;
+}
+async function ensureFreshToken(config) {
+  if (!config._token || !config._onTokenExpiring) return;
+  const exp = getJwtExp(config._token);
+  if (!exp) return;
+  const msUntilExp = exp * 1e3 - Date.now();
+  const doRefresh = () => {
+    if (config._refreshPromise) return config._refreshPromise;
+    config._refreshPromise = Promise.resolve().then(() => config._onTokenExpiring()).then((newToken) => {
+      if (!newToken || typeof newToken !== "string") {
+        console.warn("[inworld-tts] onTokenExpiring must return a non-empty string token");
+        return;
+      }
+      config._token = newToken;
+      config._authHeader = `Bearer ${newToken}`;
+    }).catch((e) => {
+      console.warn("[inworld-tts] Token refresh failed:", e.message);
+    }).finally(() => {
+      config._refreshPromise = null;
+    });
+    return config._refreshPromise;
+  };
+  if (msUntilExp <= 0) {
+    await doRefresh();
+  } else if (msUntilExp < 5 * 60 * 1e3) {
+    doRefresh();
+  }
+}
+
+// src/errors.js
+var InworldTTSError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InworldTTSError";
+  }
+};
+var MissingApiKeyError = class extends InworldTTSError {
+  constructor(message = 'INWORLD_API_KEY is not set. To fix this:\n  1. Set the environment variable: export INWORLD_API_KEY=your_key\n  2. Pass it to the constructor: InworldTTS({ apiKey: "your_key" })\n  3. Or use a JWT token: InworldTTS({ token: "your_jwt" })\n     (See: https://docs.inworld.ai/api-reference/introduction#jwt-authentication)\nGet your API key at https://platform.inworld.ai') {
+    super(message);
+    this.name = "MissingApiKeyError";
+  }
+};
+var ApiError = class extends InworldTTSError {
+  constructor(message, code = null, details = {}) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var NetworkError = class extends InworldTTSError {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+};
+
+// src/write-file.js
+async function writeFileSafe(path, data) {
+  if (typeof process === "undefined" || !process.versions?.node) {
+    throw new ApiError("outputFile is not supported in browser environments. Use the returned Uint8Array directly.");
+  }
+  const { writeFile: writeFile2 } = await import("fs/promises");
+  await writeFile2(path, data);
+}
+
+// src/player.js
+var import_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_child_process = require("child_process");
+var import_os = require("os");
+var import_path = require("path");
+
+// src/encoding.js
+function detectEncoding(audio) {
+  if (!audio || audio.length < 4) return "MP3";
+  if (audio[0] === 82 && audio[1] === 73 && audio[2] === 70 && audio[3] === 70) return "WAV";
+  if (audio[0] === 102 && audio[1] === 76 && audio[2] === 97 && audio[3] === 67) return "FLAC";
+  if (audio[0] === 79 && audio[1] === 103 && audio[2] === 103 && audio[3] === 83) return "OGG_OPUS";
+  if (audio[0] === 73 && audio[1] === 68 && audio[2] === 51) return "MP3";
+  if (audio[0] === 255 && (audio[1] & 224) === 224) return "MP3";
+  return "MP3";
+}
+
+// src/player.js
+var EXT_MAP = {
+  MP3: ".mp3",
+  OGG_OPUS: ".ogg",
+  LINEAR16: ".wav",
+  WAV: ".wav",
+  PCM: ".pcm",
+  FLAC: ".flac",
+  ALAW: ".wav",
+  MULAW: ".wav"
+};
+function scanPath(binary) {
+  const sep = process.platform === "win32" ? ";" : ":";
+  const pathDirs = (process.env.PATH || "").split(sep);
+  for (const dir of pathDirs) {
+    if (!dir) continue;
+    const full = (0, import_path.join)(dir, binary);
+    if ((0, import_fs.existsSync)(full)) return full;
+    if (process.platform === "win32" && (0, import_fs.existsSync)(full + ".exe")) return full + ".exe";
+  }
+  return null;
+}
+var FFPLAY_ARGS = ["-nodisp", "-autoexit", "-loglevel", "quiet"];
+function findPlayer(encoding) {
+  if (encoding === "PCM") {
+    process.stderr.write("[inworld-tts] PCM audio cannot be played directly. Use encoding: 'WAV' instead.\n");
+    return null;
+  }
+  const platform = process.platform;
+  const ffplay = scanPath("ffplay");
+  if (ffplay) return { binary: ffplay, args: FFPLAY_ARGS };
+  if (platform === "darwin") {
+    const afplayEncodings = ["MP3", "WAV", "FLAC", "ALAW", "MULAW"];
+    if (afplayEncodings.includes(encoding)) {
+      const afplay = scanPath("afplay");
+      if (afplay) return { binary: afplay, args: [] };
+    }
+  }
+  if (platform === "linux") {
+    if (encoding === "MP3") {
+      const mpg123 = scanPath("mpg123");
+      if (mpg123) return { binary: mpg123, args: ["-q"] };
+    }
+    if (encoding === "OGG_OPUS") {
+      const ogg123 = scanPath("ogg123");
+      if (ogg123) return { binary: ogg123, args: [] };
+    }
+    if (encoding === "WAV" || encoding === "LINEAR16") {
+      const aplay = scanPath("aplay");
+      if (aplay) return { binary: aplay, args: ["-q"] };
+    }
+  }
+  if (platform === "win32") {
+    return { binary: "cmd", args: ["/c", "start", "/wait", ""] };
+  }
+  const hint = platform === "darwin" ? "Install ffmpeg (brew install ffmpeg) or use afplay (built-in for MP3/WAV/FLAC)." : platform === "linux" ? "Install ffmpeg (apt install ffmpeg) or mpg123/ogg123/aplay for specific formats." : "Install ffmpeg to enable audio playback.";
+  process.stderr.write(`[inworld-tts] No audio player found for encoding "${encoding}". ${hint}
+`);
+  return null;
+}
+async function playFile(filePath, encoding) {
+  const player = findPlayer(encoding);
+  if (!player) return;
+  return new Promise((resolve, reject) => {
+    const args = [...player.args, filePath];
+    const proc = (0, import_child_process.spawn)(player.binary, args, { stdio: "ignore" });
+    proc.on("close", () => resolve());
+    proc.on("error", reject);
+  });
+}
+async function play(audio, options = {}) {
+  if (typeof audio === "string") {
+    const ext2 = audio.split(".").pop().toLowerCase();
+    const EXT_TO_ENCODING = { mp3: "MP3", wav: "WAV", ogg: "OGG_OPUS", flac: "FLAC", pcm: "PCM" };
+    const encoding2 = options.encoding ? options.encoding.toUpperCase() : EXT_TO_ENCODING[ext2] || "MP3";
+    return playFile(audio, encoding2);
+  }
+  const encoding = options.encoding ? options.encoding.toUpperCase() : detectEncoding(audio);
+  const ext = EXT_MAP[encoding] || ".mp3";
+  const tmpPath = (0, import_path.join)((0, import_os.tmpdir)(), `inworld-tts-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
+  await (0, import_promises.writeFile)(tmpPath, audio);
+  try {
+    await playFile(tmpPath, encoding);
+  } finally {
+    await (0, import_promises.unlink)(tmpPath).catch(() => {
+    });
+  }
+}
+
+// src/client.js
+function base64ToBytes(b64) {
+  if (typeof Buffer !== "undefined") return Buffer.from(b64, "base64");
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function concatBytes(arrays) {
+  if (typeof Buffer !== "undefined") return Buffer.concat(arrays);
+  const total = arrays.reduce((n, a) => n + a.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+}
+function _countCjk(text) {
+  return text?.match(/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/g)?.length ?? 0;
+}
+function estimateEffectiveLength(text, charsPerSecond = CHARS_PER_SECOND) {
+  const breakPattern = /<break\s+time="([\d.]+)(m?s)"\s*\/?>/gi;
+  let totalBreakSeconds = 0;
+  let m;
+  while ((m = breakPattern.exec(text)) !== null) {
+    const val = parseFloat(m[1]);
+    if (!isNaN(val)) totalBreakSeconds += m[2].toLowerCase() === "ms" ? val / 1e3 : val;
+  }
+  const textWithoutBreaks = text.replace(/<break\s[^>]*\/?>/gi, "");
+  const cjkCount = _countCjk(textWithoutBreaks);
+  const rawLength = textWithoutBreaks.length - cjkCount + Math.floor(cjkCount * CJK_CHAR_WEIGHT);
+  return rawLength + Math.floor(totalBreakSeconds * charsPerSecond);
+}
+function findBreakPoint(text, minPos, maxPos) {
+  const searchText = text.slice(0, maxPos);
+  let searchStart = minPos;
+  for (; ; ) {
+    const idx = searchText.indexOf("\n\n", searchStart);
+    if (idx === -1 || idx >= maxPos) break;
+    if (idx >= minPos) return idx + 2;
+    searchStart = idx + 1;
+  }
+  searchStart = minPos;
+  for (; ; ) {
+    const idx = searchText.indexOf("\n", searchStart);
+    if (idx === -1 || idx >= maxPos) break;
+    if (idx >= minPos) return idx + 1;
+    searchStart = idx + 1;
+  }
+  const sentenceEnd = /[.!?]["']?\s+|[。！？]["']?\s*|[.!?。！？]["']?$/g;
+  let match;
+  while ((match = sentenceEnd.exec(searchText)) !== null) {
+    if (match.index >= minPos) return match.index + match[0].length;
+  }
+  sentenceEnd.lastIndex = 0;
+  let last = -1;
+  while ((match = sentenceEnd.exec(searchText)) !== null) {
+    last = match.index + match[0].length;
+  }
+  if (last > 0) return last;
+  const spaceIdx = searchText.lastIndexOf(" ");
+  return spaceIdx > 0 ? spaceIdx + 1 : maxPos;
+}
+function chunkText(text) {
+  const chunks = [];
+  let pos = 0;
+  while (pos < text.length) {
+    const rest = text.slice(pos);
+    if (estimateEffectiveLength(rest) <= MAX_CHUNK_SIZE) {
+      const s2 = rest.trim();
+      if (s2) chunks.push(s2);
+      break;
+    }
+    const candidate = rest.slice(0, MAX_CHUNK_SIZE);
+    const effLen = estimateEffectiveLength(candidate);
+    let effectiveMax, effectiveMin;
+    if (effLen > MAX_CHUNK_SIZE) {
+      const scale = MAX_CHUNK_SIZE / effLen;
+      effectiveMax = Math.max(1, Math.floor(candidate.length * scale));
+      effectiveMin = Math.max(1, Math.floor(MIN_CHUNK_SIZE * scale));
+    } else {
+      effectiveMax = MAX_CHUNK_SIZE;
+      effectiveMin = MIN_CHUNK_SIZE;
+    }
+    const end = findBreakPoint(rest, effectiveMin, effectiveMax);
+    const s = rest.slice(0, end).trim();
+    if (s) chunks.push(s);
+    pos += end;
+  }
+  return chunks;
+}
+function extractRawPcm(audioData) {
+  if (audioData.length > 44 && audioData[0] === 82 && audioData[1] === 73 && audioData[2] === 70 && audioData[3] === 70) {
+    return audioData.subarray(44);
+  }
+  return audioData;
+}
+function createSilence(seconds, sampleRate = SAMPLE_RATE) {
+  const byteRate = sampleRate * (BITS_PER_SAMPLE / 8) * CHANNELS;
+  let n = Math.floor(byteRate * seconds);
+  n -= n % 2;
+  return new Uint8Array(n);
+}
+function mergeLinear16Buffers(buffers, spliceBreak = SPLICE_BREAK_SECONDS, sampleRate = SAMPLE_RATE) {
+  if (buffers.length === 0) return new Uint8Array(0);
+  if (buffers.length === 1) return buffers[0];
+  const silence = spliceBreak > 0 ? createSilence(spliceBreak, sampleRate) : null;
+  const out = [];
+  for (let i = 0; i < buffers.length; i++) {
+    const raw = extractRawPcm(buffers[i]);
+    if (i > 0 && silence) out.push(silence);
+    out.push(raw);
+  }
+  return concatBytes(out);
+}
+function wavHeader(dataLen, sampleRate = SAMPLE_RATE) {
+  const byteRate = sampleRate * (BITS_PER_SAMPLE / 8) * CHANNELS;
+  const blockAlign = CHANNELS * (BITS_PER_SAMPLE / 8);
+  const ab = new ArrayBuffer(44);
+  const v = new DataView(ab);
+  v.setUint8(0, 82);
+  v.setUint8(1, 73);
+  v.setUint8(2, 70);
+  v.setUint8(3, 70);
+  v.setUint32(4, 36 + dataLen, true);
+  v.setUint8(8, 87);
+  v.setUint8(9, 65);
+  v.setUint8(10, 86);
+  v.setUint8(11, 69);
+  v.setUint8(12, 102);
+  v.setUint8(13, 109);
+  v.setUint8(14, 116);
+  v.setUint8(15, 32);
+  v.setUint32(16, 16, true);
+  v.setUint16(20, 1, true);
+  v.setUint16(22, CHANNELS, true);
+  v.setUint32(24, sampleRate, true);
+  v.setUint32(28, byteRate, true);
+  v.setUint16(32, blockAlign, true);
+  v.setUint16(34, BITS_PER_SAMPLE, true);
+  v.setUint8(36, 100);
+  v.setUint8(37, 97);
+  v.setUint8(38, 116);
+  v.setUint8(39, 97);
+  v.setUint32(40, dataLen, true);
+  return new Uint8Array(ab);
+}
+var VALID_ENCODINGS = ["MP3", "OGG_OPUS", "LINEAR16", "WAV", "PCM", "FLAC", "ALAW", "MULAW"];
+var ENCODING_EXTENSIONS = {
+  MP3: [".mp3"],
+  OGG_OPUS: [".ogg", ".opus"],
+  LINEAR16: [".wav"],
+  WAV: [".wav"],
+  PCM: [".pcm"],
+  FLAC: [".flac"],
+  ALAW: [".alaw"],
+  MULAW: [".mulaw"]
+};
+function warnExtensionMismatch(outputFile, encoding) {
+  const ext = outputFile.slice(outputFile.lastIndexOf(".")).toLowerCase();
+  const expected = ENCODING_EXTENSIONS[encoding];
+  if (expected && !expected.includes(ext)) {
+    console.warn(
+      `[inworld-tts] Warning: outputFile "${outputFile}" has extension "${ext}" but encoding is "${encoding}" (expected ${expected.join(" or ")}). The file will contain ${encoding} audio data.`
+    );
+  }
+}
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set([
+  "text",
+  "voice",
+  "model",
+  "encoding",
+  "sampleRate",
+  "bitRate",
+  "speakingRate",
+  "temperature",
+  "timestampType",
+  "timestampTransportStrategy",
+  "applyTextNormalization",
+  "outputFile",
+  "play"
+]);
+var RENAMED_OPTIONS = {
+  voiceId: "voice",
+  modelId: "model",
+  audioEncoding: "encoding",
+  sampleRateHertz: "sampleRate"
+};
+function parseOptions(options, defaultModelId) {
+  if (!options || typeof options !== "object") throw new ApiError("options object is required");
+  for (const key of Object.keys(options)) {
+    if (RENAMED_OPTIONS[key]) {
+      console.warn(`[inworld-tts] Warning: "${key}" has been renamed to "${RENAMED_OPTIONS[key]}". Please update your code.`);
+    } else if (!KNOWN_OPTIONS.has(key)) {
+      console.warn(`[inworld-tts] Warning: unknown option "${key}" will be ignored. Use camelCase keys (e.g. voice, encoding).`);
+    }
+  }
+  return {
+    text: options.text || "",
+    voice: (() => {
+      if (!options.voice) throw new ApiError("options.voice is required");
+      return options.voice;
+    })(),
+    model: options.model || defaultModelId,
+    encoding: (() => {
+      const enc = (options.encoding || "MP3").toUpperCase();
+      if (!VALID_ENCODINGS.includes(enc)) {
+        throw new ApiError(`encoding "${enc}" is not supported. Valid values: ${VALID_ENCODINGS.join(", ")}`);
+      }
+      return enc;
+    })(),
+    sampleRate: (() => {
+      const enc = (options.encoding || "MP3").toUpperCase();
+      if ((enc === "ALAW" || enc === "MULAW") && options.sampleRate == null) {
+        console.warn(`[inworld-tts] ${enc} only supports sampleRate 8000 \u2014 defaulting to 8000.`);
+        return 8e3;
+      }
+      return options.sampleRate ?? 48e3;
+    })(),
+    bitRate: options.bitRate ?? 128e3,
+    speakingRate: options.speakingRate ?? 1,
+    temperature: options.temperature ?? 1,
+    timestampType: options.timestampType,
+    timestampTransportStrategy: options.timestampTransportStrategy,
+    applyTextNormalization: options.applyTextNormalization === "none" ? "APPLY_TEXT_NORMALIZATION_UNSPECIFIED" : options.applyTextNormalization
+  };
+}
+function buildBody(opts, textOverride) {
+  const ac = {
+    audioEncoding: opts.encoding,
+    sampleRateHertz: opts.sampleRate,
+    speakingRate: opts.speakingRate
+  };
+  if (["MP3", "OGG_OPUS"].includes(opts.encoding)) ac.bitRate = opts.bitRate;
+  const body = {
+    text: textOverride ?? opts.text,
+    voiceId: opts.voice,
+    modelId: opts.model,
+    audioConfig: ac,
+    temperature: opts.temperature
+  };
+  if (opts.timestampType) body.timestampType = opts.timestampType;
+  if (opts.timestampTransportStrategy) body.timestampTransportStrategy = opts.timestampTransportStrategy;
+  if (opts.applyTextNormalization) body.applyTextNormalization = opts.applyTextNormalization;
+  return body;
+}
+async function generateOne(url, headers, body, signal, config = {}) {
+  const fetchOpts = { method: "POST", headers, body: JSON.stringify(body), signal };
+  let response;
+  try {
+    response = await fetch(url, fetchOpts);
+  } catch (e) {
+    if (e.name === "AbortError" || e.name === "TimeoutError") throw e;
+    throw new NetworkError(e.message);
+  }
+  if (!response.ok) {
+    let errMsg = response.statusText;
+    let details = {};
+    try {
+      details = await response.json();
+      errMsg = details.message || JSON.stringify(details);
+    } catch (_) {
+    }
+    throw new ApiError(errMsg, response.status, details);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (_) {
+    throw new ApiError("unexpected response: failed to parse JSON");
+  }
+  if (!data.audioContent) {
+    throw new ApiError("unexpected response: missing audioContent");
+  }
+  return { audio: base64ToBytes(data.audioContent), timestampInfo: data.timestampInfo ?? null };
+}
+function isEmptyTimestampInfo(ts) {
+  if (!ts) return true;
+  if (ts.wordAlignment) {
+    return !ts.wordAlignment.words || ts.wordAlignment.words.length === 0;
+  }
+  if (ts.characterAlignment) {
+    return !ts.characterAlignment.characters || ts.characterAlignment.characters.length === 0;
+  }
+  return true;
+}
+function getLastEndTime(ts) {
+  if (!ts) return 0;
+  if (ts.wordAlignment?.wordEndTimeSeconds?.length) {
+    const ends = ts.wordAlignment.wordEndTimeSeconds;
+    return ends[ends.length - 1];
+  }
+  if (ts.characterAlignment?.characterEndTimeSeconds?.length) {
+    const ends = ts.characterAlignment.characterEndTimeSeconds;
+    return ends[ends.length - 1];
+  }
+  return 0;
+}
+function extractTrailingBreakSeconds(text) {
+  const m = text.match(/<break\s+time="([\d.]+)(m?s)"\s*\/?>\s*$/i);
+  if (!m) return 0;
+  const val = parseFloat(m[1]);
+  return m[2].toLowerCase() === "ms" ? val / 1e3 : val;
+}
+function applyTimestampOffset(ts, offset) {
+  if (!ts || offset === 0) return ts ?? {};
+  const result = {};
+  if (ts.wordAlignment) {
+    result.wordAlignment = {
+      words: ts.wordAlignment.words,
+      wordStartTimeSeconds: ts.wordAlignment.wordStartTimeSeconds?.map((t) => t + offset) ?? [],
+      wordEndTimeSeconds: ts.wordAlignment.wordEndTimeSeconds?.map((t) => t + offset) ?? [],
+      phoneticDetails: ts.wordAlignment.phoneticDetails?.map((pd) => ({
+        ...pd,
+        phones: pd.phones?.map((p) => ({ ...p, startTimeSeconds: p.startTimeSeconds + offset }))
+      })) ?? []
+    };
+  }
+  if (ts.characterAlignment) {
+    result.characterAlignment = {
+      characters: ts.characterAlignment.characters,
+      characterStartTimeSeconds: ts.characterAlignment.characterStartTimeSeconds?.map((t) => t + offset) ?? [],
+      characterEndTimeSeconds: ts.characterAlignment.characterEndTimeSeconds?.map((t) => t + offset) ?? []
+    };
+  }
+  return result;
+}
+function mergeTimestampInfos(infos) {
+  const result = {};
+  const hasWord = infos.some((ts) => ts?.wordAlignment);
+  if (hasWord) {
+    const allWords = [];
+    const allWordStart = [];
+    const allWordEnd = [];
+    const allPhoneticDetails = [];
+    let runningWordCount = 0;
+    for (const ts of infos) {
+      if (!ts?.wordAlignment) continue;
+      const wa = ts.wordAlignment;
+      allWords.push(...wa.words ?? []);
+      allWordStart.push(...wa.wordStartTimeSeconds ?? []);
+      allWordEnd.push(...wa.wordEndTimeSeconds ?? []);
+      for (const pd of wa.phoneticDetails ?? []) {
+        allPhoneticDetails.push({ ...pd, wordIndex: pd.wordIndex + runningWordCount });
+      }
+      runningWordCount += wa.words?.length ?? 0;
+    }
+    result.wordAlignment = {
+      words: allWords,
+      wordStartTimeSeconds: allWordStart,
+      wordEndTimeSeconds: allWordEnd,
+      phoneticDetails: allPhoneticDetails
+    };
+  }
+  const hasChar = infos.some((ts) => ts?.characterAlignment);
+  if (hasChar) {
+    const allChars = [];
+    const allCharStart = [];
+    const allCharEnd = [];
+    for (const ts of infos) {
+      if (!ts?.characterAlignment) continue;
+      const ca = ts.characterAlignment;
+      allChars.push(...ca.characters ?? []);
+      allCharStart.push(...ca.characterStartTimeSeconds ?? []);
+      allCharEnd.push(...ca.characterEndTimeSeconds ?? []);
+    }
+    result.characterAlignment = {
+      characters: allChars,
+      characterStartTimeSeconds: allCharStart,
+      characterEndTimeSeconds: allCharEnd
+    };
+  }
+  return result;
+}
+async function generate(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const url = `${config._baseUrl}/tts/v1/voice`;
+  const { outputFile, play: shouldPlay, ...rest } = options || {};
+  const opts = parseOptions(rest, "inworld-tts-1.5-max");
+  if (!opts.text) {
+    const received = (options || {}).text;
+    const typeInfo = received === void 0 ? "undefined" : received === null ? "null" : `${typeof received} (${JSON.stringify(received)})`;
+    throw new ApiError(`options.text is required (received: ${typeInfo})`);
+  }
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? 6e4);
+  const maxConcurrent = config.maxConcurrentRequests ?? MAX_CONCURRENT_REQUESTS;
+  const spliceBreak = SPLICE_BREAK_SECONDS;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: config._authHeader
+  };
+  const generateStart = performance.now();
+  let audio;
+  try {
+    if (estimateEffectiveLength(opts.text) <= GENERATE_MAX_CHARS) {
+      let result;
+      try {
+        result = await withRetry(() => generateOne(url, headers, buildBody(opts), signal, config), config);
+      } catch (e) {
+        if (e instanceof ApiError || e instanceof NetworkError) throw e;
+        throw new NetworkError("Request timed out");
+      }
+      audio = result.audio;
+    } else {
+      const chunks = chunkText(opts.text);
+      if (chunks.length === 0) return new Uint8Array(0);
+      debugLog(config, `long text: ${chunks.length} chunks, concurrency=${Math.min(maxConcurrent, chunks.length)}`);
+      const results = new Array(chunks.length);
+      const queue = chunks.map((t, i) => ({ text: t, index: i }));
+      const concurrency = Math.min(maxConcurrent, chunks.length);
+      const ac = new AbortController();
+      signal.addEventListener("abort", () => ac.abort(signal.reason), { once: true });
+      async function worker() {
+        while (queue.length > 0) {
+          if (ac.signal.aborted) return;
+          const { text: t, index: i } = queue.shift();
+          try {
+            results[i] = await withRetry(() => generateOne(url, headers, buildBody(opts, t), ac.signal, config), config);
+          } catch (e) {
+            ac.abort(e);
+            if (e instanceof ApiError || e instanceof NetworkError) throw e;
+            throw new NetworkError("Request timed out");
+          }
+        }
+      }
+      await Promise.all(Array.from({ length: concurrency }, () => worker()));
+      const listBuffers = results.filter((r) => r?.audio instanceof Uint8Array).map((r) => r.audio);
+      if (opts.encoding === "LINEAR16" || opts.encoding === "WAV") {
+        const merged = mergeLinear16Buffers(listBuffers, spliceBreak, opts.sampleRate);
+        audio = concatBytes([wavHeader(merged.length, opts.sampleRate), merged]);
+      } else if (opts.encoding === "PCM") {
+        audio = mergeLinear16Buffers(listBuffers, spliceBreak, opts.sampleRate);
+      } else {
+        audio = concatBytes(listBuffers);
+      }
+    }
+  } finally {
+    clear();
+  }
+  debugLog(config, `generate: ${audio.length.toLocaleString()} bytes (${((performance.now() - generateStart) / 1e3).toFixed(2)}s)`);
+  if (outputFile) {
+    warnExtensionMismatch(outputFile, opts.encoding);
+    await writeFileSafe(outputFile, audio);
+  }
+  if (shouldPlay) {
+    if (outputFile) {
+      await playFile(outputFile, opts.encoding);
+    } else {
+      await play(audio, { encoding: opts.encoding });
+    }
+  }
+  return audio;
+}
+async function generateWithTimestamps(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const url = `${config._baseUrl}/tts/v1/voice`;
+  const { outputFile, play: shouldPlay, timestampType, ...rest } = options || {};
+  if (!timestampType) throw new ApiError('options.timestampType is required ("WORD" or "CHARACTER")');
+  const opts = parseOptions({ ...rest, timestampType }, "inworld-tts-1.5-max");
+  if (!opts.text) {
+    const received = (options || {}).text;
+    const typeInfo = received === void 0 ? "undefined" : received === null ? "null" : `${typeof received} (${JSON.stringify(received)})`;
+    throw new ApiError(`options.text is required (received: ${typeInfo})`);
+  }
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? 6e4);
+  const maxConcurrent = config.maxConcurrentRequests ?? MAX_CONCURRENT_REQUESTS;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: config._authHeader
+  };
+  const generateStart = performance.now();
+  let audio;
+  let timestamps;
+  try {
+    if (estimateEffectiveLength(opts.text) <= GENERATE_MAX_CHARS) {
+      let result;
+      try {
+        result = await withRetry(() => generateOne(url, headers, buildBody(opts), signal, config), config);
+      } catch (e) {
+        if (e instanceof ApiError || e instanceof NetworkError) throw e;
+        throw new NetworkError("Request timed out");
+      }
+      audio = result.audio;
+      timestamps = result.timestampInfo ?? {};
+    } else {
+      const chunks = chunkText(opts.text);
+      if (chunks.length === 0) return { audio: new Uint8Array(0), timestamps: {} };
+      debugLog(config, `generateWithTimestamps: ${chunks.length} chunks, concurrency=${Math.min(maxConcurrent, chunks.length)}`);
+      const results = new Array(chunks.length);
+      const queue = chunks.map((t, i) => ({ text: t, index: i }));
+      const concurrency = Math.min(maxConcurrent, chunks.length);
+      const ac = new AbortController();
+      signal.addEventListener("abort", () => ac.abort(signal.reason), { once: true });
+      async function worker() {
+        while (queue.length > 0) {
+          if (ac.signal.aborted) return;
+          const { text: t, index: i } = queue.shift();
+          try {
+            results[i] = await withRetry(() => generateOne(url, headers, buildBody(opts, t), ac.signal, config), config);
+          } catch (e) {
+            ac.abort(e);
+            if (e instanceof ApiError || e instanceof NetworkError) throw e;
+            throw new NetworkError("Request timed out");
+          }
+        }
+      }
+      await Promise.all(Array.from({ length: concurrency }, () => worker()));
+      const spliceGap = ["LINEAR16", "WAV", "PCM"].includes(opts.encoding) ? SPLICE_BREAK_SECONDS : 0;
+      let offset = 0;
+      const adjustedTimestamps = [];
+      const audioBuffers = [];
+      for (let i = 0; i < chunks.length; i++) {
+        const { audio: chunkAudio, timestampInfo } = results[i];
+        audioBuffers.push(chunkAudio);
+        adjustedTimestamps.push(applyTimestampOffset(timestampInfo, offset));
+        offset += getLastEndTime(timestampInfo) + extractTrailingBreakSeconds(chunks[i]) + spliceGap;
+      }
+      timestamps = mergeTimestampInfos(adjustedTimestamps);
+      if (opts.encoding === "LINEAR16" || opts.encoding === "WAV") {
+        const merged = mergeLinear16Buffers(audioBuffers, SPLICE_BREAK_SECONDS, opts.sampleRate);
+        audio = concatBytes([wavHeader(merged.length, opts.sampleRate), merged]);
+      } else if (opts.encoding === "PCM") {
+        audio = mergeLinear16Buffers(audioBuffers, SPLICE_BREAK_SECONDS, opts.sampleRate);
+      } else {
+        audio = concatBytes(audioBuffers);
+      }
+    }
+  } finally {
+    clear();
+  }
+  debugLog(config, `generateWithTimestamps: ${audio.length.toLocaleString()} bytes (${((performance.now() - generateStart) / 1e3).toFixed(2)}s)`);
+  if (outputFile) {
+    warnExtensionMismatch(outputFile, opts.encoding);
+    await writeFileSafe(outputFile, audio);
+  }
+  if (shouldPlay) {
+    if (outputFile) {
+      await playFile(outputFile, opts.encoding);
+    } else {
+      await play(audio, { encoding: opts.encoding });
+    }
+  }
+  return { audio, timestamps };
+}
+async function* stream(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const url = `${config._baseUrl}/tts/v1/voice:stream`;
+  const outputFile = options?.outputFile;
+  const shouldPlay = options?.play;
+  if (outputFile && typeof window !== "undefined") {
+    throw new ApiError("outputFile is not supported in browser environments. Use stream() to collect chunks or generate() to get a Uint8Array.");
+  }
+  const opts = parseOptions(options, "inworld-tts-1.5-mini");
+  if (!opts.text) {
+    const received = (options || {}).text;
+    const typeInfo = received === void 0 ? "undefined" : received === null ? "null" : `${typeof received} (${JSON.stringify(received)})`;
+    throw new ApiError(`options.text is required (received: ${typeInfo})`);
+  }
+  const effectiveLen = estimateEffectiveLength(opts.text);
+  if (effectiveLen > STREAM_MAX_CHARS) {
+    throw new ApiError(
+      `text exceeds ${STREAM_MAX_CHARS} character limit for stream() (effective length ${effectiveLen}, raw length ${opts.text.length}). Use generate() instead \u2014 it handles any text length automatically.`
+    );
+  }
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? 6e4);
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: config._authHeader
+  };
+  const body = buildBody(opts);
+  const fetchOpts = { method: "POST", headers, body: JSON.stringify(body), signal };
+  const streamStart = performance.now();
+  const collectedChunks = outputFile || shouldPlay ? [] : null;
+  try {
+    let res;
+    try {
+      res = await withRetry(async () => {
+        let r;
+        try {
+          r = await fetch(url, fetchOpts);
+        } catch (e) {
+          if (e.name === "AbortError" || e.name === "TimeoutError") throw e;
+          throw new NetworkError(e.message);
+        }
+        if (r.status >= 500) {
+          const details = await r.json().catch(() => ({}));
+          throw new ApiError(details.message || r.statusText, r.status, details);
+        }
+        return r;
+      }, config);
+    } catch (e) {
+      if (e instanceof ApiError || e instanceof NetworkError) throw e;
+      throw new NetworkError("Request timed out");
+    }
+    if (!res.ok) {
+      let errMsg = res.statusText;
+      let details = {};
+      try {
+        details = await res.json();
+        errMsg = details.message || JSON.stringify(details);
+      } catch (_) {
+        errMsg = await res.text().catch(() => `HTTP ${res.status}`);
+      }
+      throw new ApiError(errMsg, res.status, details);
+    }
+    const resBody = res.body;
+    if (!resBody) throw new ApiError("empty response body");
+    const reader = resBody.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    let chunkCount = 0;
+    let firstChunkMs = null;
+    let totalBytes = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split("\n");
+        buf = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const data = JSON.parse(line);
+            const result = data.result;
+            if (result && result.audioContent) {
+              const chunk = base64ToBytes(result.audioContent);
+              if (firstChunkMs === null) firstChunkMs = performance.now() - streamStart;
+              chunkCount++;
+              totalBytes += chunk.length;
+              debugLog(config, `stream chunk #${chunkCount} (${chunk.length} bytes)`);
+              if (collectedChunks) collectedChunks.push(chunk);
+              yield chunk;
+            }
+          } catch (_) {
+          }
+        }
+      }
+      if (buf.trim()) {
+        try {
+          const data = JSON.parse(buf);
+          const result = data.result;
+          if (result && result.audioContent) {
+            const chunk = base64ToBytes(result.audioContent);
+            if (firstChunkMs === null) firstChunkMs = performance.now() - streamStart;
+            chunkCount++;
+            totalBytes += chunk.length;
+            debugLog(config, `stream chunk #${chunkCount} (${chunk.length} bytes)`);
+            if (collectedChunks) collectedChunks.push(chunk);
+            yield chunk;
+          }
+        } catch (_) {
+        }
+      }
+      if (chunkCount > 0) {
+        debugLog(config, `stream: first chunk ${Math.round(firstChunkMs)}ms, ${chunkCount} chunks, ${totalBytes.toLocaleString()} bytes total`);
+      }
+    } finally {
+      reader.releaseLock?.();
+    }
+  } finally {
+    clear();
+  }
+  if (collectedChunks) {
+    const audio = concatBytes(collectedChunks);
+    const enc = (opts.encoding || "MP3").toUpperCase();
+    if (outputFile) {
+      warnExtensionMismatch(outputFile, enc);
+      await writeFileSafe(outputFile, audio);
+      if (shouldPlay) await playFile(outputFile, enc);
+    } else {
+      await play(audio, { encoding: enc });
+    }
+  }
+}
+async function* streamWithTimestamps(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const url = `${config._baseUrl}/tts/v1/voice:stream`;
+  const { timestampType, outputFile, play: shouldPlay, ...rest } = options || {};
+  if (!timestampType) throw new ApiError('options.timestampType is required ("WORD" or "CHARACTER")');
+  if (outputFile && typeof window !== "undefined") {
+    throw new ApiError("outputFile is not supported in browser environments.");
+  }
+  const opts = parseOptions({ ...rest, timestampType }, "inworld-tts-1.5-mini");
+  if (!opts.text) {
+    const received = (options || {}).text;
+    const typeInfo = received === void 0 ? "undefined" : received === null ? "null" : `${typeof received} (${JSON.stringify(received)})`;
+    throw new ApiError(`options.text is required (received: ${typeInfo})`);
+  }
+  const effectiveLen = estimateEffectiveLength(opts.text);
+  if (effectiveLen > STREAM_MAX_CHARS) {
+    throw new ApiError(
+      `text exceeds ${STREAM_MAX_CHARS} character limit for streamWithTimestamps() (effective length ${effectiveLen}, raw length ${opts.text.length}). Use generateWithTimestamps() instead.`
+    );
+  }
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? 6e4);
+  const headers = { "Content-Type": "application/json", Authorization: config._authHeader };
+  const body = buildBody(opts);
+  body.timestampTransportStrategy = "SYNC";
+  const fetchOpts = { method: "POST", headers, body: JSON.stringify(body), signal };
+  const streamStart = performance.now();
+  const collectedChunks = outputFile || shouldPlay ? [] : null;
+  try {
+    let res;
+    try {
+      res = await withRetry(async () => {
+        let r;
+        try {
+          r = await fetch(url, fetchOpts);
+        } catch (e) {
+          if (e.name === "AbortError" || e.name === "TimeoutError") throw e;
+          throw new NetworkError(e.message);
+        }
+        if (r.status >= 500) {
+          const details = await r.json().catch(() => ({}));
+          throw new ApiError(details.message || r.statusText, r.status, details);
+        }
+        return r;
+      }, config);
+    } catch (e) {
+      if (e instanceof ApiError || e instanceof NetworkError) throw e;
+      throw new NetworkError("Request timed out");
+    }
+    if (!res.ok) {
+      let errMsg = res.statusText;
+      let details = {};
+      try {
+        details = await res.json();
+        errMsg = details.message || JSON.stringify(details);
+      } catch (_) {
+        errMsg = await res.text().catch(() => `HTTP ${res.status}`);
+      }
+      throw new ApiError(errMsg, res.status, details);
+    }
+    const resBody = res.body;
+    if (!resBody) throw new ApiError("empty response body");
+    const reader = resBody.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    let chunkCount = 0;
+    let firstChunkMs = null;
+    const processChunk = function* (line) {
+      if (!line.trim()) return;
+      try {
+        const data = JSON.parse(line);
+        const result = data.result;
+        if (result && result.audioContent) {
+          const chunk = base64ToBytes(result.audioContent);
+          if (firstChunkMs === null) firstChunkMs = performance.now() - streamStart;
+          chunkCount++;
+          debugLog(config, `streamWithTimestamps chunk #${chunkCount} (${chunk.length} bytes)`);
+          if (collectedChunks) collectedChunks.push(chunk);
+          const ts = result.timestampInfo;
+          if (isEmptyTimestampInfo(ts)) {
+            yield { audio: chunk };
+          } else {
+            yield { audio: chunk, timestamps: ts };
+          }
+        }
+      } catch (_) {
+      }
+    };
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        const lines = buf.split("\n");
+        buf = lines.pop() || "";
+        for (const line of lines) yield* processChunk(line);
+      }
+      if (buf.trim()) yield* processChunk(buf);
+      if (chunkCount > 0) {
+        debugLog(config, `streamWithTimestamps: first chunk ${Math.round(firstChunkMs)}ms, ${chunkCount} chunks total`);
+      }
+    } finally {
+      reader.releaseLock?.();
+    }
+  } finally {
+    clear();
+  }
+  if (collectedChunks) {
+    const audio = concatBytes(collectedChunks);
+    const enc = (opts.encoding || "MP3").toUpperCase();
+    if (outputFile) {
+      warnExtensionMismatch(outputFile, enc);
+      await writeFileSafe(outputFile, audio);
+      if (shouldPlay) await playFile(outputFile, enc);
+    } else {
+      await play(audio, { encoding: enc });
+    }
+  }
+}
+
+// src/voice.js
+var VOICES_PATH = "/voices/v1/voices";
+function bytesToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return (Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes)).toString("base64");
+  }
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+  return btoa(bin);
+}
+var DEFAULT_TIMEOUT = {
+  listVoices: 3e4,
+  cloneVoice: 3e5,
+  designVoice: 12e4,
+  publishVoice: 3e4,
+  migrateAudio: 6e4
+};
+function authHeader(authValue) {
+  return { Authorization: authValue };
+}
+function jsonHeaders(authValue) {
+  return { "Content-Type": "application/json", Authorization: authValue };
+}
+async function parseErrorResponse(response) {
+  let errMsg = response.statusText;
+  let details = {};
+  try {
+    details = await response.json();
+    errMsg = details.message || JSON.stringify(details);
+  } catch (_) {
+  }
+  return new ApiError(errMsg, response.status, details);
+}
+async function fetchWithRetry(url, fetchOpts, config) {
+  try {
+    return await withRetry(async () => {
+      let res;
+      try {
+        res = await fetch(url, fetchOpts);
+      } catch (e) {
+        if (e.name === "AbortError" || e.name === "TimeoutError") throw e;
+        throw new NetworkError(e.message);
+      }
+      if (!res.ok) throw await parseErrorResponse(res);
+      return res;
+    }, config);
+  } catch (e) {
+    if (e.name === "AbortError" || e.name === "TimeoutError") throw new NetworkError("Request timed out");
+    throw e;
+  }
+}
+async function listVoices(options = {}, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const url = new URL(`${config._baseUrl}${VOICES_PATH}`);
+  if (options.languages && !options.lang) {
+    console.warn('[inworld-tts] Warning: "languages" has been renamed to "lang". Please update your code.');
+  }
+  const langs = options.lang ?? options.languages;
+  if (langs) {
+    const arr = Array.isArray(langs) ? langs : [langs];
+    for (const l of arr) url.searchParams.append("languages", l);
+  }
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.listVoices);
+  try {
+    const fetchOpts = { method: "GET", headers: authHeader(config._authHeader), signal };
+    const res = await fetchWithRetry(url.toString(), fetchOpts, config);
+    let data;
+    try {
+      data = await res.json();
+    } catch (_) {
+      throw new ApiError("unexpected response: failed to parse JSON");
+    }
+    if (!Array.isArray(data.voices)) {
+      throw new ApiError('unexpected response: missing "voices" array');
+    }
+    return data.voices;
+  } finally {
+    clear();
+  }
+}
+async function cloneVoice(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const url = `${config._baseUrl}${VOICES_PATH}:clone`;
+  const rawSamples = options.audioSamples || [];
+  if (rawSamples.length === 0) throw new ApiError("options.audioSamples is required (array of Uint8Array / Buffer / file path strings)");
+  if (options.langCode && !options.lang) {
+    console.warn('[inworld-tts] Warning: "langCode" has been renamed to "lang". Please update your code.');
+  }
+  const samples = await Promise.all(rawSamples.map(async (s, i) => {
+    if (typeof s === "string") {
+      let readFileSync;
+      try {
+        ({ readFileSync } = await import("fs"));
+      } catch {
+        throw new ApiError(`options.audioSamples[${i}] is a file path string, but file system access is not available in browser. Pass Uint8Array contents instead.`);
+      }
+      return readFileSync(s);
+    }
+    if (!(s instanceof Uint8Array)) {
+      throw new ApiError(`options.audioSamples[${i}] must be a Uint8Array, Buffer, or file path string (got ${typeof s})`);
+    }
+    return s;
+  }));
+  const voiceSamples = samples.map((buf, i) => {
+    const sample = { audioData: bytesToBase64(buf) };
+    if (options.transcriptions && i < options.transcriptions.length) {
+      sample.transcription = options.transcriptions[i];
+    }
+    return sample;
+  });
+  const body = {
+    displayName: options.displayName || "Cloned Voice",
+    langCode: options.lang || options.langCode || "EN_US",
+    voiceSamples
+  };
+  if (options.description) body.description = options.description;
+  if (options.tags && options.tags.length) body.tags = options.tags;
+  if (options.removeBackgroundNoise) body.audioProcessingConfig = { removeBackgroundNoise: true };
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.cloneVoice);
+  try {
+    const fetchOpts = { method: "POST", headers: jsonHeaders(config._authHeader), body: JSON.stringify(body), signal };
+    const res = await fetchWithRetry(url, fetchOpts, config);
+    try {
+      return await res.json();
+    } catch (_) {
+      throw new ApiError("unexpected response: failed to parse JSON");
+    }
+  } finally {
+    clear();
+  }
+}
+async function designVoice(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const url = `${config._baseUrl}${VOICES_PATH}:design`;
+  const prompt = options.designPrompt || "";
+  if (prompt.length < 30 || prompt.length > 250) {
+    throw new ApiError(`designPrompt must be 30-250 characters (got ${prompt.length})`);
+  }
+  if (!options.previewText) throw new ApiError("options.previewText is required");
+  if (options.langCode && !options.lang) {
+    console.warn('[inworld-tts] Warning: "langCode" has been renamed to "lang". Please update your code.');
+  }
+  const body = {
+    designPrompt: prompt,
+    previewText: options.previewText,
+    langCode: options.lang || options.langCode || "EN_US",
+    voiceDesignConfig: { numberOfSamples: Math.min(3, Math.max(1, options.numberOfSamples || 1)) }
+  };
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.designVoice);
+  try {
+    const fetchOpts = { method: "POST", headers: jsonHeaders(config._authHeader), body: JSON.stringify(body), signal };
+    const res = await fetchWithRetry(url, fetchOpts, config);
+    try {
+      return await res.json();
+    } catch (_) {
+      throw new ApiError("unexpected response: failed to parse JSON");
+    }
+  } finally {
+    clear();
+  }
+}
+async function publishVoice(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const voiceId = options.voice;
+  if (!voiceId) throw new ApiError("options.voice is required");
+  const url = `${config._baseUrl}${VOICES_PATH}/${encodeURIComponent(voiceId)}:publish`;
+  const body = {};
+  if (options.displayName) body.displayName = options.displayName;
+  if (options.description) body.description = options.description;
+  if (options.tags && options.tags.length) body.tags = options.tags;
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.publishVoice);
+  try {
+    const fetchOpts = { method: "POST", headers: jsonHeaders(config._authHeader), body: JSON.stringify(body), signal };
+    const res = await fetchWithRetry(url, fetchOpts, config);
+    try {
+      return await res.json();
+    } catch (_) {
+      throw new ApiError("unexpected response: failed to parse JSON");
+    }
+  } finally {
+    clear();
+  }
+}
+async function getVoice(voiceId, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  if (!voiceId) throw new ApiError("voiceId is required");
+  const url = `${config._baseUrl}${VOICES_PATH}/${encodeURIComponent(voiceId)}`;
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.listVoices);
+  try {
+    const fetchOpts = { method: "GET", headers: authHeader(config._authHeader), signal };
+    const res = await fetchWithRetry(url, fetchOpts, config);
+    try {
+      return await res.json();
+    } catch (_) {
+      throw new ApiError("unexpected response: failed to parse JSON");
+    }
+  } finally {
+    clear();
+  }
+}
+async function updateVoice(options, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const voiceId = options.voice;
+  if (!voiceId) throw new ApiError("options.voice is required");
+  const url = `${config._baseUrl}${VOICES_PATH}/${encodeURIComponent(voiceId)}`;
+  const body = {};
+  if (options.displayName != null) body.displayName = options.displayName;
+  if (options.description != null) body.description = options.description;
+  if (options.tags != null) body.tags = options.tags;
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.publishVoice);
+  try {
+    const fetchOpts = { method: "PATCH", headers: jsonHeaders(config._authHeader), body: JSON.stringify(body), signal };
+    const res = await fetchWithRetry(url, fetchOpts, config);
+    try {
+      return await res.json();
+    } catch (_) {
+      throw new ApiError("unexpected response: failed to parse JSON");
+    }
+  } finally {
+    clear();
+  }
+}
+async function deleteVoice(voiceId, config = {}) {
+  if (!config._authHeader) throw new MissingApiKeyError();
+  if (!voiceId) throw new ApiError("voiceId is required");
+  const url = `${config._baseUrl}${VOICES_PATH}/${encodeURIComponent(voiceId)}`;
+  const { signal, clear } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.publishVoice);
+  try {
+    const fetchOpts = { method: "DELETE", headers: authHeader(config._authHeader), signal };
+    await fetchWithRetry(url, fetchOpts, config);
+  } finally {
+    clear();
+  }
+}
+var LANG_TO_INWORLD = {
+  en: "EN_US",
+  zh: "ZH_CN",
+  ja: "JA_JP",
+  ko: "KO_KR",
+  es: "ES_ES",
+  fr: "FR_FR",
+  de: "DE_DE",
+  pt: "PT_BR",
+  it: "IT_IT",
+  pl: "PL_PL",
+  ru: "RU_RU",
+  hi: "HI_IN",
+  ar: "AR_SA",
+  nl: "NL_NL",
+  he: "HE_IL"
+};
+function buildWavHeader(dataLen, sampleRate, channels, bitsPerSample) {
+  const buf = new ArrayBuffer(44);
+  const view = new DataView(buf);
+  const writeUint32LE = (off, v) => view.setUint32(off, v, true);
+  const writeUint16LE = (off, v) => view.setUint16(off, v, true);
+  view.setUint8(0, 82);
+  view.setUint8(1, 73);
+  view.setUint8(2, 70);
+  view.setUint8(3, 70);
+  writeUint32LE(4, 36 + dataLen);
+  view.setUint8(8, 87);
+  view.setUint8(9, 65);
+  view.setUint8(10, 86);
+  view.setUint8(11, 69);
+  view.setUint8(12, 102);
+  view.setUint8(13, 109);
+  view.setUint8(14, 116);
+  view.setUint8(15, 32);
+  writeUint32LE(16, 16);
+  writeUint16LE(20, 1);
+  writeUint16LE(22, channels);
+  writeUint32LE(24, sampleRate);
+  writeUint32LE(28, sampleRate * channels * (bitsPerSample >> 3));
+  writeUint16LE(32, channels * (bitsPerSample >> 3));
+  writeUint16LE(34, bitsPerSample);
+  view.setUint8(36, 100);
+  view.setUint8(37, 97);
+  view.setUint8(38, 116);
+  view.setUint8(39, 97);
+  writeUint32LE(40, dataLen);
+  return new Uint8Array(buf);
+}
+function trimWavTo15s(bytes) {
+  if (bytes[0] !== 82 || bytes[1] !== 73 || bytes[2] !== 70 || bytes[3] !== 70) {
+    return bytes;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const sampleRate = view.getUint32(24, true);
+  const channels = view.getUint16(22, true);
+  const bitsPerSample = view.getUint16(34, true);
+  let dataOffset = 12;
+  while (dataOffset + 8 <= bytes.length) {
+    const id = String.fromCharCode(bytes[dataOffset], bytes[dataOffset + 1], bytes[dataOffset + 2], bytes[dataOffset + 3]);
+    const chunkSize = view.getUint32(dataOffset + 4, true);
+    if (id === "data") {
+      dataOffset += 8;
+      break;
+    }
+    dataOffset += 8 + chunkSize;
+  }
+  const pcm = bytes.slice(dataOffset);
+  const maxDataBytes = Math.floor(15 * sampleRate * channels * (bitsPerSample >> 3));
+  if (pcm.length <= maxDataBytes) return bytes;
+  const trimmedPcm = pcm.slice(0, maxDataBytes);
+  const header = buildWavHeader(trimmedPcm.length, sampleRate, channels, bitsPerSample);
+  const result = new Uint8Array(header.length + trimmedPcm.length);
+  result.set(header, 0);
+  result.set(trimmedPcm, header.length);
+  return result;
+}
+var MP3_BITRATES = [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320];
+function findMp3FrameSync(bytes, startOffset) {
+  for (let i = startOffset; i < bytes.length - 1; i++) {
+    if (bytes[i] === 255 && (bytes[i + 1] & 224) === 224) return i;
+  }
+  return -1;
+}
+function trimMp3To15s(bytes) {
+  const firstSync = findMp3FrameSync(bytes, 0);
+  if (firstSync < 0) return bytes;
+  const b1 = bytes[firstSync + 1];
+  const b2 = bytes[firstSync + 2];
+  const mpegVersion = b1 >> 3 & 3;
+  const layer = b1 >> 1 & 3;
+  if (layer !== 1) return bytes;
+  const bitrateIdx = b2 >> 4 & 15;
+  if (bitrateIdx === 0 || bitrateIdx === 15) return bytes;
+  const bitrateKbps = MP3_BITRATES[bitrateIdx];
+  const estimatedBytes = Math.floor(15 * bitrateKbps * 1e3 / 8);
+  if (bytes.length <= estimatedBytes) return bytes;
+  const cutPos = findMp3FrameSync(bytes, estimatedBytes);
+  const actualCut = cutPos > firstSync ? cutPos : estimatedBytes;
+  return bytes.slice(0, actualCut);
+}
+function trimAudioTo15s(bytes) {
+  if (bytes.length === 0) return bytes;
+  if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70) {
+    return trimWavTo15s(bytes);
+  }
+  const mp3Sync = findMp3FrameSync(bytes, 0);
+  if (mp3Sync >= 0 && mp3Sync < 4) {
+    return trimMp3To15s(bytes);
+  }
+  return bytes;
+}
+async function migrateFromElevenLabs({ elevenLabsApiKey, elevenLabsVoiceId } = {}, config = {}) {
+  if (!elevenLabsApiKey) throw new ApiError("elevenLabsApiKey is required");
+  if (!elevenLabsVoiceId) throw new ApiError("elevenLabsVoiceId is required");
+  const voiceId = elevenLabsVoiceId;
+  if (!config._authHeader) throw new MissingApiKeyError();
+  const { signal: metaSignal, clear: clearMeta } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.listVoices);
+  let meta;
+  try {
+    const metaRes = await fetch(
+      `https://api.elevenlabs.io/v1/voices/${encodeURIComponent(voiceId)}`,
+      { headers: { "xi-api-key": elevenLabsApiKey }, signal: metaSignal }
+    );
+    if (!metaRes.ok) {
+      const err = await metaRes.json().catch(() => ({}));
+      const msg = (typeof err.detail === "string" ? err.detail : err.detail?.message) || err.message || metaRes.statusText;
+      throw new ApiError(`ElevenLabs get voice failed: ${msg}`, metaRes.status, err);
+    }
+    meta = await metaRes.json();
+  } finally {
+    clearMeta();
+  }
+  const voiceName = meta.name;
+  const rawLang = (meta.labels?.language || "en").toLowerCase().split(/[-_]/)[0];
+  const inworldLang = LANG_TO_INWORLD[rawLang] ?? "EN_US";
+  const { signal: audioSignal, clear: clearAudio } = getTimeoutSignal(config.timeout ?? DEFAULT_TIMEOUT.migrateAudio);
+  let audioBytes;
+  try {
+    const samples = meta.samples;
+    if (samples && samples.length > 0) {
+      const sampleId = samples[0].sample_id;
+      const sampleRes = await fetch(
+        `https://api.elevenlabs.io/v1/voices/${encodeURIComponent(voiceId)}/samples/${encodeURIComponent(sampleId)}/audio`,
+        { headers: { "xi-api-key": elevenLabsApiKey }, signal: audioSignal }
+      );
+      if (!sampleRes.ok) {
+        const err = await sampleRes.json().catch(() => ({}));
+        const msg = (typeof err.detail === "string" ? err.detail : err.detail?.message) || err.message || sampleRes.statusText;
+        throw new ApiError(`ElevenLabs get sample audio failed: ${msg}`, sampleRes.status, err);
+      }
+      audioBytes = new Uint8Array(await sampleRes.arrayBuffer());
+    } else if (meta.preview_url) {
+      const previewRes = await fetch(meta.preview_url, { signal: audioSignal });
+      if (!previewRes.ok) {
+        throw new ApiError(`ElevenLabs fetch preview_url failed: ${previewRes.statusText}`, previewRes.status);
+      }
+      audioBytes = new Uint8Array(await previewRes.arrayBuffer());
+    } else {
+      throw new ApiError("No voice samples or preview_url available for this ElevenLabs voice");
+    }
+  } finally {
+    clearAudio();
+  }
+  audioBytes = trimAudioTo15s(audioBytes);
+  const cloneResult = await cloneVoice(
+    { displayName: voiceName, audioSamples: [audioBytes], lang: inworldLang },
+    config
+  );
+  const inworldVoiceId = cloneResult.voice?.voiceId;
+  if (!inworldVoiceId) throw new ApiError("unexpected Inworld clone response: missing voiceId");
+  return { elevenLabsVoiceId: voiceId, elevenLabsName: voiceName, inworldVoiceId };
+}
+
+// src/index.js
+function createClient(opts = {}) {
+  const token = opts.token ?? null;
+  const env = typeof process !== "undefined" ? process.env?.INWORLD_API_KEY : null;
+  const apiKey = token ? null : opts.apiKey ?? env ?? null;
+  if (opts.token && opts.apiKey) {
+    console.warn("[inworld-tts] Both token and apiKey provided \u2014 apiKey will be ignored");
+  }
+  if (opts.onTokenExpiring && !token) {
+    console.warn("[inworld-tts] onTokenExpiring is ignored when no token is provided");
+  }
+  if (!token && apiKey && isRunningInBrowser()) {
+    if (!opts.dangerouslyAllowBrowser) {
+      throw new InworldTTSError(
+        "Running in browser with API key is disabled by default. Your API key would be exposed to end users.\nRecommended: use a JWT token instead: createClient({ token: 'your_jwt' })\nSee: https://docs.inworld.ai/api-reference/introduction#jwt-authentication\nOr to opt in anyway: createClient({ apiKey: '...', dangerouslyAllowBrowser: true })"
+      );
+    }
+    console.warn("[inworld-tts] dangerouslyAllowBrowser is set. Your API key is visible to anyone using browser DevTools and can be used to make requests at your expense.");
+  }
+  if (!apiKey && !token) throw new MissingApiKeyError();
+  const config = {
+    _baseUrl: getBaseUrl(opts.baseUrl ?? null),
+    _authHeader: token ? `Bearer ${token}` : `Basic ${apiKey}`,
+    _token: token,
+    _onTokenExpiring: token && opts.onTokenExpiring ? opts.onTokenExpiring : null,
+    _refreshPromise: null,
+    timeout: opts.timeout ?? null,
+    maxConcurrentRequests: opts.maxConcurrentRequests,
+    maxRetries: opts.maxRetries ?? 2,
+    debug: opts.debug ?? false
+  };
+  return {
+    async generate(options) {
+      await ensureFreshToken(config);
+      return generate(options, config);
+    },
+    async *stream(options) {
+      await ensureFreshToken(config);
+      yield* stream(options, config);
+    },
+    async generateWithTimestamps(options) {
+      await ensureFreshToken(config);
+      return generateWithTimestamps(options, config);
+    },
+    async *streamWithTimestamps(options) {
+      await ensureFreshToken(config);
+      yield* streamWithTimestamps(options, config);
+    },
+    async listVoices(options) {
+      await ensureFreshToken(config);
+      return listVoices(options, config);
+    },
+    async getVoice(voice) {
+      await ensureFreshToken(config);
+      return getVoice(voice, config);
+    },
+    async updateVoice(options) {
+      await ensureFreshToken(config);
+      return updateVoice(options, config);
+    },
+    async deleteVoice(voice) {
+      await ensureFreshToken(config);
+      return deleteVoice(voice, config);
+    },
+    async cloneVoice(options) {
+      await ensureFreshToken(config);
+      return cloneVoice(options, config);
+    },
+    async designVoice(options) {
+      await ensureFreshToken(config);
+      return designVoice(options, config);
+    },
+    async publishVoice(options) {
+      await ensureFreshToken(config);
+      return publishVoice(options, config);
+    },
+    async migrateFromElevenLabs(options) {
+      await ensureFreshToken(config);
+      return migrateFromElevenLabs(options, config);
+    },
+    async play(audio, options) {
+      return play(audio, options);
+    }
+  };
+}
+function InworldTTS(opts = {}) {
+  return createClient(opts);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  InworldTTS,
+  InworldTTSError,
+  MissingApiKeyError,
+  NetworkError,
+  createClient
+});