speech-to-speech 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -1,27 +1,7 @@
 'use strict';
 
 var vadWeb = require('@ricky0123/vad-web');
-var piperTts = require('@realtimex/piper-tts-web');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var piperTts__namespace = /*#__PURE__*/_interopNamespace(piperTts);
+var piperTtsWeb = require('@realtimex/piper-tts-web');
 
 // src/stt/reset-stt-logic.ts
 var ResetSTTLogic = class {
@@ -557,17 +537,101 @@ var sharedAudioPlayer = {
   /** Close */
   close: () => AudioPlayer.reset()
 };
+
+// src/tts/wasm-cache.ts
+var CACHE_NAME = "stt-tts-lib-piper-wasm-v1";
+var DEFAULT_CDN_BASE = "https://cdn.jsdelivr.net/npm/@diffusionstudio/piper-wasm@1.0.0/build/piper_phonemize";
+var cachedBlobUrls = null;
+function isCacheAvailable() {
+  return typeof caches !== "undefined";
+}
+async function fetchAndCache(cache, url) {
+  const existing = await cache.match(url);
+  if (existing) {
+    const blob2 = await existing.blob();
+    return URL.createObjectURL(blob2);
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status}`);
+  }
+  const responseForCache = response.clone();
+  await cache.put(url, responseForCache);
+  const blob = await response.blob();
+  return URL.createObjectURL(blob);
+}
+async function ensureWasmCached(cdnBase = DEFAULT_CDN_BASE) {
+  if (cachedBlobUrls) return cachedBlobUrls;
+  const dataUrl = `${cdnBase}.data`;
+  const wasmUrl = `${cdnBase}.wasm`;
+  if (!isCacheAvailable()) {
+    console.log("[wasm-cache] Cache API unavailable \u2014 using CDN URLs directly");
+    cachedBlobUrls = { piperData: dataUrl, piperWasm: wasmUrl };
+    return cachedBlobUrls;
+  }
+  try {
+    const cache = await caches.open(CACHE_NAME);
+    const [piperData, piperWasm] = await Promise.all([
+      fetchAndCache(cache, dataUrl),
+      fetchAndCache(cache, wasmUrl)
+    ]);
+    cachedBlobUrls = { piperData, piperWasm };
+    console.log("[wasm-cache] WASM assets served from Cache API (blob URLs)");
+    return cachedBlobUrls;
+  } catch (err) {
+    console.warn("[wasm-cache] Caching failed, falling back to CDN URLs:", err);
+    cachedBlobUrls = { piperData: dataUrl, piperWasm: wasmUrl };
+    return cachedBlobUrls;
+  }
+}
+async function isWasmCached(cdnBase = DEFAULT_CDN_BASE) {
+  if (!isCacheAvailable()) return false;
+  try {
+    const cache = await caches.open(CACHE_NAME);
+    const [data, wasm] = await Promise.all([
+      cache.match(`${cdnBase}.data`),
+      cache.match(`${cdnBase}.wasm`)
+    ]);
+    return !!data && !!wasm;
+  } catch {
+    return false;
+  }
+}
+async function clearWasmCache() {
+  if (cachedBlobUrls) {
+    try {
+      URL.revokeObjectURL(cachedBlobUrls.piperData);
+    } catch {
+    }
+    try {
+      URL.revokeObjectURL(cachedBlobUrls.piperWasm);
+    } catch {
+    }
+    cachedBlobUrls = null;
+  }
+  if (!isCacheAvailable()) return;
+  try {
+    await caches.delete(CACHE_NAME);
+    console.log("[wasm-cache] Cache cleared");
+  } catch (err) {
+    console.warn("[wasm-cache] Failed to clear cache:", err);
+  }
+}
+
+// src/tts/piper-synthesizer.ts
 var DEFAULT_VOICE_ID = "en_US-hfc_female-medium";
 var TTSLogic = class {
   constructor(config = {}) {
     this.ready = false;
     this.voiceLoaded = false;
     this.warmUp = true;
+    this.ttsSession = null;
     this.config = {
       voiceId: DEFAULT_VOICE_ID,
       sampleRate: 22050,
       useSharedAudioPlayer: true,
       warmUp: true,
+      enableWasmCache: true,
       ...config
     };
     this.useSharedPlayer = this.config.useSharedAudioPlayer !== false;
@@ -594,10 +658,11 @@ var TTSLogic = class {
       throw new Error("Voice not loaded. Call initialize() first.");
     }
     try {
-      await piperTts__namespace.predict({
-        text,
-        voiceId: this.config.voiceId
-      });
+      if (this.ttsSession) {
+        await this.ttsSession.predict(text);
+      } else {
+        throw new Error("TtsSession not created yet");
+      }
       console.log("\u2713 Piper synthesizer warmed up");
       return { synthesized: true };
     } catch (error) {
@@ -612,11 +677,30 @@ var TTSLogic = class {
     try {
       const voiceId = this.config.voiceId;
       console.log("\u{1F4CD} Loading Piper voice:", voiceId);
-      const storedVoices = await piperTts__namespace.stored();
+      let wasmPaths;
+      if (this.config.wasmPaths) {
+        console.log("\u{1F4E6} Using custom WASM paths");
+        wasmPaths = {
+          onnxWasm: this.config.wasmPaths.onnxWasm ?? piperTtsWeb.TtsSession.WASM_LOCATIONS.onnxWasm,
+          piperData: this.config.wasmPaths.piperData,
+          piperWasm: this.config.wasmPaths.piperWasm
+        };
+      } else if (this.config.enableWasmCache !== false) {
+        console.log("\u{1F4E6} Caching WASM assets via Cache API...");
+        const cached = await ensureWasmCached(piperTtsWeb.WASM_BASE);
+        wasmPaths = {
+          onnxWasm: piperTtsWeb.TtsSession.WASM_LOCATIONS.onnxWasm,
+          piperData: cached.piperData,
+          piperWasm: cached.piperWasm
+        };
+      } else {
+        wasmPaths = { ...piperTtsWeb.TtsSession.WASM_LOCATIONS };
+      }
+      const storedVoices = await piperTtsWeb.stored();
       const alreadyCached = Array.isArray(storedVoices) ? storedVoices.includes(voiceId) : false;
       if (!alreadyCached) {
         console.log("\u2B07\uFE0F Downloading voice model...");
-        await piperTts__namespace.download(voiceId, (progress) => {
+        await piperTtsWeb.download(voiceId, (progress) => {
           if (progress?.total) {
             const pct = Math.round(progress.loaded * 100 / progress.total);
             console.log(`\u2B07\uFE0F Downloading: ${pct}%`);
@@ -625,6 +709,12 @@ var TTSLogic = class {
       } else {
         console.log("\u2713 Voice found in cache");
       }
+      this.ttsSession = new piperTtsWeb.TtsSession({
+        voiceId,
+        wasmPaths,
+        logger: (msg) => console.log(`[piper] ${msg}`)
+      });
+      await this.ttsSession.waitReady;
       this.voiceLoaded = true;
       if (this.config.warmUp) {
         const { synthesized } = await this.warmup();
@@ -660,10 +750,7 @@ var TTSLogic = class {
       throw new Error("No text provided for synthesis");
     }
     try {
-      const wavBlob = await piperTts__namespace.predict({
-        text: trimmed,
-        voiceId: this.config.voiceId
-      });
+      const wavBlob = await this.ttsSession.predict(trimmed);
       const arrayBuffer = await wavBlob.arrayBuffer();
       const audioContext = new (window.AudioContext || window.webkitAudioContext)();
       const decodedBuffer = await audioContext.decodeAudioData(arrayBuffer);
@@ -690,10 +777,7 @@ var TTSLogic = class {
     if (!trimmed) {
       throw new Error("No text provided for synthesis");
     }
-    return piperTts__namespace.predict({
-      text: trimmed,
-      voiceId: this.config.voiceId
-    });
+    return this.ttsSession.predict(trimmed);
   }
   /**
    * Synthesize text and add to queue (uses shared player by default)
@@ -717,6 +801,7 @@ var TTSLogic = class {
   async dispose() {
     this.ready = false;
     this.voiceLoaded = false;
+    this.ttsSession = null;
   }
 };
 function textToPhonemes(_text) {
@@ -1822,17 +1907,20 @@ exports.STTLogic = STTLogic;
 exports.SimpleQueue = SimpleQueue;
 exports.TTSLogic = TTSLogic;
 exports.VADController = VADController;
+exports.clearWasmCache = clearWasmCache;
 exports.configureFillerManager = configureFillerManager;
 exports.createAudioPlayer = createAudioPlayer;
 exports.createOrtEnvironment = createOrtEnvironment;
 exports.emitSentence = emitSentence;
 exports.ensureOrtReady = ensureOrtReady;
 exports.ensureVoiceLoaded = ensureVoiceLoaded;
+exports.ensureWasmCached = ensureWasmCached;
 exports.getAsyncIterator = getAsyncIterator;
 exports.getBackendLabel = getBackendLabel;
 exports.getFillerManager = getFillerManager;
 exports.handleChunk = handleChunk;
 exports.isCorruptModelError = isCorruptModelError;
+exports.isWasmCached = isWasmCached;
 exports.nextBoundaryIndex = nextBoundaryIndex;
 exports.playerWorker = playerWorker;
 exports.preparePiperVoice = preparePiperVoice;