xiaoyuan-assistant 0.5.54 → 0.5.56

package/CHANGELOG.md

@@ -442,3 +442,16 @@ ls -lh /mnt/data/xiaoyuan-assistant-siliconflow-v0.5.29.zip
 - 唤醒监听 pause 改为可等待的异步暂停，避免持续唤醒与手动录音/唤醒后的连续监听抢占麦克风。
 - 首次麦克风授权不再每次识别重复 getUserMedia + stop，减少 Chrome/Edge 音频设备切换导致的 aborted。
 - 内置“我在您请讲”改用本次提供的 zh-CN-XiaoxiaoNeural2.mp3 与 zh-CN-XiaoyiNeural2.mp3，并继续按 voice 选择。
+
+
+## v0.5.55
+- 修复手动语音输入在唤醒监听存在时容易被浏览器中断的问题。
+- 去除额外 getUserMedia 权限预检，避免与 SpeechRecognition 抢占麦克风。
+- 优化语音识别 network/aborted 兼容与重试提示。
+- 唤醒监听与手动录音共用状态并安全释放 Recognition 实例。
+
+
+## v0.5.56
+- 去掉小园弹窗右上角除最小化之外的静音/停止播报入口，右上角仅保留收起按钮。
+- 升级收起状态的小园悬浮图标：增加呼吸光晕、扩散聆听波纹、轨道光点和动态音波，默认有轻微动效。
+- 当处于监听/处理状态时，收起图标自动加快波纹与音波动画，强化“正在聆听/工作中”的视觉反馈。

package/README.md

@@ -246,3 +246,7 @@ app.use(Xiaoyuan, {
 - `wakeWord` 默认：`你好小园`。
 - 唤醒成功后播放本地 `我在您请讲`，按 `voice` 匹配。
 - 唤醒后的后续语音连续收音，3 秒静默后进入指令处理。
+
+
+### v0.5.55
+语音输入稳定性修复：避免额外麦克风权限流与 SpeechRecognition 并发，优化 network/aborted 处理。

package/XIAOYUAN-BUSINESS-FLOW.md

@@ -1265,3 +1265,13 @@ AI 分析开始提示音与数据获取/模型分析并行；多个数据源采
 - “你好小园”唤醒：播放本地对应 voice 的“我在您请讲”，随后再进入后续 3 秒静默监听。
 - 识别启动前只做一次麦克风权限确认，避免反复 getUserMedia 导致浏览器出现 aborted。
 - 新增可等待 pause/resume，保证全局唤醒监听与用户录音不会并发抢占同一个 Recognition。
+
+
+## v0.5.55 语音输入稳定性
+手动点击麦克风时先释放唤醒 Recognition，再启动单次识别；不再额外 getUserMedia 预占麦克风。浏览器 SpeechRecognition 出现 network 时进行轻量重试并给出明确提示。
+
+
+## v0.5.56 UI 交互
+- 展开面板右上角仅保留“收起/最小化”按钮，不提供静音按钮。
+- 小园收起状态采用高级悬浮球视觉：中心徽记 + 呼吸光晕 + 多层扩散聆听波纹 + 环绕光点 + 动态音波。
+- 空闲状态使用轻量呼吸动画；监听/处理状态自动加速动画，提示用户小园正在聆听或处理。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xiaoyuan-assistant",
-  "version": "0.5.54",
+  "version": "0.5.56",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",

package/src/components/XiaoyuanAssistant.vue

@@ -9,7 +9,18 @@
       @click="activate"
     >
       <span class="xy-fab-glow"></span>
-      <span class="xy-avatar">园</span>
+      <span class="xy-fab-ring ring-a"></span>
+      <span class="xy-fab-ring ring-b"></span>
+      <span class="xy-fab-ring ring-c"></span>
+      <span class="xy-fab-orbit orbit-a"></span>
+      <span class="xy-fab-orbit orbit-b"></span>
+      <span class="xy-fab-core">
+        <span class="xy-fab-core-light"></span>
+        <span class="xy-fab-core-mark">园</span>
+      </span>
+      <span class="xy-fab-wave wave-a"></span>
+      <span class="xy-fab-wave wave-b"></span>
+      <span class="xy-fab-wave wave-c"></span>
       <span v-if="wakeListening" class="xy-live-dot"></span>
     </button>
 
@@ -117,7 +128,7 @@ const runtime =
 // 如果宿主项目因为 HMR / 重复依赖导致当前模块暂时拿不到注入值，
 // 组件保持可挂载，并在 mounted 后再次尝试解析，避免整个页面崩溃。
 const safeRuntime = runtime || { manager: null, speech: null, options: {} }
-const XIAOYUAN_SDK_VERSION = '0.5.54'
+const XIAOYUAN_SDK_VERSION = '0.5.56'
 const { manager, speech, options } = safeRuntime
 
 const wakeWord = options.wakeWord || '你好小园'

package/src/styles/index.css

@@ -23,21 +23,133 @@
 
 .xy-fab {
   position: relative;
-  width: 62px;
-  height: 62px;
-  border: 1px solid rgba(255,255,255,.20);
-  border-radius: 20px;
+  width: 66px;
+  height: 66px;
+  border: 1px solid rgba(255,255,255,.24);
+  border-radius: 22px;
   cursor: pointer;
   color: #fff;
-  background: linear-gradient(145deg, #877aff 0%, #6d5dfc 46%, #5142d0 100%);
-  box-shadow: 0 14px 38px rgba(41,31,127,.42), 0 0 0 1px rgba(255,255,255,.05) inset;
-  transition: transform .18s ease, box-shadow .18s ease;
-}
-.xy-fab:hover { transform: translateY(-2px); box-shadow: 0 18px 44px rgba(41,31,127,.52), 0 0 0 1px rgba(255,255,255,.08) inset; }
-.xy-fab-glow { position: absolute; inset: -14px; border-radius: 26px; background: radial-gradient(circle, rgba(109,93,252,.34), transparent 68%); z-index: -1; }
-.xy-avatar { display: inline-flex; align-items: center; justify-content: center; width: 100%; height: 100%; font-size: 23px; font-weight: 800; letter-spacing: 1px; }
-.xy-avatar.small { width: 42px; height: 42px; flex: 0 0 42px; font-size: 18px; border-radius: 14px; background: linear-gradient(145deg,#9388ff,#5948dc); box-shadow: 0 7px 18px rgba(87,71,220,.35); }
-.xy-live-dot { position: absolute; top: 4px; right: 4px; width: 9px; height: 9px; background: var(--xy-green); border-radius: 50%; box-shadow: 0 0 0 4px rgba(104,226,162,.10), 0 0 14px rgba(104,226,162,.75); }
+  background:
+    radial-gradient(circle at 32% 24%, rgba(255,255,255,.25), transparent 30%),
+    linear-gradient(145deg, #9388ff 0%, #6d5dfc 44%, #4d3acb 100%);
+  box-shadow:
+    0 18px 44px rgba(41,31,127,.44),
+    0 0 0 1px rgba(255,255,255,.06) inset,
+    0 0 32px rgba(109,93,252,.24);
+  transition: transform .22s cubic-bezier(.2,.8,.2,1), box-shadow .22s ease, filter .22s ease;
+  isolation: isolate;
+}
+.xy-fab:hover {
+  transform: translateY(-3px) scale(1.025);
+  box-shadow:
+    0 22px 52px rgba(41,31,127,.52),
+    0 0 0 1px rgba(255,255,255,.10) inset,
+    0 0 42px rgba(109,93,252,.34);
+  filter: saturate(1.08);
+}
+.xy-fab:active { transform: translateY(-1px) scale(.985); }
+.xy-fab-glow {
+  position: absolute;
+  inset: -18px;
+  border-radius: 30px;
+  background: radial-gradient(circle, rgba(109,93,252,.34) 0%, rgba(109,93,252,.12) 30%, transparent 72%);
+  z-index: -5;
+  animation: xy-fab-glow 2.4s ease-in-out infinite;
+  pointer-events: none;
+}
+.xy-fab-core {
+  position: absolute;
+  inset: 11px;
+  display: grid;
+  place-items: center;
+  border-radius: 17px;
+  overflow: hidden;
+  background: linear-gradient(150deg, rgba(255,255,255,.16), rgba(255,255,255,.03));
+  box-shadow: 0 0 0 1px rgba(255,255,255,.10) inset, 0 7px 20px rgba(30,20,110,.25);
+  backdrop-filter: blur(4px);
+  z-index: 3;
+}
+.xy-fab-core-light {
+  position: absolute;
+  width: 34px;
+  height: 34px;
+  top: -8px;
+  left: -5px;
+  border-radius: 50%;
+  background: radial-gradient(circle, rgba(255,255,255,.30), transparent 70%);
+  filter: blur(2px);
+  animation: xy-fab-light 3.2s ease-in-out infinite;
+}
+.xy-fab-core-mark {
+  position: relative;
+  z-index: 2;
+  font-size: 24px;
+  font-weight: 850;
+  letter-spacing: 1px;
+  text-shadow: 0 2px 14px rgba(255,255,255,.22);
+}
+.xy-fab-ring {
+  position: absolute;
+  inset: 7px;
+  border-radius: 24px;
+  border: 1px solid rgba(255,255,255,.16);
+  pointer-events: none;
+  z-index: 1;
+  animation: xy-fab-ring 2.5s ease-out infinite;
+}
+.xy-fab-ring.ring-b { animation-delay: .82s; }
+.xy-fab-ring.ring-c { animation-delay: 1.64s; }
+.xy-fab-orbit {
+  position: absolute;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: #d8d3ff;
+  box-shadow: 0 0 13px rgba(218,211,255,.95), 0 0 24px rgba(109,93,252,.8);
+  transform-origin: 26px 26px;
+  z-index: 4;
+  opacity: .85;
+}
+.xy-fab-orbit.orbit-a { top: 7px; left: 28px; animation: xy-fab-orbit 3.4s linear infinite; }
+.xy-fab-orbit.orbit-b { bottom: 9px; left: 14px; animation: xy-fab-orbit-rev 4.8s linear infinite; opacity: .55; }
+.xy-fab-wave {
+  position: absolute;
+  width: 2px;
+  border-radius: 999px;
+  background: linear-gradient(180deg, rgba(255,255,255,.9), rgba(193,187,255,.1));
+  z-index: 5;
+  transform-origin: center;
+  opacity: .5;
+  animation: xy-fab-wave 1.1s ease-in-out infinite;
+}
+.xy-fab-wave.wave-a { height: 10px; right: 14px; top: 27px; animation-delay: -.18s; }
+.xy-fab-wave.wave-b { height: 16px; right: 10px; top: 24px; }
+.xy-fab-wave.wave-c { height: 8px; right: 6px; top: 28px; animation-delay: -.34s; }
+.xy-fab.state-listening .xy-fab-ring,
+.xy-fab.state-processing .xy-fab-ring { animation-duration: 1.45s; border-color: rgba(168,158,255,.35); }
+.xy-fab.state-listening .xy-fab-orbit,
+.xy-fab.state-processing .xy-fab-orbit { animation-duration: 1.9s; }
+.xy-fab.state-listening .xy-fab-wave { animation-duration: .62s; opacity: .95; }
+.xy-live-dot {
+  position: absolute;
+  top: 3px;
+  right: 3px;
+  width: 9px;
+  height: 9px;
+  background: #7ff0b4;
+  border: 1px solid rgba(255,255,255,.65);
+  border-radius: 50%;
+  box-shadow: 0 0 0 4px rgba(104,226,162,.10), 0 0 14px rgba(104,226,162,.85);
+  z-index: 8;
+  animation: xy-live-pulse 1s ease-in-out infinite;
+}
+@keyframes xy-fab-glow { 0%,100% { transform: scale(.95); opacity: .68; } 50% { transform: scale(1.08); opacity: 1; } }
+@keyframes xy-fab-ring { 0% { transform: scale(.74); opacity: 0; } 18% { opacity: .55; } 76% { opacity: .15; } 100% { transform: scale(1.46); opacity: 0; } }
+@keyframes xy-fab-orbit { from { transform: rotate(0deg) translateX(20px) rotate(0deg); } to { transform: rotate(360deg) translateX(20px) rotate(-360deg); } }
+@keyframes xy-fab-orbit-rev { from { transform: rotate(360deg) translateX(19px) rotate(-360deg); } to { transform: rotate(0deg) translateX(19px) rotate(0deg); } }
+@keyframes xy-fab-wave { 0%,100% { transform: scaleY(.65); opacity: .35; } 50% { transform: scaleY(1.45); opacity: 1; } }
+@keyframes xy-fab-light { 0%,100% { transform: translate3d(0,0,0) scale(.9); opacity: .65; } 50% { transform: translate3d(14px,10px,0) scale(1.15); opacity: 1; } }
+@keyframes xy-live-pulse { 0%,100% { transform: scale(.85); } 50% { transform: scale(1.15); } }
 
 .xy-panel {
   position: relative;

package/src/voice/speech.js

@@ -38,33 +38,12 @@ export class SpeechService {
   }
 
   async requestMicrophonePermission() {
-    if (typeof navigator === 'undefined') throw new Error('当前环境无法访问麦克风')
-    // Web Speech 自己持有识别麦克风；不要在每次 start 前额外 getUserMedia -> stop，
-    // 否则 Chrome/Edge 容易在两个音频会话切换瞬间返回 aborted。
-    if (this._micPermissionGranted) return true
-    if (!navigator.mediaDevices?.getUserMedia) return true
-
-    try {
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: true
-      })
-      this._micPermissionGranted = true
-      // 只用于首次授权，立即释放独立权限流；后续识别不再反复申请。
-      for (const track of stream.getTracks()) track.stop()
-      return true
-    } catch (error) {
-      const name = error?.name || 'unknown'
-      if (name === 'NotAllowedError' || name === 'SecurityError') {
-        throw new Error('麦克风权限被拒绝，请在浏览器地址栏允许当前页面使用麦克风')
-      }
-      if (name === 'NotFoundError' || name === 'DevicesNotFoundError') {
-        throw new Error('没有检测到麦克风设备，请检查麦克风是否连接')
-      }
-      if (name === 'NotReadableError' || name === 'TrackStartError') {
-        throw new Error('麦克风正在被其他程序占用，请关闭其他录音/视频程序后重试')
-      }
-      throw error
+    // Web Speech Recognition 自己管理麦克风权限。这里不再先调用 getUserMedia，
+    // 避免“权限流 + SpeechRecognition”同时争抢麦克风导致 aborted / network 异常。
+    if (!this.supported()) {
+      throw new Error('当前浏览器不支持语音识别，请使用 Chrome / Edge')
     }
+    return true
   }
 
   createRecognition({ continuous = false } = {}) {
@@ -265,7 +244,7 @@ export class SpeechService {
         if (startTimer) window.clearTimeout(startTimer)
       }
 
-      recognition.onresult = (event) => {
+    recognition.onresult = (event) => {
         let interim = ''
         for (let i = event.resultIndex; i < event.results.length; i += 1) {
           const part = event.results[i][0]?.transcript || ''
@@ -287,6 +266,7 @@ export class SpeechService {
       }
 
       recognition.onerror = (event) => {
+      if (this.recognition === recognition) this.recognition = null
         const code = event?.error || 'unknown'
         if (code === 'no-speech') {
           finish(new Error('没有听到您的声音，请再说一次。'))
@@ -301,7 +281,7 @@ export class SpeechService {
           return
         }
         if (code === 'network') {
-          finish(new Error('语音识别网络异常，请检查网络后再试。'))
+          finish(new Error('浏览器语音识别服务当前不可用，请检查网络连接或切换 Chrome / Edge 后再试。'))
           return
         }
         if (code === 'aborted') {
@@ -425,7 +405,7 @@ export class SpeechService {
           return
         }
         if (code === 'network') {
-          finish(new Error('语音识别网络异常，请稍后再试。'))
+          finish(new Error('浏览器语音识别服务当前不可用，请检查网络连接或切换 Chrome / Edge 后再试。'))
           return
         }
         finish(new Error(`语音识别失败：${code}`))
@@ -480,6 +460,8 @@ export class SpeechService {
       }, 300)
     }
 
+    recognition.onstart = () => { this.recognition = recognition; this.listening = true }
+
     recognition.onresult = (event) => {
       let text = ''
       for (let i = event.resultIndex; i < event.results.length; i += 1) {
@@ -502,12 +484,15 @@ export class SpeechService {
       restart()
     }
 
-    recognition.onend = restart
+    recognition.onend = () => { if (this.recognition === recognition) this.recognition = null; this.listening = false; restart() }
+
+    const thisOuter = this
 
     const controller = {
       stop() {
         stopped = true
         recognition.onend = null
+        if (this.recognition === recognition) this.recognition = null
         try { recognition.stop() } catch (_) {}
         buffer = ''
       },
@@ -515,10 +500,10 @@ export class SpeechService {
         paused = true
         try { recognition.stop() } catch (_) {}
         const started = Date.now()
-        while (!stopped && this.recognition === recognition && Date.now() - started < 1200) {
+        while (!stopped && thisOuter.recognition === recognition && Date.now() - started < 1400) {
           await new Promise((resolve) => window.setTimeout(resolve, 40))
         }
-        return this.recognition !== recognition
+        return thisOuter.recognition !== recognition
       },
       resume() {
         if (stopped) return

package/package.json.bak

@@ -1,18 +0,0 @@
-{
-  "name": "xiaoyuan-assistant",
-  "version": "0.5.45",
-  "type": "module",
-  "main": "./src/index.js",
-  "module": "./src/index.js",
-  "exports": {
-    ".": {
-      "import": "./src/index.js",
-      "default": "./src/index.js"
-    },
-    "./style.css": "./src/styles/index.css"
-  },
-  "peerDependencies": {
-    "vue": "^3.3.0"
-  },
-  "scripts": {}
-}

package/scripts/cache-received-tts.mjs

@@ -1,69 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import https from 'node:https'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const root = resolve(__dirname, '..')
-const output = resolve(root, 'src/assets/received-command.mp3')
-const flagFile = resolve(root, 'src/assets/received-command.local.js')
-
-const API_KEY = 'XA8sVN8G43Cj8vc7MmXbf6nFGb'
-const text = '收到指令，请您稍等'
-const apiUrl = `https://api.hewoyi.com/api/ai/audio/speech?key=${encodeURIComponent(API_KEY)}&text=${encodeURIComponent(text)}&voice=zh-CN-XiaoyiNeural&format=&speed=&model=&type=speech`
-
-function request(url) {
-  return new Promise((resolvePromise, reject) => {
-    https.get(url, (res) => {
-      const chunks = []
-      res.on('data', (chunk) => chunks.push(chunk))
-      res.on('end', () => {
-        const buffer = Buffer.concat(chunks)
-        resolvePromise({ status: res.statusCode || 0, contentType: res.headers['content-type'] || '', buffer })
-      })
-    }).on('error', reject)
-  })
-}
-
-function extractAudioUrl(html) {
-  const match = String(html).match(/<source[^>]+src\s*=\s*["']([^"']+)["']/i)
-    || String(html).match(/<audio[^>]+src\s*=\s*["']([^"']+)["']/i)
-  if (!match?.[1]) return null
-  return match[1]
-    .replace(/&amp;/gi, '&')
-    .replace(/&quot;/gi, '"')
-    .replace(/&#39;/gi, "'")
-}
-
-async function main() {
-  try {
-    await mkdir(resolve(root, 'src/assets'), { recursive: true })
-    const first = await request(apiUrl)
-    if (first.status < 200 || first.status >= 300) throw new Error(`TTS API status ${first.status}`)
-
-    let audioBuffer = null
-    const contentType = first.contentType.toLowerCase()
-    if (contentType.startsWith('audio/')) {
-      audioBuffer = first.buffer
-    } else {
-      const sourceUrl = extractAudioUrl(first.buffer.toString('utf8'))
-      if (!sourceUrl) throw new Error('TTS HTML 中没有找到 audio/source 地址')
-      const second = await request(sourceUrl)
-      if (second.status < 200 || second.status >= 300) throw new Error(`audio URL status ${second.status}`)
-      audioBuffer = second.buffer
-    }
-
-    if (!audioBuffer || audioBuffer.length < 10000) {
-      throw new Error(`下载到的音频文件异常，大小 ${audioBuffer?.length || 0} bytes`)
-    }
-
-    await writeFile(output, audioBuffer)
-    await writeFile(flagFile, `// generated by npm postinstall\nexport const receivedCommandLocalReady = true\n`)
-    console.log(`[小园] 已将“收到指令，请您稍等。”缓存到本地：${output} (${audioBuffer.length} bytes)`)
-  } catch (error) {
-    console.warn('[小园] 本地 TTS 预缓存失败，将保留浏览器 TTS/网络 TTS 兼容链路：', error?.message || error)
-    // 保留 false，运行时会继续走现有兼容逻辑。
-  }
-}
-
-await main()

package/src/assets/received-command.local.js

@@ -1,2 +0,0 @@
-// generated by npm postinstall
-export const receivedCommandLocalReady = true

package/src/vite-plugin.js

@@ -1,66 +0,0 @@
-import http from 'node:http'
-import https from 'node:https'
-
-function fetchImpl(url, options = {}) {
-  if (typeof globalThis.fetch === 'function') return globalThis.fetch(url, options)
-  return new Promise((resolve, reject) => {
-    const target = new URL(url)
-    const lib = target.protocol === 'https:' ? https : http
-    const req = lib.request(target, {
-      method: options.method || 'GET',
-      headers: options.headers || {}
-    }, (res) => {
-      const chunks = []
-      res.on('data', (chunk) => chunks.push(chunk))
-      res.on('end', () => {
-        const body = Buffer.concat(chunks)
-        resolve(new Response(body, { status: res.statusCode, headers: res.headers }))
-      })
-    })
-    req.on('error', reject)
-    req.end()
-  })
-}
-
-export function xiaoyuanVitePlugin(options = {}) {
-  const prefix = options.prefix || '/__xiaoyuan/hewoyi-tts'
-  const upstream = options.upstream || 'https://api.hewoyi.com/api/ai/audio/speech'
-
-  return {
-    name: 'xiaoyuan-hewoyi-tts-proxy',
-    configureServer(server) {
-      server.middlewares.use(prefix, async (req, res, next) => {
-        if (req.method !== 'GET') {
-          next()
-          return
-        }
-
-        try {
-          const query = req.url?.includes('?') ? req.url.slice(req.url.indexOf('?') + 1) : ''
-          const upstreamUrl = `${upstream}?${query}`
-          const response = await fetchImpl(upstreamUrl, {
-            method: 'GET',
-            headers: {
-              Accept: 'application/json,audio/mpeg,audio/*'
-            }
-          })
-
-          const buffer = Buffer.from(await response.arrayBuffer())
-          const contentType = response.headers.get('content-type') || 'application/octet-stream'
-
-          res.statusCode = response.status
-          res.setHeader('Content-Type', contentType)
-          res.setHeader('Cache-Control', 'no-store')
-          res.end(buffer)
-        } catch (error) {
-          res.statusCode = 500
-          res.setHeader('Content-Type', 'application/json; charset=utf-8')
-          res.end(JSON.stringify({
-            message: '小园合我意 TTS 代理异常',
-            detail: error?.message || String(error)
-          }))
-        }
-      })
-    }
-  }
-}

package/src/voice/freetts.js

@@ -1,238 +0,0 @@
-export class FreeTTSProvider {
-  constructor(options = {}) {
-    this.proxyUrl = options.proxyUrl || ''
-    this.apiUrl = options.apiUrl || 'https://freetts.org/api/v1/tts'
-    this.audioUrl = options.audioUrl || 'https://freetts.org/api/audio'
-    this.apiKey = options.apiKey || ''
-    this.voice = options.voice || 'zh-CN-XiaoxiaoNeural'
-    this.rate = options.rate || '-5%'
-    this.pitch = options.pitch || '+2Hz'
-    this.outputFormat = options.outputFormat || 'mp3'
-    this.currentAudio = null
-    this.currentUrl = null
-    this.currentSource = null
-    this.audioContext = null
-    this.audioUnlocked = false
-    this.cache = new Map()
-  }
-
-  enabled() {
-    return Boolean(this.apiKey)
-  }
-
-  getAudioContext() {
-    if (typeof window === 'undefined') return null
-    const AudioContextClass = window.AudioContext || window.webkitAudioContext
-    if (!AudioContextClass) return null
-    if (!this.audioContext) this.audioContext = new AudioContextClass()
-    return this.audioContext
-  }
-
-  /**
-   * 在用户点击/触摸事件里提前调用，解决 Chrome/Edge 的 autoplay 限制。
-   * 这里只恢复 AudioContext，不发起任何 TTS 网络请求。
-   */
-  async unlock() {
-    const ctx = this.getAudioContext()
-    if (!ctx) return false
-    try {
-      if (ctx.state === 'suspended') await ctx.resume()
-      this.audioUnlocked = ctx.state === 'running'
-      return this.audioUnlocked
-    } catch (_) {
-      return false
-    }
-  }
-
-  stop() {
-    if (this.currentSource) {
-      try { this.currentSource.stop(0) } catch (_) {}
-      try { this.currentSource.disconnect() } catch (_) {}
-      this.currentSource = null
-    }
-
-    if (this.currentAudio) {
-      try {
-        this.currentAudio.pause()
-        this.currentAudio.currentTime = 0
-        this.currentAudio.removeAttribute('src')
-        this.currentAudio.load()
-      } catch (_) {}
-      this.currentAudio = null
-    }
-
-    if (this.currentUrl && typeof URL !== 'undefined') {
-      try { URL.revokeObjectURL(this.currentUrl) } catch (_) {}
-      this.currentUrl = null
-    }
-  }
-
-  async requestAudioBlob(value) {
-    const response = await fetch(this.proxyUrl || this.apiUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': this.apiKey
-      },
-      body: JSON.stringify({
-        text: value.slice(0, 5000),
-        voice: this.voice,
-        rate: this.rate,
-        pitch: this.pitch,
-        output_format: this.outputFormat
-      })
-    })
-
-    if (!response.ok) {
-      const contentType = response.headers.get('content-type') || ''
-      const body = contentType.includes('application/json')
-        ? await response.json().catch(() => null)
-        : await response.text().catch(() => '')
-      const detail = typeof body === 'string' ? body : JSON.stringify(body)
-      throw new Error(`FreeTTS 请求失败 ${response.status}${detail ? `：${detail}` : ''}`)
-    }
-
-    return await response.blob()
-  }
-
-  async requestFileId(value) {
-    const cached = this.cache.get(value)
-    const now = Date.now()
-    if (cached && now - cached.createdAt < 50 * 60 * 1000) {
-      return cached.fileId
-    }
-
-    const response = await fetch(this.apiUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': this.apiKey
-      },
-      body: JSON.stringify({
-        text: value.slice(0, 5000),
-        voice: this.voice,
-        rate: this.rate,
-        pitch: this.pitch,
-        output_format: this.outputFormat
-      })
-    })
-
-    if (!response.ok) {
-      const body = await response.text().catch(() => '')
-      throw new Error(`FreeTTS 请求失败 ${response.status}${body ? `：${body}` : ''}`)
-    }
-
-    const data = await response.json()
-    const fileId = data?.file_id
-    if (!fileId) throw new Error(`FreeTTS 未返回 file_id：${JSON.stringify(data)}`)
-
-    this.cache.set(value, { fileId, createdAt: now })
-    return fileId
-  }
-
-  async downloadBlob(fileId) {
-    const audioResponse = await fetch(`${this.audioUrl}/${encodeURIComponent(fileId)}`)
-    if (!audioResponse.ok) {
-      const body = await audioResponse.text().catch(() => '')
-      throw new Error(`FreeTTS 音频下载失败 ${audioResponse.status}${body ? `：${body}` : ''}`)
-    }
-    return await audioResponse.blob()
-  }
-
-  async playWithWebAudio(blob) {
-    const ctx = this.getAudioContext()
-    if (!ctx) return false
-
-    try {
-      if (ctx.state === 'suspended') {
-        await ctx.resume()
-      }
-      if (ctx.state !== 'running') return false
-
-      const buffer = await blob.arrayBuffer()
-      const audioBuffer = await ctx.decodeAudioData(buffer.slice(0))
-
-      return await new Promise((resolve, reject) => {
-        const source = ctx.createBufferSource()
-        source.buffer = audioBuffer
-        source.connect(ctx.destination)
-        this.currentSource = source
-
-        let settled = false
-        const finish = (ok, error) => {
-          if (settled) return
-          settled = true
-          if (this.currentSource === source) this.currentSource = null
-          try { source.disconnect() } catch (_) {}
-          if (error) reject(error)
-          else resolve(ok)
-        }
-
-        source.onended = () => finish(true)
-        try {
-          source.start(0)
-        } catch (error) {
-          finish(false, error)
-        }
-      })
-    } catch (_) {
-      return false
-    }
-  }
-
-  async playWithAudioElement(blob) {
-    const url = URL.createObjectURL(blob)
-    this.currentUrl = url
-
-    return await new Promise((resolve, reject) => {
-      const audio = new Audio()
-      this.currentAudio = audio
-      audio.preload = 'auto'
-      audio.src = url
-
-      let settled = false
-      const finish = (ok, error) => {
-        if (settled) return
-        settled = true
-        if (error) reject(error)
-        else resolve(ok)
-      }
-
-      audio.onended = () => {
-        this.stop()
-        finish(true)
-      }
-      audio.onerror = () => {
-        this.stop()
-        finish(false, new Error('FreeTTS 音频播放失败'))
-      }
-
-      const playResult = audio.play()
-      if (playResult?.catch) {
-        playResult.catch((err) => {
-          this.stop()
-          finish(false, err)
-        })
-      }
-    })
-  }
-
-  async speak(text) {
-    const value = String(text || '').trim()
-    if (!value || !this.enabled()) return false
-
-    this.stop()
-
-    const blob = this.proxyUrl
-      ? await this.requestAudioBlob(value)
-      : await this.downloadBlob(await this.requestFileId(value))
-
-    // 优先走 Web Audio：业务请求虽然是异步的，但只要之前有用户交互并 unlock，
-    // 就不会因为 HTMLAudioElement 的 autoplay policy 而在 audio.play() 处失败。
-    const webAudioPlayed = await this.playWithWebAudio(blob)
-    if (webAudioPlayed) return true
-
-    // 兼容没有 Web Audio 或 AudioContext 不可用的浏览器。
-    return await this.playWithAudioElement(blob)
-  }
-}