retiam 2.0.1 → 2.0.3

package/dist/libs/tts/providers/ElevenLabsTTSProvider.d.ts

@@ -0,0 +1,30 @@
+import { ITTSProvider } from './ITTSProvider';
+import { ElevenLabsTTSConfig, TTSAudioResult, TTSGenerateOptions, TTSStreamChunk, VoiceInfo } from '../core/types';
+/**
+ * Direct REST provider for browser and Node runtimes. Initialize with your API key;
+ * no Vite middleware or SDK is needed. Browser-supplied keys remain browser-visible.
+ */
+export declare class ElevenLabsTTSProvider implements ITTSProvider {
+    #private;
+    readonly name = "elevenlabs";
+    private _ready;
+    private _revision;
+    private _voices;
+    private _cache;
+    private readonly _pending;
+    private readonly _controllers;
+    get isReady(): boolean;
+    /** Validates and stores configuration locally. Does not spend credits or fetch voices. */
+    init(config?: ElevenLabsTTSConfig): Promise<void>;
+    synthesize(text: string, options?: TTSGenerateOptions): Promise<TTSAudioResult>;
+    /** Sentence-sized synthesis, matching Retiam's stream contract (not byte streaming). */
+    stream(text: string, options?: TTSGenerateOptions): AsyncGenerator<TTSStreamChunk>;
+    getVoices(): VoiceInfo[];
+    /** Fetches the authenticated, paginated voice catalog explicitly. */
+    fetchVoices(): Promise<VoiceInfo[]>;
+    clearCache(): void;
+    dispose(): Promise<void>;
+    private _assertReady;
+    private _reset;
+    private _request;
+}

package/dist/libs/tts/providers/ITTSProvider.d.ts

@@ -5,7 +5,7 @@ import { TTSAudioResult, TTSConfig, TTSGenerateOptions, TTSStreamChunk, VoiceInf
 export interface ITTSProvider {
     /** Distinct provider identifier (for example, "msedge-tts"). */
     readonly name: string;
-    /** Indicates whether the underlying neural model and session are loaded and ready. */
+    /** Indicates whether the provider is initialized for synthesis. */
     readonly isReady: boolean;
     /**
      * Initializes provider configuration and any required runtime resources.
@@ -24,7 +24,7 @@ export interface ITTSProvider {
      */
     getVoices(): VoiceInfo[];
     /**
-     * Frees WebGPU buffers and tears down the model session.
+     * Releases provider resources and cached audio.
      */
     dispose(): Promise<void>;
 }

package/dist/libs/vite/index.d.ts

@@ -0,0 +1,28 @@
+import { Plugin } from 'vite';
+export interface MsEdgeTTSPluginOptions {
+    /**
+     * Base route path for the Edge TTS endpoints.
+     * Defaults to "/api/tts/msedge".
+     */
+    basePath?: string;
+    /**
+     * Directory for persisting synthesized audio and metadata to disk.
+     * Defaults to "node_modules/.cache/msedge-tts".
+     */
+    cacheDir?: string;
+    /**
+     * Whether to log synthesis and voice fetching events in the console.
+     * Defaults to true.
+     */
+    verbose?: boolean;
+}
+/**
+ * Vite plugin that serves high-performance Microsoft Edge Text-To-Speech endpoints
+ * during development (`npm run dev`) and preview (`npm run cdn`).
+ *
+ * Provides:
+ * - `GET  /api/tts/msedge/voices`      - Live catalog of all 320+ Edge neural voices
+ * - `POST /api/tts/msedge/synthesize`  - Synthesizes text with word boundaries and MP3 audio
+ * - `GET  /api/tts/msedge/synthesize`  - Stream-friendly GET endpoint for direct HTML5 audio playback
+ */
+export declare function msEdgeTTSPlugin(options?: MsEdgeTTSPluginOptions): Plugin;

package/dist/libs/vite/index.js

@@ -0,0 +1,158 @@
+import { f as I, c as j, p as K } from "../../msEdgeV2-D3w4Xsn-.js";
+import l from "node:fs";
+import B from "node:path";
+import z from "node:crypto";
+/*! Retiam: noncommercial use only unless separately licensed. See ../../LICENSE and ../../COMMERCIAL_LICENSE.md. Third-party notices: ../../THIRD_PARTY_NOTICES.md and ../../THIRD_PARTY_LICENSES.txt. */
+const h = /* @__PURE__ */ new Map();
+function Y(P = {}) {
+  const b = (P.basePath || "/api/tts/msedge").replace(/\/$/, ""), U = P.verbose !== !1, x = async (a, e, C) => {
+    if (!a.url || !a.url.startsWith(b))
+      return C();
+    const J = a.url.split("?")[0].substring(b.length);
+    if (e.setHeader("Access-Control-Allow-Origin", "*"), e.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS"), e.setHeader("Access-Control-Allow-Headers", "Content-Type"), e.setHeader(
+      "Access-Control-Expose-Headers",
+      "X-Audio-Duration-Ms, X-Audio-Sample-Rate, X-Word-Boundaries"
+    ), a.method === "OPTIONS") {
+      e.statusCode = 204, e.end();
+      return;
+    }
+    if (J === "/voices" && a.method === "GET")
+      try {
+        const d = await I();
+        e.statusCode = 200, e.setHeader("Content-Type", "application/json; charset=utf-8"), e.setHeader("Cache-Control", "public, max-age=86400"), e.end(JSON.stringify(d));
+        return;
+      } catch (d) {
+        console.error("[MsEdge TTS Plugin] Error fetching voices:", d), e.statusCode = 502, e.end(JSON.stringify({ error: d.message }));
+        return;
+      }
+    if (J === "/synthesize") {
+      let d = "", m = "en-US-JennyNeural", g = 1, y, r;
+      if (a.method === "GET") {
+        const t = new URL(a.url, "http://localhost");
+        d = t.searchParams.get("text") || "", m = t.searchParams.get("voice") || m, g = parseFloat(t.searchParams.get("speed") || "1.0"), y = t.searchParams.get("pitch") || void 0, r = t.searchParams.get("volume") || void 0;
+      } else if (a.method === "POST")
+        try {
+          const t = await new Promise((p, n) => {
+            let u = "";
+            a.on("data", (w) => u += w), a.on("end", () => p(u)), a.on("error", n);
+          }), s = JSON.parse(t || "{}");
+          d = s.text || "", m = s.voice || m, g = typeof s.speed == "number" ? s.speed : g, y = s.pitch, r = s.volume;
+        } catch {
+          e.statusCode = 400, e.end(JSON.stringify({ error: "Invalid JSON body" }));
+          return;
+        }
+      else
+        return C();
+      const S = d.trim();
+      if (!S) {
+        e.statusCode = 400, e.end(JSON.stringify({ error: "Text cannot be empty" }));
+        return;
+      }
+      const T = `${m}_${g}_${y || ""}_${r || ""}_${S}`;
+      let c = h.get(T);
+      const M = P.cacheDir || B.resolve(process.cwd(), "node_modules/.cache/msedge-tts"), $ = z.createHash("sha256").update(T).digest("hex"), A = B.join(M, `${$}.mp3`), H = B.join(M, `${$}.json`);
+      if (!c && l.existsSync(A) && l.existsSync(H))
+        try {
+          const t = l.readFileSync(A), s = JSON.parse(l.readFileSync(H, "utf-8"));
+          c = {
+            audioBuffer: t,
+            durationMs: s.durationMs,
+            sampleRate: s.sampleRate,
+            wordBoundaries: s.wordBoundaries || []
+          }, h.set(T, c);
+        } catch {
+        }
+      if (c) {
+        e.statusCode = 200, e.setHeader("Content-Type", "audio/mpeg"), e.setHeader("X-Audio-Duration-Ms", c.durationMs.toString()), e.setHeader("X-Audio-Sample-Rate", c.sampleRate.toString()), e.setHeader(
+          "X-Word-Boundaries",
+          encodeURIComponent(JSON.stringify(c.wordBoundaries))
+        ), e.end(c.audioBuffer);
+        return;
+      }
+      try {
+        U && console.log(`[MsEdge TTS Plugin] 🎙️ Synthesizing: "${S.slice(0, 40)}..." (${m})`);
+        const t = Math.round((g - 1) * 100), p = { rate: t >= 0 ? `+${t}%` : `${t}%` };
+        if (y && (p.pitch = y), r != null && r !== "") {
+          const o = parseFloat(String(r));
+          !isNaN(o) && !String(r).includes("%") && !String(r).startsWith("+") && !String(r).startsWith("-") ? p.volume = o <= 1 && o > 0 ? Math.round(o * 100) : Math.round(o) : p.volume = r;
+        }
+        let n = null, u = [], w = null;
+        for (let o = 0; o < 3; o++)
+          try {
+            const { MsEdgeTTS: v, OUTPUT_FORMAT: N } = await import("msedge-tts");
+            j(v);
+            const D = new v();
+            await D.setMetadata(m, N.AUDIO_24KHZ_96KBITRATE_MONO_MP3, {
+              wordBoundaryEnabled: !0
+            });
+            const { audioStream: R, metadataStream: W } = D.toStream(S, p), _ = [];
+            if (u = [], W && W.on("data", (E) => {
+              try {
+                const O = JSON.parse(E.toString());
+                if (Array.isArray(O?.Metadata)) {
+                  for (const i of O.Metadata)
+                    if (i.Type === "WordBoundary" && i.Data) {
+                      const X = (i.Data.Offset || 0) / 1e4, k = (i.Data.Duration || 0) / 1e4, F = i.Data.text?.Text || "";
+                      u.push({
+                        text: F,
+                        offsetMs: X,
+                        durationMs: k,
+                        boundaryType: "WordBoundary"
+                      });
+                    }
+                }
+              } catch {
+              }
+            }), await new Promise((E, O) => {
+              R.on("data", (i) => _.push(i)), R.on("end", () => E()), R.on("error", (i) => O(i));
+            }), n = Buffer.concat(_), n.length > 0)
+              break;
+          } catch (v) {
+            w = v, await new Promise((N) => setTimeout(N, 350));
+          }
+        if (!n || n.length === 0)
+          throw w || new Error("Synthesis failed after 3 attempts.");
+        const f = K(new Uint8Array(n));
+        if (h.size > 256) {
+          const o = h.keys().next().value;
+          o && h.delete(o);
+        }
+        h.set(T, {
+          audioBuffer: n,
+          durationMs: f.durationMs,
+          sampleRate: f.sampleRate,
+          wordBoundaries: u
+        });
+        try {
+          l.existsSync(M) || l.mkdirSync(M, { recursive: !0 }), l.writeFileSync(A, n), l.writeFileSync(H, JSON.stringify({
+            durationMs: f.durationMs,
+            sampleRate: f.sampleRate,
+            wordBoundaries: u
+          }));
+        } catch {
+        }
+        e.statusCode = 200, e.setHeader("Content-Type", "audio/mpeg"), e.setHeader("X-Audio-Duration-Ms", f.durationMs.toString()), e.setHeader("X-Audio-Sample-Rate", f.sampleRate.toString()), e.setHeader(
+          "X-Word-Boundaries",
+          encodeURIComponent(JSON.stringify(u))
+        ), e.end(n);
+        return;
+      } catch (t) {
+        console.error("[MsEdge TTS Plugin] Synthesis error:", t), e.statusCode = 502, e.end(JSON.stringify({ error: t.message || "Synthesis failed" }));
+        return;
+      }
+    }
+    C();
+  };
+  return {
+    name: "msedge-tts-server-plugin",
+    configureServer(a) {
+      a.middlewares.use(x);
+    },
+    configurePreviewServer(a) {
+      a.middlewares.use(x);
+    }
+  };
+}
+export {
+  Y as msEdgeTTSPlugin
+};