@cartesia/cartesia-js 0.0.4-alpha.0 → 1.0.0-alpha.2

package/dist/react/index.cjs

@@ -1,15 +1,14 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __knownSymbol = (name, symbol) => {
-  return (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -22,6 +21,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -43,6 +43,28 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -63,26 +85,30 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 
 // src/react/index.ts
 var react_exports = {};
 __export(react_exports, {
-  useAudio: () => useAudio
+  useTTS: () => useTTS
 });
 module.exports = __toCommonJS(react_exports);
 var import_react = require("react");
 
-// src/audio/index.ts
-var import_emittery = __toESM(require("emittery"), 1);
-var import_human_id = require("human-id");
-var import_partysocket = require("partysocket");
+// src/lib/client.ts
+var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 
 // src/lib/constants.ts
-var BASE_URL = "https://api.cartesia.ai/v0";
-var SAMPLE_RATE = 44100;
-var constructWebsocketUrl = (baseUrl) => {
-  return new URL(`${baseUrl.replace(/^http/, "ws")}/audio/websocket`);
+var BASE_URL = "https://api.cartesia.ai/";
+var CARTESIA_VERSION = "2024-06-10";
+var constructApiUrl = (baseUrl, path, protocol) => {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  if (!protocol) {
+    return new URL(`${baseUrl}${normalizedPath}`);
+  }
+  if (!["http", "ws"].includes(protocol)) {
+    throw new Error(`Invalid protocol: ${protocol}`);
+  }
+  return new URL(`${baseUrl.replace(/^http/, protocol)}${normalizedPath}`);
 };
 
 // src/lib/client.ts
@@ -94,37 +120,167 @@ var Client = class {
     this.apiKey = options.apiKey || process.env.CARTESIA_API_KEY;
     this.baseUrl = options.baseUrl || BASE_URL;
   }
+  fetch(path, options = {}) {
+    const url = constructApiUrl(this.baseUrl, path);
+    return (0, import_cross_fetch.default)(url.toString(), __spreadProps(__spreadValues({}, options), {
+      headers: __spreadValues({
+        "X-API-Key": this.apiKey,
+        "Cartesia-Version": CARTESIA_VERSION
+      }, options.headers)
+    }));
+  }
+};
+
+// src/tts/websocket.ts
+var import_emittery2 = __toESM(require("emittery"), 1);
+var import_human_id = require("human-id");
+var import_partysocket = require("partysocket");
+
+// src/tts/source.ts
+var import_emittery = __toESM(require("emittery"), 1);
+var _emitter, _buffer, _readIndex, _writeIndex, _closed, _sampleRate;
+var Source = class {
+  /**
+   * Create a new Source.
+   *
+   * @param options - Options for the Source.
+   * @param options.sampleRate - The sample rate of the audio.
+   */
+  constructor({ sampleRate }) {
+    __privateAdd(this, _emitter, new import_emittery.default());
+    __privateAdd(this, _buffer, void 0);
+    __privateAdd(this, _readIndex, 0);
+    __privateAdd(this, _writeIndex, 0);
+    __privateAdd(this, _closed, false);
+    __privateAdd(this, _sampleRate, void 0);
+    this.on = __privateGet(this, _emitter).on.bind(__privateGet(this, _emitter));
+    this.once = __privateGet(this, _emitter).once.bind(__privateGet(this, _emitter));
+    this.events = __privateGet(this, _emitter).events.bind(__privateGet(this, _emitter));
+    this.off = __privateGet(this, _emitter).off.bind(__privateGet(this, _emitter));
+    __privateSet(this, _sampleRate, sampleRate);
+    __privateSet(this, _buffer, new Float32Array(1024));
+  }
+  get sampleRate() {
+    return __privateGet(this, _sampleRate);
+  }
+  /**
+   * Append audio to the buffer.
+   *
+   * @param src The audio to append.
+   */
+  enqueue(src) {
+    return __async(this, null, function* () {
+      const requiredCapacity = __privateGet(this, _writeIndex) + src.length;
+      if (requiredCapacity > __privateGet(this, _buffer).length) {
+        let newCapacity = __privateGet(this, _buffer).length;
+        while (newCapacity < requiredCapacity) {
+          newCapacity *= 2;
+        }
+        const newBuffer = new Float32Array(newCapacity);
+        newBuffer.set(__privateGet(this, _buffer));
+        __privateSet(this, _buffer, newBuffer);
+      }
+      __privateGet(this, _buffer).set(src, __privateGet(this, _writeIndex));
+      __privateSet(this, _writeIndex, __privateGet(this, _writeIndex) + src.length);
+      yield __privateGet(this, _emitter).emit("enqueue");
+    });
+  }
+  /**
+   * Read audio from the buffer.
+   *
+   * @param dst The buffer to read the audio into.
+   * @returns The number of samples read. If the source is closed, this will be
+   * less than the length of the provided buffer.
+   */
+  read(dst) {
+    return __async(this, null, function* () {
+      const targetReadIndex = __privateGet(this, _readIndex) + dst.length;
+      while (!__privateGet(this, _closed) && targetReadIndex > __privateGet(this, _writeIndex)) {
+        yield __privateGet(this, _emitter).emit("wait");
+        yield Promise.race([
+          __privateGet(this, _emitter).once("enqueue"),
+          __privateGet(this, _emitter).once("close")
+        ]);
+        yield __privateGet(this, _emitter).emit("read");
+      }
+      const read = Math.min(dst.length, __privateGet(this, _writeIndex) - __privateGet(this, _readIndex));
+      dst.set(__privateGet(this, _buffer).subarray(__privateGet(this, _readIndex), __privateGet(this, _readIndex) + read));
+      __privateSet(this, _readIndex, __privateGet(this, _readIndex) + read);
+      return read;
+    });
+  }
+  /**
+   * Get the number of samples in a given duration.
+   *
+   * @param durationSecs The duration in seconds.
+   * @returns The number of samples.
+   */
+  durationToSampleCount(durationSecs) {
+    return Math.trunc(durationSecs * __privateGet(this, _sampleRate));
+  }
+  get buffer() {
+    return __privateGet(this, _buffer);
+  }
+  get readIndex() {
+    return __privateGet(this, _readIndex);
+  }
+  /**
+   * Close the source. This signals that no more audio will be enqueued.
+   *
+   * This will emit a "close" event.
+   *
+   * @returns A promise that resolves when the source is closed.
+   */
+  close() {
+    return __async(this, null, function* () {
+      __privateSet(this, _closed, true);
+      yield __privateGet(this, _emitter).emit("close");
+      __privateGet(this, _emitter).clearListeners();
+    });
+  }
 };
+_emitter = new WeakMap();
+_buffer = new WeakMap();
+_readIndex = new WeakMap();
+_writeIndex = new WeakMap();
+_closed = new WeakMap();
+_sampleRate = new WeakMap();
 
-// src/audio/utils.ts
+// src/tts/utils.ts
 var import_base64_js = __toESM(require("base64-js"), 1);
-function getBufferDuration(b64) {
-  const floats = base64ToArray(b64);
-  return floats.length / SAMPLE_RATE;
-}
 function base64ToArray(b64) {
-  return filterSentinel(b64).reduce((acc, b) => {
-    const floats = new Float32Array(import_base64_js.default.toByteArray(b).buffer);
-    const newAcc = new Float32Array(acc.length + floats.length);
-    newAcc.set(acc, 0);
-    newAcc.set(floats, acc.length);
-    return newAcc;
-  }, new Float32Array(0));
+  const byteArrays = filterSentinel(b64).map((b) => import_base64_js.default.toByteArray(b));
+  const totalLength = byteArrays.reduce(
+    (acc, arr) => acc + arr.length / Float32Array.BYTES_PER_ELEMENT,
+    0
+  );
+  const result = new Float32Array(totalLength);
+  let offset = 0;
+  for (const arr of byteArrays) {
+    const floats = new Float32Array(arr.buffer);
+    result.set(floats, offset);
+    offset += floats.length;
+  }
+  return result;
 }
-function playAudioBuffer(b64, context, maybeStartAt = null, onEnded = null) {
-  const startAt = maybeStartAt != null ? maybeStartAt : context.currentTime;
-  const floats = base64ToArray(b64);
+function playAudioBuffer(floats, context, startAt, sampleRate) {
   const source = context.createBufferSource();
-  const buffer = context.createBuffer(1, floats.length, SAMPLE_RATE);
+  const buffer = context.createBuffer(1, floats.length, sampleRate);
   buffer.getChannelData(0).set(floats);
   source.buffer = buffer;
   source.connect(context.destination);
   source.start(startAt);
-  source.onended = onEnded;
-  return buffer.duration;
+  return new Promise((resolve) => {
+    source.onended = () => {
+      resolve();
+    };
+  });
 }
 function createMessageHandlerForContextId(contextId, handler) {
   return (event) => {
+    if (typeof event.data !== "string") {
+      return;
+    }
     const message = JSON.parse(event.data);
     if (message.context_id !== contextId) {
       return;
@@ -135,7 +291,7 @@ function createMessageHandlerForContextId(contextId, handler) {
     } else {
       chunk = message.data;
     }
-    handler({ chunk, message });
+    handler({ chunk, message: event.data });
   };
 }
 function getSentinel() {
@@ -149,9 +305,6 @@ function filterSentinel(collection) {
     (x) => !isSentinel(x)
   );
 }
-function isComplete(chunks) {
-  return isSentinel(chunks[chunks.length - 1]);
-}
 function getEmitteryCallbacks(emitter) {
   return {
     on: emitter.on.bind(emitter),
@@ -160,91 +313,76 @@ function getEmitteryCallbacks(emitter) {
     events: emitter.events.bind(emitter)
   };
 }
-function bufferToWav(sampleRate, channelBuffers) {
-  const totalSamples = channelBuffers[0].length * channelBuffers.length;
-  const buffer = new ArrayBuffer(44 + totalSamples * 2);
-  const view = new DataView(buffer);
-  const writeString = (view2, offset2, string) => {
-    for (let i = 0; i < string.length; i++) {
-      view2.setUint8(offset2 + i, string.charCodeAt(i));
-    }
-  };
-  writeString(view, 0, "RIFF");
-  view.setUint32(4, 36 + totalSamples * 2, true);
-  writeString(view, 8, "WAVE");
-  writeString(view, 12, "fmt ");
-  view.setUint32(16, 16, true);
-  view.setUint16(20, 1, true);
-  view.setUint16(22, channelBuffers.length, true);
-  view.setUint32(24, sampleRate, true);
-  view.setUint32(28, sampleRate * 4, true);
-  view.setUint16(32, channelBuffers.length * 2, true);
-  view.setUint16(34, 16, true);
-  writeString(view, 36, "data");
-  view.setUint32(40, totalSamples * 2, true);
-  let offset = 44;
-  for (let i = 0; i < channelBuffers[0].length; i++) {
-    for (let channel = 0; channel < channelBuffers.length; channel++) {
-      const s = Math.max(-1, Math.min(1, channelBuffers[channel][i]));
-      view.setInt16(offset, s < 0 ? s * 32768 : s * 32767, true);
-      offset += 2;
-    }
-  }
-  return buffer;
-}
 
-// src/audio/index.ts
-var audio_default = class extends Client {
-  constructor() {
-    super(...arguments);
-    this.isConnected = false;
+// src/tts/websocket.ts
+var _isConnected, _sampleRate2, _generateId, generateId_fn;
+var WebSocket = class extends Client {
+  /**
+   * Create a new WebSocket client.
+   *
+   * @param args - Arguments to pass to the Client constructor.
+   */
+  constructor({ sampleRate }, ...args) {
+    super(...args);
+    /**
+     * Generate a unique ID suitable for a streaming context.
+     *
+     * Not suitable for security purposes or as a primary key, since
+     * it lacks the amount of entropy required for those use cases.
+     *
+     * @returns A unique ID.
+     */
+    __privateAdd(this, _generateId);
+    __privateAdd(this, _isConnected, false);
+    __privateAdd(this, _sampleRate2, void 0);
+    __privateSet(this, _sampleRate2, sampleRate);
   }
   /**
-   * Stream audio from a model.
+   * Send a message over the WebSocket in order to start a stream.
    *
-   * @param inputs - Stream options. Includes a `model` key and some `parameters`, which
-   * are model-specific and can be found in the model's documentation.
+   * @param inputs - Stream options.
    * @param options - Options for the stream.
    * @param options.timeout - The maximum time to wait for a chunk before cancelling the stream.
    * If `0`, the stream will not time out.
-   * @returns An object with a method `play` of type `(bufferDuration: number) => Promise<void>`
-   * that plays the audio as it arrives, with `bufferDuration` seconds of audio buffered before
-   * starting playback.
+   * @returns A Source object that can be passed to a Player to play the audio.
    */
-  stream(inputs, { timeout = 0 } = {}) {
+  send(inputs, { timeout = 0 } = {}) {
     var _a, _b, _c, _d;
-    if (!this.isConnected) {
+    if (!__privateGet(this, _isConnected)) {
       throw new Error("Not connected to WebSocket. Call .connect() first.");
     }
-    const contextId = this.generateId();
+    const contextId = __privateMethod(this, _generateId, generateId_fn).call(this);
     (_a = this.socket) == null ? void 0 : _a.send(
-      JSON.stringify({
-        data: inputs,
+      JSON.stringify(__spreadProps(__spreadValues({
         context_id: contextId
-      })
+      }, inputs), {
+        output_format: {
+          container: "raw",
+          encoding: "pcm_f32le",
+          sample_rate: __privateGet(this, _sampleRate2)
+        }
+      }))
     );
+    const emitter = new import_emittery2.default();
+    const source = new Source({
+      sampleRate: __privateGet(this, _sampleRate2)
+    });
     const streamCompleteController = new AbortController();
     let timeoutId = null;
     if (timeout > 0) {
       timeoutId = setTimeout(streamCompleteController.abort, timeout);
     }
-    const chunks = [];
-    const emitter = new import_emittery.default();
     const handleMessage = createMessageHandlerForContextId(
       contextId,
       (_0) => __async(this, [_0], function* ({ chunk, message }) {
-        chunks.push(chunk);
-        yield emitter.emit("chunk", {
-          chunk,
-          chunks
-        });
-        yield emitter.emit("message", message);
+        emitter.emit("message", message);
         if (isSentinel(chunk)) {
-          yield emitter.emit("streamed", {
-            chunks
-          });
+          yield source.close();
           streamCompleteController.abort();
-        } else if (timeoutId) {
+          return;
+        }
+        yield source.enqueue(base64ToArray([chunk]));
+        if (timeoutId) {
           clearTimeout(timeoutId);
           timeoutId = setTimeout(streamCompleteController.abort, timeout);
         }
@@ -272,107 +410,12 @@ var audio_default = class extends Client {
       }
     );
     streamCompleteController.signal.addEventListener("abort", () => {
+      source.close();
       if (timeoutId) {
         clearTimeout(timeoutId);
       }
-      emitter.clearListeners();
-    });
-    const play = (_0) => __async(this, [_0], function* ({ bufferDuration }) {
-      const context = new AudioContext({
-        sampleRate: SAMPLE_RATE
-      });
-      let startNextPlaybackAt = 0;
-      const playLatestChunk = (chunk) => {
-        if (isSentinel(chunk)) {
-          return true;
-        }
-        startNextPlaybackAt = playAudioBuffer([chunk], context, startNextPlaybackAt) + Math.max(context.currentTime, startNextPlaybackAt);
-        return false;
-      };
-      const playChunks = (chunks2) => {
-        startNextPlaybackAt += playAudioBuffer(
-          chunks2,
-          context,
-          startNextPlaybackAt
-        );
-        if (isComplete(chunks2)) {
-          return;
-        }
-      };
-      const tryStart = (chunks2) => __async(this, null, function* () {
-        startNextPlaybackAt = context.currentTime;
-        if (isComplete(chunks2) || streamCompleteController.signal.aborted) {
-          emitter.emit("buffered");
-          playChunks(chunks2);
-          return true;
-        }
-        if (getBufferDuration(chunks2) > bufferDuration) {
-          emitter.emit("buffered");
-          playChunks(chunks2);
-          try {
-            for (var iter2 = __forAwait(emitter.events("chunk")), more2, temp2, error2; more2 = !(temp2 = yield iter2.next()).done; more2 = false) {
-              const { chunk } = temp2.value;
-              if (playLatestChunk(chunk)) {
-                break;
-              }
-            }
-          } catch (temp2) {
-            error2 = [temp2];
-          } finally {
-            try {
-              more2 && (temp2 = iter2.return) && (yield temp2.call(iter2));
-            } finally {
-              if (error2)
-                throw error2[0];
-            }
-          }
-          return true;
-        }
-        emitter.emit("buffering");
-        return false;
-      });
-      if (!(yield tryStart(chunks))) {
-        try {
-          for (var iter = __forAwait(emitter.events("chunk")), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
-            const { chunks: chunks2 } = temp.value;
-            if (yield tryStart(chunks2)) {
-              const playbackEndsIn = Math.max(0, startNextPlaybackAt - context.currentTime) * 1e3;
-              emitter.emit("scheduled", { playbackEndsIn });
-              break;
-            }
-          }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield temp.call(iter));
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-      } else {
-        const playbackEndsIn = Math.max(0, startNextPlaybackAt - context.currentTime) * 1e3;
-        emitter.emit("scheduled", { playbackEndsIn });
-      }
-    });
-    return __spreadValues({
-      play
-    }, getEmitteryCallbacks(emitter));
-  }
-  /**
-   * Generate a unique ID suitable for a streaming context.
-   *
-   * Not suitable for security purposes or as a primary key, since
-   * it lacks the amount of entropy required for those use cases.
-   *
-   * @returns A unique ID.
-   */
-  generateId() {
-    return (0, import_human_id.humanId)({
-      separator: "-",
-      capitalize: false
     });
+    return __spreadValues({ source }, getEmitteryCallbacks(emitter));
   }
   /**
    * Authenticate and connect to a Cartesia streaming WebSocket.
@@ -381,16 +424,20 @@ var audio_default = class extends Client {
    * @throws {Error} If the WebSocket fails to connect.
    */
   connect() {
-    const url = constructWebsocketUrl(this.baseUrl);
+    const url = constructApiUrl(
+      this.baseUrl,
+      `/tts/websocket?cartesia_version=${CARTESIA_VERSION}`,
+      "ws"
+    );
     url.searchParams.set("api_key", this.apiKey);
-    const emitter = new import_emittery.default();
+    const emitter = new import_emittery2.default();
     this.socket = new import_partysocket.WebSocket(url.toString());
     this.socket.onopen = () => {
-      this.isConnected = true;
+      __privateSet(this, _isConnected, true);
       emitter.emit("open");
     };
     this.socket.onclose = () => {
-      this.isConnected = false;
+      __privateSet(this, _isConnected, false);
       emitter.emit("close");
     };
     return new Promise(
@@ -437,6 +484,192 @@ var audio_default = class extends Client {
     (_a = this.socket) == null ? void 0 : _a.close();
   }
 };
+_isConnected = new WeakMap();
+_sampleRate2 = new WeakMap();
+_generateId = new WeakSet();
+generateId_fn = function() {
+  return (0, import_human_id.humanId)({
+    separator: "-",
+    capitalize: false
+  });
+};
+
+// src/tts/index.ts
+var TTS = class extends Client {
+  /**
+   * Get a WebSocket client for streaming audio from the TTS API.
+   *
+   * @returns {WebSocket} A Cartesia WebSocket client.
+   */
+  websocket(options) {
+    return new WebSocket(options, {
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl
+    });
+  }
+};
+
+// src/voices/index.ts
+var Voices = class extends Client {
+  list() {
+    return __async(this, null, function* () {
+      const response = yield this.fetch("/voices");
+      return response.json();
+    });
+  }
+  get(voiceId) {
+    return __async(this, null, function* () {
+      const response = yield this.fetch(`/voices/${voiceId}`);
+      return response.json();
+    });
+  }
+  create(voice) {
+    return __async(this, null, function* () {
+      const response = yield this.fetch("/voices", {
+        method: "POST",
+        body: JSON.stringify(voice)
+      });
+      return response.json();
+    });
+  }
+  clone(options) {
+    return __async(this, null, function* () {
+      if (options.mode === "url") {
+        const response = yield this.fetch(
+          `/voices/clone/url?link=${options.link}`,
+          {
+            method: "POST"
+          }
+        );
+        return response.json();
+      }
+      if (options.mode === "clip") {
+        const formData = new FormData();
+        formData.append("clip", options.clip);
+        const response = yield this.fetch("/voices/clone/clip", {
+          method: "POST",
+          body: formData
+        });
+        return response.json();
+      }
+      throw new Error("Invalid mode for clone()");
+    });
+  }
+};
+
+// src/lib/index.ts
+var Cartesia = class extends Client {
+  constructor(options = {}) {
+    super(options);
+    this.tts = new TTS(options);
+    this.voices = new Voices(options);
+  }
+};
+
+// src/tts/player.ts
+var import_emittery3 = __toESM(require("emittery"), 1);
+var _context, _startNextPlaybackAt, _bufferDuration, _emitter2, _playBuffer, playBuffer_fn;
+var Player = class {
+  /**
+   * Create a new Player.
+   *
+   * @param options - Options for the Player.
+   * @param options.bufferDuration - The duration of the audio buffer to play.
+   */
+  constructor({ bufferDuration }) {
+    __privateAdd(this, _playBuffer);
+    __privateAdd(this, _context, null);
+    __privateAdd(this, _startNextPlaybackAt, 0);
+    __privateAdd(this, _bufferDuration, void 0);
+    __privateAdd(this, _emitter2, new import_emittery3.default());
+    __privateSet(this, _bufferDuration, bufferDuration);
+  }
+  /**
+   * Play audio from a source.
+   *
+   * @param source The source to play audio from.
+   * @returns A promise that resolves when the audio has finished playing.
+   */
+  play(source) {
+    return __async(this, null, function* () {
+      __privateSet(this, _startNextPlaybackAt, 0);
+      __privateSet(this, _context, new AudioContext({ sampleRate: source.sampleRate }));
+      const buffer = new Float32Array(
+        source.durationToSampleCount(__privateGet(this, _bufferDuration))
+      );
+      const plays = [];
+      while (true) {
+        const read = yield source.read(buffer);
+        const playableAudio = buffer.subarray(0, read);
+        plays.push(__privateMethod(this, _playBuffer, playBuffer_fn).call(this, playableAudio, source.sampleRate));
+        if (read < buffer.length) {
+          yield __privateGet(this, _emitter2).emit("finish");
+          break;
+        }
+      }
+      yield Promise.all(plays);
+    });
+  }
+  /**
+   * Pause the audio.
+   *
+   * @returns A promise that resolves when the audio has been paused.
+   */
+  pause() {
+    return __async(this, null, function* () {
+      if (!__privateGet(this, _context)) {
+        throw new Error("AudioContext not initialized.");
+      }
+      yield __privateGet(this, _context).suspend();
+    });
+  }
+  /**
+   * Resume the audio.
+   *
+   * @returns A promise that resolves when the audio has been resumed.
+   */
+  resume() {
+    return __async(this, null, function* () {
+      if (!__privateGet(this, _context)) {
+        throw new Error("AudioContext not initialized.");
+      }
+      yield __privateGet(this, _context).resume();
+    });
+  }
+  /**
+   * Toggle the audio.
+   *
+   * @returns A promise that resolves when the audio has been toggled.
+   */
+  toggle() {
+    return __async(this, null, function* () {
+      if (!__privateGet(this, _context)) {
+        throw new Error("AudioContext not initialized.");
+      }
+      if (__privateGet(this, _context).state === "running") {
+        yield this.pause();
+      } else {
+        yield this.resume();
+      }
+    });
+  }
+};
+_context = new WeakMap();
+_startNextPlaybackAt = new WeakMap();
+_bufferDuration = new WeakMap();
+_emitter2 = new WeakMap();
+_playBuffer = new WeakSet();
+playBuffer_fn = function(buf, sampleRate) {
+  return __async(this, null, function* () {
+    if (!__privateGet(this, _context)) {
+      throw new Error("AudioContext not initialized.");
+    }
+    const startAt = __privateGet(this, _startNextPlaybackAt);
+    const duration = buf.length / sampleRate;
+    __privateSet(this, _startNextPlaybackAt, duration + Math.max(__privateGet(this, _context).currentTime, __privateGet(this, _startNextPlaybackAt)));
+    yield playAudioBuffer(buf, __privateGet(this, _context), startAt, sampleRate);
+  });
+};
 
 // src/react/utils.ts
 function pingServer(url) {
@@ -449,91 +682,125 @@ function pingServer(url) {
 }
 
 // src/react/index.ts
-function useAudio({ apiKey, baseUrl }) {
+var PING_INTERVAL = 5e3;
+var DEFAULT_BUFFER_DURATION = 0.01;
+function useTTS({
+  apiKey,
+  baseUrl,
+  sampleRate
+}) {
+  var _a, _b;
   if (typeof window === "undefined") {
     return {
-      stream: () => {
-      },
+      buffer: () => __async(this, null, function* () {
+      }),
       play: () => __async(this, null, function* () {
       }),
-      download: () => null,
+      pause: () => __async(this, null, function* () {
+      }),
+      resume: () => __async(this, null, function* () {
+      }),
+      toggle: () => __async(this, null, function* () {
+      }),
+      playbackStatus: "inactive",
+      bufferStatus: "inactive",
+      isWaiting: false,
+      source: null,
       isConnected: false,
-      isPlaying: false,
-      isStreamed: false,
-      isBuffering: false,
-      chunks: [],
-      messages: []
+      metrics: {
+        modelLatency: null
+      }
     };
   }
-  const audio = (0, import_react.useMemo)(() => {
+  const websocket = (0, import_react.useMemo)(() => {
     if (!apiKey) {
       return null;
     }
-    const audio2 = new audio_default({ apiKey, baseUrl });
-    return audio2;
-  }, [apiKey, baseUrl]);
-  const streamReturn = (0, import_react.useRef)(null);
-  const [isStreamed, setIsStreamed] = (0, import_react.useState)(false);
-  const [isPlaying, setIsPlaying] = (0, import_react.useState)(false);
-  const [isBuffering, setIsBuffering] = (0, import_react.useState)(false);
+    const cartesia = new Cartesia({ apiKey, baseUrl });
+    baseUrl = baseUrl != null ? baseUrl : cartesia.baseUrl;
+    return cartesia.tts.websocket({ sampleRate });
+  }, [apiKey, baseUrl, sampleRate]);
+  const websocketReturn = (0, import_react.useRef)(null);
+  const player = (0, import_react.useRef)(null);
+  const [playbackStatus, setPlaybackStatus] = (0, import_react.useState)("inactive");
+  const [bufferStatus, setBufferStatus] = (0, import_react.useState)("inactive");
+  const [isWaiting, setIsWaiting] = (0, import_react.useState)(false);
   const [isConnected, setIsConnected] = (0, import_react.useState)(false);
-  const [chunks, setChunks] = (0, import_react.useState)([]);
+  const [bufferDuration, setBufferDuration] = (0, import_react.useState)(null);
   const [messages, setMessages] = (0, import_react.useState)([]);
-  const latencyEndpoint = "https://api.cartesia.ai";
-  const stream = (0, import_react.useCallback)(
+  const buffer = (0, import_react.useCallback)(
     (options) => __async(this, null, function* () {
-      var _a;
-      setIsStreamed(false);
-      streamReturn.current = (_a = audio == null ? void 0 : audio.stream(options)) != null ? _a : null;
-      if (!streamReturn.current) {
+      var _a2;
+      setMessages([]);
+      setBufferStatus("buffering");
+      websocketReturn.current = (_a2 = websocket == null ? void 0 : websocket.send(options)) != null ? _a2 : null;
+      if (!websocketReturn.current) {
         return;
       }
-      setMessages([]);
-      streamReturn.current.on(
-        "chunk",
-        ({ chunks: chunks3 }) => {
-          setChunks(chunks3);
-        }
-      );
-      streamReturn.current.on(
-        "message",
-        (message) => {
-          setMessages((messages2) => [...messages2, message]);
-        }
-      );
-      const { chunks: chunks2 } = yield streamReturn.current.once("streamed");
-      setChunks(chunks2);
-      setIsStreamed(true);
+      const unsubscribe = websocketReturn.current.on("message", (message) => {
+        setMessages((messages2) => [...messages2, JSON.parse(message)]);
+      });
+      yield websocketReturn.current.source.once("close");
+      setBufferStatus("buffered");
+      unsubscribe();
     }),
-    [audio]
+    [websocket]
   );
-  const download = (0, import_react.useCallback)(() => {
-    if (!isStreamed) {
-      return null;
+  const metrics = (0, import_react.useMemo)(() => {
+    var _a2;
+    if (messages.length === 0) {
+      return {
+        modelLatency: null
+      };
     }
-    const audio2 = bufferToWav(SAMPLE_RATE, [base64ToArray(chunks)]);
-    return new Blob([audio2], { type: "audio/wav" });
-  }, [isStreamed, chunks]);
+    const modelLatency = (_a2 = messages[0].step_time) != null ? _a2 : null;
+    return {
+      modelLatency: Math.trunc(modelLatency)
+    };
+  }, [messages]);
   (0, import_react.useEffect)(() => {
     let cleanup = () => {
     };
     function setupConnection() {
       return __async(this, null, function* () {
         try {
-          const connection = yield audio == null ? void 0 : audio.connect();
+          const connection = yield websocket == null ? void 0 : websocket.connect();
           if (!connection) {
             return;
           }
+          const unsubscribes = [];
           setIsConnected(true);
-          connection.on("open", () => {
-            setIsConnected(true);
-          });
-          const unsubscribe = connection.on("close", () => {
-            setIsConnected(false);
-          });
+          unsubscribes.push(
+            connection.on("open", () => {
+              setIsConnected(true);
+            })
+          );
+          unsubscribes.push(
+            connection.on("close", () => {
+              setIsConnected(false);
+            })
+          );
+          const intervalId = setInterval(() => {
+            if (baseUrl) {
+              pingServer(new URL(baseUrl).origin).then((ping) => {
+                let bufferDuration2;
+                if (ping < 300) {
+                  bufferDuration2 = 0.01;
+                } else if (ping > 1500) {
+                  bufferDuration2 = 6;
+                } else {
+                  bufferDuration2 = ping / 1e3 * 4;
+                }
+                setBufferDuration(bufferDuration2);
+              });
+            }
+          }, PING_INTERVAL);
           return () => {
-            unsubscribe();
-            audio == null ? void 0 : audio.disconnect();
+            for (const unsubscribe of unsubscribes) {
+              unsubscribe();
+            }
+            clearInterval(intervalId);
+            websocket == null ? void 0 : websocket.disconnect();
           };
         } catch (e) {
           console.error(e);
@@ -544,54 +811,70 @@ function useAudio({ apiKey, baseUrl }) {
       cleanup = cleanupConnection;
     });
     return () => cleanup == null ? void 0 : cleanup();
-  }, [audio]);
+  }, [websocket, baseUrl]);
   const play = (0, import_react.useCallback)(() => __async(this, null, function* () {
-    var _a;
-    if (isPlaying || !streamReturn.current) {
+    if (playbackStatus === "playing" || !websocketReturn.current) {
       return;
     }
-    setIsPlaying(true);
-    const ping = yield pingServer(latencyEndpoint);
-    let bufferingTimeout;
-    let bufferDuration;
-    if (ping < 300) {
-      bufferDuration = 0;
-    } else if (ping > 1500) {
-      bufferDuration = 6;
-    } else {
-      bufferDuration = ping / 1e3 * 4;
-    }
-    streamReturn.current.once("buffering").then(() => {
-      bufferingTimeout = setTimeout(() => {
-        setIsBuffering(true);
-      }, 250);
+    setPlaybackStatus("playing");
+    const unsubscribes = [];
+    unsubscribes.push(
+      websocketReturn.current.source.on("wait", () => {
+        setIsWaiting(true);
+      })
+    );
+    unsubscribes.push(
+      websocketReturn.current.source.on("read", () => {
+        setIsWaiting(false);
+      })
+    );
+    player.current = new Player({
+      bufferDuration: bufferDuration != null ? bufferDuration : DEFAULT_BUFFER_DURATION
     });
-    streamReturn.current.once("buffered").then(() => {
-      if (bufferingTimeout) {
-        clearTimeout(bufferingTimeout);
+    yield player.current.play(websocketReturn.current.source);
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+    setPlaybackStatus("finished");
+  }), [playbackStatus, bufferDuration]);
+  const pause = (0, import_react.useCallback)(() => __async(this, null, function* () {
+    var _a2;
+    yield (_a2 = player.current) == null ? void 0 : _a2.pause();
+    setPlaybackStatus("paused");
+  }), []);
+  const resume = (0, import_react.useCallback)(() => __async(this, null, function* () {
+    var _a2;
+    yield (_a2 = player.current) == null ? void 0 : _a2.resume();
+    setPlaybackStatus("playing");
+  }), []);
+  const toggle = (0, import_react.useCallback)(() => __async(this, null, function* () {
+    var _a2;
+    yield (_a2 = player.current) == null ? void 0 : _a2.toggle();
+    setPlaybackStatus((status) => {
+      if (status === "playing") {
+        return "paused";
       }
-      setIsBuffering(false);
-    });
-    streamReturn.current.once("scheduled").then((data) => {
-      setTimeout(() => {
-        setIsPlaying(false);
-      }, data.playbackEndsIn);
+      if (status === "paused") {
+        return "playing";
+      }
+      return status;
     });
-    yield (_a = streamReturn.current) == null ? void 0 : _a.play({ bufferDuration });
-  }), [isPlaying]);
+  }), []);
   return {
-    stream,
+    buffer,
     play,
-    download,
-    isPlaying,
+    pause,
+    source: (_b = (_a = websocketReturn.current) == null ? void 0 : _a.source) != null ? _b : null,
+    resume,
+    toggle,
+    playbackStatus,
+    bufferStatus,
+    isWaiting,
     isConnected,
-    isStreamed,
-    isBuffering,
-    chunks,
-    messages
+    metrics
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  useAudio
+  useTTS
 });