@fraziym/axoniz 0.1.0

package/dist/web/static/js/tourHints.js

@@ -0,0 +1,179 @@
+// tourHints.js — secret continuation of /tour. The first time the user opens
+// a tool modal (after the welcome experience), surface a single "pro tip"
+// hint pointing out that modals can be snapped to the screen edge or
+// fullscreened by dragging the title bar. Shown once globally — once the
+// user has dismissed it (or it auto-hides), it never returns.
+
+const HINT_SEEN_KEY = 'zero-hint-drag-to-snap-seen';
+
+// Allow-list of modals where the snap/fullscreen hint makes sense.
+// These are the full-window "tool" modals where users commonly want to
+// reposition or fullscreen the pane (email, calendar, cookbook, gallery,
+// library, brain memories, tasks, theme, compare). Transient modals
+// like settings, prompts, rename dialogs, custom-preset picker, etc.
+// are excluded — opening those is task-focused and the snap tip would
+// be noise.
+const SHOW_MODALS = new Set([
+  'email-lib-modal',
+  'calendar-modal',
+  'compare-modal',     // not currently a real id, defensive
+  'cookbook-modal',
+  'gallery-modal',
+  'doclib-modal',
+  'library-modal',     // chat-history library (sessions.js)
+  'memory-modal',      // brain / memories
+  'tasks-modal',
+  'theme-modal',
+]);
+
+// Some modals have dynamic per-instance IDs (e.g. one window per opened
+// email). Match by prefix so any window from the same family qualifies.
+const SHOW_MODAL_PREFIXES = ['email-window-'];
+
+function _modalShouldShowHint(id) {
+  if (!id) return false;
+  if (SHOW_MODALS.has(id)) return true;
+  return SHOW_MODAL_PREFIXES.some(p => id.startsWith(p));
+}
+
+let _shown = false;
+let _initialized = false;
+
+function _hasSeen() { return localStorage.getItem(HINT_SEEN_KEY) === '1'; }
+function _markSeen() { try { localStorage.setItem(HINT_SEEN_KEY, '1'); } catch {} }
+
+function _isVisible(el) {
+  if (!el || el.classList.contains('hidden')) return false;
+  // Some modals set inline display:none rather than .hidden
+  if (el.style.display === 'none') return false;
+  const r = el.getBoundingClientRect();
+  return r.width > 0 && r.height > 0;
+}
+
+function _onModalOpened(modal) {
+  if (_shown || _hasSeen()) return;
+  const id = modal.id;
+  if (!_modalShouldShowHint(id)) return;
+  // Don't interrupt the welcome / tour itself
+  if (document.body.classList.contains('tour-active')) return;
+  if (document.getElementById('tour-tooltip')) return;
+  // Mobile: skip — snapping isn't a desktop-only feature there
+  if (window.innerWidth <= 768) return;
+
+  _shown = true;
+  // Give the modal a moment to settle (some open with their own animation).
+  setTimeout(() => _show(modal), 380);
+}
+
+function _show(modal) {
+  if (_hasSeen()) return;
+  const content = modal.querySelector('.modal-content') || modal;
+  const r = content.getBoundingClientRect();
+
+  const pop = document.createElement('div');
+  pop.className = 'tour-hint';
+  pop.innerHTML = `
+    <div class="tour-hint-visual" aria-hidden="true">
+      <svg viewBox="0 0 100 60" width="160" height="96">
+        <!-- ambient frame -->
+        <rect x="0.5" y="0.5" width="99" height="59" rx="3" fill="none" stroke="currentColor" stroke-opacity="0.18" />
+        <!-- snap-zone preview (right half) -->
+        <rect class="th-zone" x="51" y="2" width="47" height="56" rx="2" fill="currentColor" opacity="0" />
+        <!-- the modal being dragged -->
+        <g class="th-modal-group">
+          <rect x="22" y="20" width="34" height="22" rx="2.5" fill="var(--bg)" stroke="currentColor" stroke-width="1.2" />
+          <rect x="22" y="20" width="34" height="5"  rx="2.5" fill="currentColor" opacity="0.35" />
+        </g>
+        <!-- cursor -->
+        <path class="th-cursor" d="M0 0 L0 9 L2.5 7 L4.5 10 L6 9 L4 6 L7 6 Z" fill="currentColor" />
+      </svg>
+    </div>
+    <div class="tour-hint-text"><b>Pro tip:</b> drag any window's title bar to a screen edge to snap it. Drag to the top for fullscreen.</div>
+    <button class="tour-hint-dismiss" type="button">Got it</button>
+  `;
+  document.body.appendChild(pop);
+
+  // Prefer placing to the right of the modal; fall back to left, then below.
+  pop.style.opacity = '0';
+  requestAnimationFrame(() => {
+    const pw = pop.offsetWidth || 260;
+    const ph = pop.offsetHeight || 200;
+    let left = r.right + 14;
+    let top  = r.top;
+    if (left + pw > window.innerWidth - 8) {
+      left = r.left - pw - 14;
+      if (left < 8) {
+        left = Math.max(8, r.left + (r.width - pw) / 2);
+        top  = r.bottom + 14;
+        if (top + ph > window.innerHeight - 8) top = Math.max(8, r.top - ph - 14);
+      }
+    }
+    pop.style.left = left + 'px';
+    pop.style.top  = top  + 'px';
+    pop.style.opacity = '';
+    pop.classList.add('tour-hint-in');
+  });
+
+  const dismiss = () => {
+    pop.classList.add('tour-hint-out');
+    setTimeout(() => pop.remove(), 280);
+    _markSeen();
+  };
+  pop.querySelector('.tour-hint-dismiss').addEventListener('click', dismiss);
+  // Auto-dismiss after 14s so it doesn't linger forever.
+  setTimeout(() => { if (pop.isConnected) dismiss(); }, 14000);
+}
+
+function _watchModals() {
+  const observeModal = (modal) => {
+    if (!modal || modal.dataset.tourHintObserved === '1') return;
+    modal.dataset.tourHintObserved = '1';
+    observer.observe(modal, {
+      attributes: true,
+      attributeOldValue: true,
+      attributeFilter: ['class', 'style'],
+    });
+    if (_isVisible(modal)) _onModalOpened(modal);
+  };
+  const observer = new MutationObserver((muts) => {
+    if (_hasSeen() || _shown) return;
+    for (const m of muts) {
+      if (m.attributeName !== 'class' && m.attributeName !== 'style') continue;
+      const el = m.target;
+      if (!(el instanceof HTMLElement)) continue;
+      if (!el.classList.contains('modal')) continue;
+      const wasHidden = !m.oldValue || /\bhidden\b/.test(m.oldValue) || /display:\s*none/.test(m.oldValue);
+      if (wasHidden && _isVisible(el)) _onModalOpened(el);
+    }
+  });
+  document.querySelectorAll('.modal').forEach(observeModal);
+  const addObserver = new MutationObserver((muts) => {
+    if (_hasSeen() || _shown) return;
+    for (const m of muts) {
+      m.addedNodes.forEach(node => {
+        if (!(node instanceof HTMLElement)) return;
+        if (node.classList.contains('modal')) observeModal(node);
+        node.querySelectorAll?.('.modal').forEach(observeModal);
+      });
+    }
+  });
+  addObserver.observe(document.body, { childList: true, subtree: true });
+}
+
+export function init() {
+  if (_initialized) return;
+  _initialized = true;
+  if (_hasSeen()) return; // nothing to do
+  // Defer one tick so the rest of the app has a chance to mount its modals.
+  setTimeout(_watchModals, 50);
+}
+
+if (typeof window !== 'undefined') {
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+}
+
+export default { init };

package/dist/web/static/js/tts-ai.js

@@ -0,0 +1,521 @@
+// static/js/tts-ai.js
+// AI Text-to-Speech Module — supports server TTS and browser Web Speech API
+
+class AITTSManager {
+    constructor() {
+        this.currentAudio = null;
+        this.isPlaying = false;
+        this.available = false;
+        this.useBrowserTTS = false;
+        this.browserVoice = '';
+        this.playbackSpeed = 1;
+        this._provider = 'disabled';
+        this.autoPlay = false;
+        this.cache = new Map(); // Client-side audio cache
+
+        // Queue for sequential auto-play
+        this._queue = [];       // Array of { text, button, resetFn }
+        this._processing = false;
+
+        // Streaming sentence-by-sentence TTS state
+        this._streamSentencesSent = 0;  // chars of plain text already queued
+        this._streamActive = false;
+        this._streamButton = null;
+        this._streamResetFn = null;
+        this._streamDebounceTimer = null;
+
+        // Check if TTS service is available
+        this.checkAvailability();
+    }
+
+    async checkAvailability() {
+        try {
+            // Check user setting first — if TTS is disabled in settings, don't show buttons
+            try {
+                const settingsRes = await fetch('/api/auth/settings', { credentials: 'same-origin' });
+                const settings = await settingsRes.json();
+                if (settings.tts_enabled === false) {
+                    this.available = false;
+                    this._provider = 'disabled';
+                    return;
+                }
+            } catch {}
+
+            const response = await fetch('/api/tts/stats');
+            const stats = await response.json();
+            this.available = stats.available && stats.ready;
+            this.playbackSpeed = stats.speed || 1;
+            this._provider = stats.provider || 'disabled';
+
+            if (stats.provider === 'browser') {
+                this.useBrowserTTS = true;
+                this.browserVoice = stats.voice || '';
+                this.available = 'speechSynthesis' in window;
+                if (!this.available) {
+                    console.warn('TTS: browser mode selected but speechSynthesis not supported');
+                }
+            } else if (this.available) {
+                this.useBrowserTTS = false;
+            } else {
+                console.warn('TTS: not available');
+            }
+        } catch (error) {
+            console.error('Failed to check TTS availability:', error);
+            this.available = false;
+        }
+    }
+
+    extractPlainText(content) {
+        // Strip <think>/<thinking> blocks (model reasoning)
+        let cleaned = content.replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/gi, '');
+
+        // Create a temporary div to parse HTML/markdown
+        const temp = document.createElement('div');
+        temp.innerHTML = cleaned;
+
+        // Remove code blocks
+        temp.querySelectorAll('pre, code').forEach(el => el.remove());
+
+        // Get text content
+        let text = temp.textContent || temp.innerText || '';
+
+        // Clean up markdown syntax
+        text = text
+            .replace(/#{1,6}\s/g, '') // Remove headers
+            .replace(/\*\*(.+?)\*\*/g, '$1') // Remove bold
+            .replace(/\*(.+?)\*/g, '$1') // Remove italic
+            .replace(/\[(.+?)\]\(.+?\)/g, '$1') // Remove links
+            .replace(/`(.+?)`/g, '$1') // Remove inline code
+            .replace(/\n{3,}/g, '\n\n') // Normalize line breaks
+            .trim();
+
+        return text;
+    }
+
+    getCacheKey(text) {
+        // Simple hash function for cache key
+        let hash = 0;
+        for (let i = 0; i < text.length; i++) {
+            const char = text.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return hash.toString(36);
+    }
+
+    async synthesize(text, onProgress = null) {
+        if (!this.available) {
+            throw new Error('AI TTS service not available');
+        }
+
+        const plainText = this.extractPlainText(text);
+
+        if (!plainText) {
+            throw new Error('No text to synthesize');
+        }
+
+        // Browser TTS doesn't use synthesize — handled directly in play()
+        if (this.useBrowserTTS) {
+            return '__browser_tts__';
+        }
+
+        const cacheKey = this.getCacheKey(plainText);
+
+        // Check cache first
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+
+        try {
+            if (onProgress) onProgress('synthesizing');
+
+            const response = await fetch('/api/tts/synthesize', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    text: plainText,
+                    format: 'audio'
+                })
+            });
+
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.detail?.message || 'Synthesis failed');
+            }
+
+            const audioBlob = await response.blob();
+            const audioUrl = URL.createObjectURL(audioBlob);
+
+            // Cache the result
+            this.cache.set(cacheKey, audioUrl);
+
+            if (onProgress) onProgress('complete');
+
+            return audioUrl;
+
+        } catch (error) {
+            if (onProgress) onProgress('error');
+            throw error;
+        }
+    }
+
+    _findBrowserVoice() {
+        if (!this.browserVoice) return null;
+        const voices = window.speechSynthesis.getVoices();
+        const target = this.browserVoice.toLowerCase();
+        // Try exact match first, then partial
+        return voices.find(v => v.name.toLowerCase() === target) ||
+               voices.find(v => v.name.toLowerCase().includes(target)) ||
+               null;
+    }
+
+    async play(text) {
+        // Stop current audio if playing
+        this.stop();
+
+        const plainText = this.extractPlainText(text);
+        if (!plainText) return;
+
+        if (this.useBrowserTTS) {
+            return this._playBrowser(plainText);
+        }
+
+        try {
+            const audioUrl = await this.synthesize(text);
+
+            this.currentAudio = new Audio(audioUrl);
+            await this.currentAudio.play();
+            this.isPlaying = true;
+            // Note: onended should be set by the caller (addAITTSButton)
+            // to reset button state when audio finishes
+
+        } catch (error) {
+            console.error('Failed to play audio:', error);
+            throw error;
+        }
+    }
+
+    _playBrowser(plainText) {
+        return new Promise((resolve, reject) => {
+            const utterance = new SpeechSynthesisUtterance(plainText);
+            const voice = this._findBrowserVoice();
+            if (voice) utterance.voice = voice;
+            utterance.rate = this.playbackSpeed;
+
+            utterance.onend = () => {
+                this.isPlaying = false;
+                resolve();
+            };
+            utterance.onerror = (e) => {
+                this.isPlaying = false;
+                reject(new Error('Browser TTS error: ' + e.error));
+            };
+
+            window.speechSynthesis.speak(utterance);
+            this.isPlaying = true;
+        });
+    }
+
+    stop() {
+        // Cancel streaming TTS
+        this._streamActive = false;
+        if (this._streamDebounceTimer) {
+            clearTimeout(this._streamDebounceTimer);
+            this._streamDebounceTimer = null;
+        }
+        this._streamSentencesSent = 0;
+
+        // Clear the entire queue and reset all queued buttons
+        for (const item of this._queue) {
+            if (item.resetFn) item.resetFn();
+        }
+        this._queue = [];
+        this._processing = false;
+
+        if (this.useBrowserTTS) {
+            window.speechSynthesis.cancel();
+            this.isPlaying = false;
+        }
+        if (this.currentAudio) {
+            this.currentAudio.pause();
+            this.currentAudio.currentTime = 0;
+            this.currentAudio = null;
+            this.isPlaying = false;
+        }
+    }
+
+    /**
+     * Enqueue a message for auto-play. Plays sequentially — each message
+     * finishes before the next starts. Stopping any message clears the queue.
+     */
+    enqueue(text, button, resetFn) {
+        this._queue.push({ text, button, resetFn });
+        if (!this._processing) {
+            this._processQueue();
+        }
+    }
+
+    async _processQueue() {
+        if (this._processing) return;
+        this._processing = true;
+
+        while (this._queue.length > 0) {
+            const item = this._queue[0];
+            try {
+                await this._playQueueItem(item);
+            } catch (err) {
+                console.error('TTS queue item error:', err);
+            }
+            if (this._queue.length > 0 && this._queue[0] === item) {
+                this._queue.shift();
+            }
+            if (!this._processing) return;
+        }
+
+        this._processing = false;
+    }
+
+    async _playQueueItem(item) {
+        const { text, button, resetFn } = item;
+        const ICON_LOADING = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="12" cy="12" r="9" stroke-dasharray="42" stroke-dashoffset="12" stroke-linecap="round"><animateTransform attributeName="transform" type="rotate" from="0 12 12" to="360 12 12" dur="0.8s" repeatCount="indefinite"/></circle></svg>';
+        var ICON_STOP = '<svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor" stroke="none"><rect x="5" y="5" width="14" height="14" rx="2"/></svg>';
+
+        button.innerHTML = ICON_LOADING;
+        button.classList.add('loading');
+        button.style.color = '#ccc';
+        button.title = 'Loading...';
+
+        try {
+            if (!this._processing) return;
+
+            const audioUrl = await this.synthesize(text);
+
+            if (!this._processing) return;
+
+            button.innerHTML = ICON_STOP;
+            button.classList.remove('loading');
+            button.classList.add('playing');
+            button.title = 'Stop';
+
+            if (this.useBrowserTTS) {
+                const plainText = this.extractPlainText(text);
+                await this._playBrowser(plainText);
+            } else {
+                if (this.currentAudio) {
+                    this.currentAudio.pause();
+                    this.currentAudio = null;
+                }
+
+                await new Promise((resolve, reject) => {
+                    const audio = new Audio(audioUrl);
+                    if (this._provider === 'local' && this.playbackSpeed !== 1) {
+                        audio.playbackRate = this.playbackSpeed;
+                    }
+                    this.currentAudio = audio;
+                    audio.onended = () => {
+                        this.isPlaying = false;
+                        if (this.currentAudio === audio) this.currentAudio = null;
+                        resolve();
+                    };
+                    audio.onerror = (e) => {
+                        this.isPlaying = false;
+                        if (this.currentAudio === audio) this.currentAudio = null;
+                        reject(new Error('Audio playback error'));
+                    };
+                    audio.onpause = () => {
+                        if (this.currentAudio !== audio) {
+                            resolve();
+                        }
+                    };
+                    audio.play().then(() => {
+                        this.isPlaying = true;
+                    }).catch(reject);
+                });
+            }
+        } finally {
+            if (resetFn) resetFn();
+        }
+    }
+
+    // ── Streaming TTS (sentence-by-sentence) ──
+
+    streamingStart() {
+        this._streamSentencesSent = 0;
+        this._streamActive = true;
+        this._streamButton = null;
+        this._streamResetFn = null;
+    }
+
+    streamingUpdate(accumulatedText) {
+        if (!this._streamActive || !this.available || !this.autoPlay) return;
+        if (this._streamDebounceTimer) return;
+        this._streamDebounceTimer = setTimeout(() => {
+            this._streamDebounceTimer = null;
+            this._processStreamingSentences(accumulatedText);
+        }, 150);
+    }
+
+    _processStreamingSentences(accumulatedText) {
+        if (!this._streamActive) return;
+
+        var text = accumulatedText
+            .replace(/```[\s\S]*?```/g, '')
+            .replace(/```[\s\S]*$/g, '');
+
+        var plainText = this.extractPlainText(text);
+        if (!plainText || plainText.length <= this._streamSentencesSent) return;
+
+        var newRegion = plainText.substring(this._streamSentencesSent);
+
+        var sentences = [];
+        var current = '';
+        for (var i = 0; i < newRegion.length; i++) {
+            current += newRegion[i];
+            var ch = newRegion[i];
+            var next = newRegion[i + 1];
+            if ((ch === '.' || ch === '!' || ch === '?') && next && /\s/.test(next)) {
+                var lastWord = current.trim().split(/\s/).pop() || '';
+                if (/^\d+\.$/.test(lastWord)) continue;
+                if (/^[A-Z][a-z]?\.$/.test(lastWord)) continue;
+                sentences.push(current.trim());
+                current = '';
+            }
+        }
+
+        if (sentences.length === 0) return;
+
+        var advancedChars = 0;
+        for (var j = 0; j < sentences.length; j++) {
+            var sentence = sentences[j];
+            if (sentence.length < 15) {
+                advancedChars += sentence.length + 1;
+                continue;
+            }
+            var btn = this._streamButton || this._createPlaceholderButton();
+            var resetFn = this._streamResetFn || function() {};
+            this.enqueue(sentence, btn, resetFn);
+            advancedChars += sentence.length + 1;
+        }
+
+        this._streamSentencesSent += advancedChars;
+    }
+
+    _createPlaceholderButton() {
+        var btn = document.createElement('button');
+        btn.style.display = 'none';
+        btn.className = 'ai-tts-button streaming-placeholder';
+        return btn;
+    }
+
+    streamingAttachButton(button, resetFn) {
+        this._streamButton = button;
+        this._streamResetFn = resetFn;
+        for (var i = 0; i < this._queue.length; i++) {
+            if (this._queue[i].button && this._queue[i].button.classList.contains('streaming-placeholder')) {
+                this._queue[i].button = button;
+                this._queue[i].resetFn = resetFn;
+            }
+        }
+    }
+
+    streamingEnd(finalText) {
+        if (!this._streamActive) return;
+        this._streamActive = false;
+        if (this._streamDebounceTimer) {
+            clearTimeout(this._streamDebounceTimer);
+            this._streamDebounceTimer = null;
+        }
+
+        var text = finalText
+            .replace(/```[\s\S]*?```/g, '')
+            .replace(/```[\s\S]*$/g, '');
+
+        var plainText = this.extractPlainText(text);
+        if (!plainText) return;
+
+        var remaining = plainText.substring(this._streamSentencesSent).trim();
+        if (remaining.length >= 15) {
+            var btn = this._streamButton || this._createPlaceholderButton();
+            var resetFn = this._streamResetFn || function() {};
+            this.enqueue(remaining, btn, resetFn);
+        }
+        this._streamSentencesSent = 0;
+    }
+
+    clearCache() {
+        for (const url of this.cache.values()) {
+            URL.revokeObjectURL(url);
+        }
+        this.cache.clear();
+    }
+}
+
+// Create global AI TTS manager instance
+window.aiTTSManager = new AITTSManager();
+
+// Function to add AI TTS button to a message element's action bar
+export function addAITTSButton(messageElement, text) {
+    if (!window.aiTTSManager.available || window.aiTTSManager._provider === 'disabled') {
+        return;
+    }
+
+    if (messageElement.querySelector('.ai-tts-button')) {
+        return;
+    }
+
+    // Find the msg-actions container in the footer
+    const actions = messageElement.querySelector('.msg-actions');
+    if (!actions) return;
+
+    var ICON_PLAY = '<svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor" stroke="none"><polygon points="6 3 20 12 6 21 6 3"/></svg>';
+    var ICON_STOP = '<svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor" stroke="none"><rect x="5" y="5" width="14" height="14" rx="2"/></svg>';
+    var ICON_LOADING = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="12" cy="12" r="9" stroke-dasharray="42" stroke-dashoffset="12" stroke-linecap="round"><animateTransform attributeName="transform" type="rotate" from="0 12 12" to="360 12 12" dur="0.8s" repeatCount="indefinite"/></circle></svg>';
+
+    const playButton = document.createElement('button');
+    playButton.className = 'ai-tts-button';
+    playButton.type = 'button';
+    playButton.title = 'Read aloud';
+    playButton.innerHTML = ICON_PLAY;
+    playButton.style.cssText = 'background:none;border:none;color:#6b7280;cursor:pointer;padding:2px 6px;border-radius:4px;transition:color .15s;line-height:1;display:inline-flex;align-items:center;';
+
+    playButton.addEventListener('mouseenter', () => { playButton.style.color = '#ccc'; });
+    playButton.addEventListener('mouseleave', () => {
+        if (!playButton.classList.contains('playing') && !playButton.classList.contains('loading')) playButton.style.color = '#6b7280';
+    });
+
+    function resetButton() {
+        playButton.innerHTML = ICON_PLAY;
+        playButton.classList.remove('playing', 'loading');
+        playButton.style.color = '#6b7280';
+        playButton.title = 'Read aloud';
+    }
+
+    playButton.addEventListener('click', async (e) => {
+        e.stopPropagation();
+        const mgr = window.aiTTSManager;
+
+        if (mgr.isPlaying || mgr._processing) {
+            mgr.stop();
+            resetButton();
+            return;
+        }
+
+        mgr.enqueue(text, playButton, resetButton);
+    });
+
+    actions.appendChild(playButton);
+}
+
+// Stop audio when navigating away
+window.addEventListener('beforeunload', () => {
+    if (window.aiTTSManager) {
+        window.aiTTSManager.stop();
+    }
+});
+
+export { AITTSManager };
+
+const ttsModule = { AITTSManager, addAITTSButton };
+export default ttsModule;