@pickleball/expo-sdk 0.1.1 → 0.2.0

package/dist/chunk-YGSQ25UA.cjs

@@ -0,0 +1,800 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+var _chunk7OX2DSKIcjs = require('./chunk-7OX2DSKI.cjs');
+
+// src/match/voice/types.ts
+var VoiceError = (_class = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);_class.prototype.__init.call(this);;
+    this.code = code;
+  }
+  __init() {this.name = "VoiceError"}
+}, _class);
+
+// src/match/voice/audio.ts
+function createExpoAudioPlayback(options = {}) {
+  const load = _nullishCoalesce(options.load, () => ( (() => _chunk7OX2DSKIcjs.__require.call(void 0, "expo-audio"))));
+  const loadNativeAudio = _nullishCoalesce(options.loadNativeAudio, () => ( (() => {
+    const imported = _chunk7OX2DSKIcjs.__require.call(void 0, "@pickleball/voice-native");
+    return _nullishCoalesce(imported.default, () => ( imported));
+  })));
+  let player = null;
+  let settleCurrent = null;
+  let nativeAudio;
+  let nativeSubscription = null;
+  let disposed = false;
+  let operationGeneration = 0;
+  let configureTail = Promise.resolve();
+  let disposePromise = null;
+  let routeState = {
+    route: "system",
+    interrupted: false,
+    disconnectedReason: null
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const updateRouteState = (state) => {
+    if (disposed) return;
+    routeState = state;
+    for (const listener of listeners) listener(routeState);
+  };
+  const getNativeAudio = () => {
+    if (nativeAudio !== void 0) return nativeAudio;
+    try {
+      nativeAudio = loadNativeAudio();
+    } catch (e) {
+      nativeAudio = null;
+    }
+    return nativeAudio;
+  };
+  const observeNativeAudio = () => {
+    const native = getNativeAudio();
+    if (native && !nativeSubscription) {
+      nativeSubscription = native.addListener("onAudioRouteChanged", updateRouteState);
+    }
+    return native;
+  };
+  const stop = async () => {
+    if (!player) return;
+    const current = player;
+    player = null;
+    const settle = settleCurrent;
+    settleCurrent = null;
+    try {
+      current.pause();
+    } catch (e2) {
+    }
+    if (settle) settle();
+    else try {
+      current.remove();
+    } catch (e3) {
+    }
+  };
+  const isCurrentAudioOperation = (generation) => !disposed && generation === operationGeneration;
+  const releaseNativeAudioSession = async (native) => {
+    _optionalChain([nativeSubscription, 'optionalAccess', _ => _.remove, 'call', _2 => _2()]);
+    nativeSubscription = null;
+    await native.disposeAudioSession();
+  };
+  return {
+    configure(mode) {
+      if (disposed) return Promise.resolve();
+      const generation = operationGeneration;
+      const operation = configureTail.then(async () => {
+        if (!isCurrentAudioOperation(generation)) return;
+        const native = observeNativeAudio();
+        try {
+          await _optionalChain([native, 'optionalAccess', _3 => _3.captureAudioSessionState, 'call', _4 => _4()]);
+        } catch (e4) {
+        }
+        if (!isCurrentAudioOperation(generation)) return;
+        try {
+          await load().setAudioModeAsync({
+            allowsRecording: mode === "live",
+            playsInSilentMode: true
+          });
+        } catch (error) {
+          if (native) {
+            try {
+              await releaseNativeAudioSession(native);
+            } catch (e5) {
+            }
+          }
+          throw error;
+        }
+        if (native) {
+          try {
+            const nextRouteState = await native.configureAudioSession(mode);
+            if (isCurrentAudioOperation(generation)) updateRouteState(nextRouteState);
+          } catch (error) {
+            try {
+              await releaseNativeAudioSession(native);
+            } catch (e6) {
+            }
+            throw error;
+          }
+        }
+      });
+      configureTail = operation.catch(() => void 0);
+      return operation;
+    },
+    async play(source) {
+      if (disposed) {
+        throw new VoiceError("playback_failed", "Audio playback is disposed");
+      }
+      await stop();
+      if (disposed) {
+        throw new VoiceError("playback_failed", "Audio playback is disposed");
+      }
+      let current;
+      try {
+        current = load().createAudioPlayer(
+          options.resolveSource ? options.resolveSource(source) : source
+        );
+      } catch (error) {
+        throw new VoiceError("playback_failed", "Unable to create audio player", { cause: error });
+      }
+      player = current;
+      await new Promise((resolve, reject) => {
+        let settled = false;
+        let subscription = null;
+        const timeout = setTimeout(() => {
+          settle(new VoiceError("playback_failed", "Audio playback timed out"));
+        }, _nullishCoalesce(options.playbackTimeoutMs, () => ( 3e4)));
+        const settle = (error) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeout);
+          try {
+            _optionalChain([subscription, 'optionalAccess', _5 => _5.remove, 'call', _6 => _6()]);
+          } catch (e7) {
+          }
+          if (player === current) player = null;
+          if (settleCurrent === settle) settleCurrent = null;
+          try {
+            current.remove();
+          } catch (e8) {
+          }
+          if (error) {
+            reject(error instanceof VoiceError ? error : new VoiceError("playback_failed", "Audio playback failed", { cause: error }));
+          } else resolve();
+        };
+        settleCurrent = settle;
+        try {
+          subscription = current.addListener("playbackStatusUpdate", (status) => {
+            if (status.didJustFinish) settle();
+            else if (status.error != null || status.playbackState === "error") {
+              settle(_nullishCoalesce(status.error, () => ( new Error("Audio player entered an error state"))));
+            }
+          });
+          current.play();
+        } catch (error) {
+          settle(error);
+        }
+      });
+    },
+    stop,
+    dispose() {
+      if (disposePromise) return disposePromise;
+      disposed = true;
+      operationGeneration += 1;
+      disposePromise = (async () => {
+        await stop();
+        await configureTail;
+        const native = getNativeAudio();
+        if (!native) {
+          _optionalChain([nativeSubscription, 'optionalAccess', _7 => _7.remove, 'call', _8 => _8()]);
+          nativeSubscription = null;
+        }
+        try {
+          if (native) await releaseNativeAudioSession(native);
+        } catch (e9) {
+        }
+        listeners.clear();
+      })();
+      return disposePromise;
+    },
+    getRouteState() {
+      return routeState;
+    },
+    subscribeToRouteChanges(listener) {
+      listeners.add(listener);
+      observeNativeAudio();
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/match/voice/bundled-assets.ts
+function resolveBundledVoiceAsset(source) {
+  return source;
+}
+
+// src/match/voice/gemini-engine.ts
+function createExpoGeneratedAudioFileSystem() {
+  return {
+    async writeFile(path, bytes) {
+      const fs = _chunk7OX2DSKIcjs.__require.call(void 0, "expo-file-system");
+      const file = new fs.File(path);
+      if (!file.exists) file.create({ intermediates: true, overwrite: true });
+      const handle = file.open(fs.FileMode.ReadWrite);
+      try {
+        handle.writeBytes(bytes);
+      } finally {
+        handle.close();
+      }
+    },
+    async removeFile(path) {
+      const fs = _chunk7OX2DSKIcjs.__require.call(void 0, "expo-file-system");
+      const file = new fs.File(path);
+      if (file.exists) file.delete();
+    }
+  };
+}
+function createGeminiVoiceEngine(options) {
+  const fetcher = _nullishCoalesce(options.fetch, () => ( globalThis.fetch));
+  const fileSystem = _nullishCoalesce(options.fileSystem, () => ( createExpoGeneratedAudioFileSystem()));
+  const timeoutMs = _nullishCoalesce(options.requestTimeoutMs, () => ( 8e3));
+  const controllers = /* @__PURE__ */ new Set();
+  let sequence = 0;
+  let disposed = false;
+  const abortAll = () => {
+    for (const controller of controllers) controller.abort();
+    controllers.clear();
+  };
+  return {
+    async availability() {
+      return !disposed && options.url ? "available" : "unavailable";
+    },
+    async prewarm() {
+    },
+    async synthesize(text, signal) {
+      if (disposed) {
+        throw new VoiceError("engine_unavailable", "Gemini voice engine is disposed");
+      }
+      const controller = new AbortController();
+      controllers.add(controller);
+      const onAbort = () => controller.abort();
+      signal.addEventListener("abort", onAbort, { once: true });
+      if (signal.aborted) controller.abort();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        let response;
+        try {
+          response = await fetcher(options.url, {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              ...options.headers ? await options.headers() : void 0
+            },
+            body: JSON.stringify({
+              text,
+              voiceName: options.voiceName,
+              languageCode: options.languageCode
+            }),
+            signal: controller.signal
+          });
+        } catch (caught) {
+          throw new VoiceError(
+            controller.signal.aborted ? "synthesis_failed" : "network_unavailable",
+            controller.signal.aborted ? "Voice synthesis was cancelled" : "Voice synthesis request could not reach the TTS endpoint",
+            { cause: caught }
+          );
+        }
+        if (!response.ok) {
+          throw new VoiceError(
+            "synthesis_failed",
+            `TTS endpoint responded with status ${response.status}`
+          );
+        }
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.length === 0) {
+          throw new VoiceError("synthesis_failed", "TTS endpoint returned an empty body");
+        }
+        if (controller.signal.aborted || disposed) {
+          throw new VoiceError("synthesis_failed", "Voice synthesis was cancelled");
+        }
+        const path = `${options.generatedRoot}/tts-${++sequence}-${Date.now()}.wav`;
+        try {
+          await fileSystem.writeFile(path, bytes);
+        } catch (caught) {
+          throw new VoiceError("storage_failure", "Unable to persist generated audio", {
+            cause: caught
+          });
+        }
+        if (controller.signal.aborted || disposed) {
+          await fileSystem.removeFile(path).catch(() => void 0);
+          throw new VoiceError("synthesis_failed", "Voice synthesis was cancelled");
+        }
+        return path;
+      } finally {
+        clearTimeout(timeout);
+        signal.removeEventListener("abort", onAbort);
+        controllers.delete(controller);
+      }
+    },
+    async cancel() {
+      abortAll();
+    },
+    async release(filePath) {
+      try {
+        await fileSystem.removeFile(filePath);
+      } catch (e10) {
+      }
+    },
+    async dispose() {
+      disposed = true;
+      abortAll();
+    }
+  };
+}
+function createUnavailableVoiceEngine() {
+  return {
+    async availability() {
+      return "unavailable";
+    },
+    async prewarm() {
+    },
+    async synthesize() {
+      throw new VoiceError("engine_unavailable", "No TTS endpoint is configured");
+    },
+    async cancel() {
+    },
+    async dispose() {
+    }
+  };
+}
+
+// src/match/voice/phrases.ts
+var VIETNAMESE_NUMBERS = [
+  "kh\xF4ng",
+  "m\u1ED9t",
+  "hai",
+  "ba",
+  "b\u1ED1n",
+  "n\u0103m",
+  "s\xE1u",
+  "b\u1EA3y",
+  "t\xE1m",
+  "ch\xEDn"
+];
+function spokenNumber(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 99) {
+    throw new RangeError("Announcement scores must be integers from 0 to 99");
+  }
+  if (value < 10) return VIETNAMESE_NUMBERS[value];
+  if (value === 10) return "m\u01B0\u1EDDi";
+  const tens = Math.floor(value / 10);
+  const units = value % 10;
+  const tensWord = tens === 1 ? "m\u01B0\u1EDDi" : `${VIETNAMESE_NUMBERS[tens]} m\u01B0\u01A1i`;
+  if (units === 0) return tensWord;
+  if (units === 1) return `${tensWord} m\u1ED1t`;
+  if (units === 5) return `${tensWord} l\u0103m`;
+  return `${tensWord} ${VIETNAMESE_NUMBERS[units]}`;
+}
+function teamName(snapshot, teamId) {
+  const team = snapshot.teams[teamId];
+  return _nullishCoalesce(team.name, () => ( team.players.map((player) => player.name).join(" v\xE0 ")));
+}
+function numberTokens(value) {
+  if (value < 20 || value % 10 === 0) return [`number-${value}`];
+  const units = value % 10;
+  const unitToken = units === 1 ? "number-mot" : units === 5 ? "number-lam" : `number-${units}`;
+  return [`number-${Math.floor(value / 10) * 10}`, unitToken];
+}
+function scoreDeuTokens(value) {
+  if (value < 20 || value % 10 === 0) return [`score-deu-${value}`];
+  const units = value % 10;
+  const unitToken = units === 1 ? "score-deu-mot" : units === 5 ? "score-deu-lam" : `score-deu-${units}`;
+  return [`number-${Math.floor(value / 10) * 10}`, unitToken];
+}
+function doublesServerNumber(snapshot) {
+  if (snapshot.scoringMode === "sideOut") {
+    return snapshot.serve.serverNumber;
+  }
+  const servingTeam = snapshot.teams[snapshot.serve.teamId];
+  const playerIndex = servingTeam.players.findIndex(
+    (player) => player.id === snapshot.serve.playerId
+  );
+  return playerIndex === 1 ? 2 : 1;
+}
+function scorePlan(snapshot, prefix = "") {
+  const serving = snapshot.serve.teamId;
+  const receiving = serving === "A" ? "B" : "A";
+  const game = snapshot.games[snapshot.currentGame - 1];
+  if (!game) throw new TypeError("Current game is missing");
+  const servingScore = game.score[serving];
+  const receivingScore = game.score[receiving];
+  const serverNum = snapshot.format === "doubles" ? doublesServerNumber(snapshot) : 1;
+  const server = snapshot.format === "doubles" ? ` ${spokenNumber(serverNum)}` : "";
+  const fallbackTokens = [];
+  if (prefix === "\u0110\u1ED5i giao b\xF3ng") {
+    fallbackTokens.push("service-change");
+  } else if (prefix === "\u0110i\u1EC3m th\u1EAFng v\xE1n") {
+    fallbackTokens.push("game-point");
+  }
+  if (servingScore === receivingScore) {
+    fallbackTokens.push(...scoreDeuTokens(servingScore));
+  } else {
+    fallbackTokens.push(...numberTokens(servingScore));
+    fallbackTokens.push(...numberTokens(receivingScore));
+  }
+  if (snapshot.format === "doubles") {
+    fallbackTokens.push(`server-${serverNum}`);
+  }
+  const secondPart = servingScore === receivingScore ? "\u0111\u1EC1u" : spokenNumber(receivingScore);
+  const scoreBody = `${spokenNumber(servingScore).replace(/^./u, (letter) => letter.toLocaleUpperCase("vi"))} ${secondPart}${server}.`;
+  return {
+    kind: "score",
+    text: prefix ? `${prefix}, ${scoreBody.replace(/^./u, (letter) => letter.toLocaleLowerCase("vi"))}` : scoreBody,
+    score: [servingScore, receivingScore],
+    fallbackTokens
+  };
+}
+function statusPlan(kind, text, token) {
+  return { kind, text, fallbackTokens: [token] };
+}
+function buildVietnameseAnnouncement(previous, current, event) {
+  if (current.status === "completed" && previous.status !== "completed" && current.winner) {
+    return statusPlan(
+      "matchWon",
+      `\u0110\u1ED9i ${teamName(current, current.winner)} th\u1EAFng tr\u1EADn.`,
+      "match-won"
+    );
+  }
+  const previousGame = previous.games[previous.currentGame - 1];
+  const currentGame = current.games[current.currentGame - 1];
+  if (_optionalChain([currentGame, 'optionalAccess', _9 => _9.winner]) && !_optionalChain([previousGame, 'optionalAccess', _10 => _10.winner])) {
+    return statusPlan(
+      "gameWon",
+      `\u0110\u1ED9i ${teamName(current, currentGame.winner)} th\u1EAFng v\xE1n.`,
+      "game-won"
+    );
+  }
+  if (event.type === "courtSwitchConfirmed") {
+    return statusPlan("courtSwitch", "\u0110\u1ED5i s\xE2n.", "court-switch");
+  }
+  const serviceChanged = previous.serve.teamId !== current.serve.teamId;
+  if (serviceChanged) {
+    const plan = scorePlan(current, "\u0110\u1ED5i giao b\xF3ng");
+    return { ...plan, kind: "serviceChange" };
+  }
+  if (currentGame && !currentGame.winner && Math.max(currentGame.score.A, currentGame.score.B) === current.targetScore - 1) {
+    const plan = scorePlan(current, "\u0110i\u1EC3m th\u1EAFng v\xE1n");
+    return { ...plan, kind: "gamePoint" };
+  }
+  return scorePlan(current);
+}
+function planBundledFallback(plan) {
+  let tokens = plan.fallbackTokens;
+  if (plan.score) {
+    const prefixTokens = plan.fallbackTokens.filter(
+      (token) => token === "service-change" || token === "game-point"
+    );
+    const suffixTokens = plan.fallbackTokens.filter(
+      (token) => token.startsWith("server-") || token.startsWith("court-")
+    );
+    const scoreTokens = plan.score[0] === plan.score[1] ? [...scoreDeuTokens(plan.score[0])] : [...numberTokens(plan.score[0]), ...numberTokens(plan.score[1])];
+    tokens = [
+      ...prefixTokens,
+      ...scoreTokens,
+      ...suffixTokens
+    ];
+  }
+  return tokens.map((token) => `asset://voice/${token}.wav`);
+}
+
+// src/match/voice/scheduler.ts
+var LatestAnnouncementScheduler = (_class2 = class _LatestAnnouncementScheduler {
+  constructor(options) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);
+    this.options = options;
+  }
+  static __initStatic() {this.MAX_CACHE_ENTRIES = 32}
+  __init2() {this.generation = 0}
+  __init3() {this.activeController = null}
+  __init4() {this.lastPlan = null}
+  __init5() {this.neuralCache = /* @__PURE__ */ new Map()}
+  __init6() {this.operations = /* @__PURE__ */ new Set()}
+  __init7() {this.prewarmControllers = /* @__PURE__ */ new Set()}
+  __init8() {this.lifecycle = "active"}
+  __init9() {this.disposePromise = null}
+  prewarm(commonPhrases = []) {
+    if (this.lifecycle !== "active") return Promise.resolve();
+    const generation = this.generation;
+    return this.track((async () => {
+      try {
+        await this.options.engine.prewarm(commonPhrases);
+        if (this.lifecycle !== "active" || generation !== this.generation) return;
+        const availability = await this.options.engine.availability();
+        if (this.lifecycle !== "active" || generation !== this.generation) return;
+        if (availability === "available") {
+          for (const phrase of commonPhrases) {
+            if (this.lifecycle !== "active" || generation !== this.generation) return;
+            if (this.neuralCache.has(phrase)) continue;
+            const controller = new AbortController();
+            this.prewarmControllers.add(controller);
+            let file;
+            try {
+              file = await this.options.engine.synthesize(phrase, controller.signal);
+            } finally {
+              this.prewarmControllers.delete(controller);
+            }
+            if (this.lifecycle !== "active" || generation !== this.generation || controller.signal.aborted) {
+              await _optionalChain([this, 'access', _11 => _11.options, 'access', _12 => _12.engine, 'access', _13 => _13.release, 'optionalCall', _14 => _14(file)]);
+              return;
+            }
+            await this.cacheFile(phrase, file);
+          }
+        }
+      } catch (error) {
+        this.report(error);
+      }
+    })());
+  }
+  enqueue(plan) {
+    if (this.lifecycle !== "active") return Promise.resolve();
+    return this.track(this.performEnqueue(plan));
+  }
+  async performEnqueue(plan) {
+    this.lastPlan = plan;
+    const generation = ++this.generation;
+    _optionalChain([this, 'access', _15 => _15.activeController, 'optionalAccess', _16 => _16.abort, 'call', _17 => _17()]);
+    const controller = new AbortController();
+    this.activeController = controller;
+    await Promise.allSettled([
+      this.options.engine.cancel(),
+      this.options.audio.stop()
+    ]);
+    if (generation !== this.generation) return;
+    let neuralFailure = null;
+    try {
+      const avail = await this.options.engine.availability();
+      if (avail === "available") {
+        let file = this.touchCachedFile(plan.text);
+        if (!file) {
+          file = await this.options.engine.synthesize(plan.text, controller.signal);
+          await this.cacheFile(plan.text, file);
+        }
+        if (this.lifecycle !== "active" || generation !== this.generation || controller.signal.aborted) return;
+        await this.options.audio.play(file);
+        return;
+      }
+    } catch (error) {
+      if (controller.signal.aborted || generation !== this.generation) return;
+      neuralFailure = error;
+    }
+    let fallbackPlayed = false;
+    for (const source of planBundledFallback(plan)) {
+      if (generation !== this.generation || controller.signal.aborted) return;
+      try {
+        await this.options.audio.play(source);
+        fallbackPlayed = true;
+      } catch (error) {
+        this.report(error);
+      }
+    }
+    if (neuralFailure && !fallbackPlayed) this.report(neuralFailure);
+  }
+  async replayLast() {
+    if (this.lifecycle !== "active") return;
+    if (this.lastPlan) await this.enqueue(this.lastPlan);
+  }
+  testSpeaker() {
+    if (this.lifecycle !== "active") return Promise.resolve();
+    return this.track(this.performSpeakerTest());
+  }
+  async performSpeakerTest() {
+    const generation = ++this.generation;
+    _optionalChain([this, 'access', _18 => _18.activeController, 'optionalAccess', _19 => _19.abort, 'call', _20 => _20()]);
+    await Promise.allSettled([
+      this.options.engine.cancel(),
+      this.options.audio.stop()
+    ]);
+    if (generation === this.generation) {
+      try {
+        await this.options.audio.play("asset://voice/test-speaker.wav");
+      } catch (error) {
+        this.report(error);
+      }
+    }
+  }
+  async dispose() {
+    if (this.disposePromise) return this.disposePromise;
+    this.lifecycle = "disposing";
+    this.generation += 1;
+    _optionalChain([this, 'access', _21 => _21.activeController, 'optionalAccess', _22 => _22.abort, 'call', _23 => _23()]);
+    this.activeController = null;
+    for (const controller of this.prewarmControllers) controller.abort();
+    this.prewarmControllers.clear();
+    this.disposePromise = (async () => {
+      await Promise.allSettled([
+        this.options.engine.cancel(),
+        this.options.audio.stop()
+      ]);
+      await Promise.allSettled([...this.operations]);
+      await this.clearCache();
+      await Promise.allSettled([
+        this.options.engine.dispose(),
+        this.options.audio.dispose()
+      ]);
+      this.lifecycle = "disposed";
+    })();
+    return this.disposePromise;
+  }
+  async clearCache() {
+    const files = [...new Set(this.neuralCache.values())];
+    this.neuralCache.clear();
+    if (this.options.engine.release) {
+      await Promise.allSettled(files.map((file) => this.options.engine.release(file)));
+    }
+  }
+  async cacheFile(text, file) {
+    if (this.lifecycle !== "active") {
+      await _optionalChain([this, 'access', _24 => _24.options, 'access', _25 => _25.engine, 'access', _26 => _26.release, 'optionalCall', _27 => _27(file)]);
+      return;
+    }
+    const replaced = this.neuralCache.get(text);
+    if (replaced && replaced !== file) await _optionalChain([this, 'access', _28 => _28.options, 'access', _29 => _29.engine, 'access', _30 => _30.release, 'optionalCall', _31 => _31(replaced)]);
+    this.neuralCache.delete(text);
+    this.neuralCache.set(text, file);
+    while (this.neuralCache.size > _LatestAnnouncementScheduler.MAX_CACHE_ENTRIES) {
+      const oldest = this.neuralCache.entries().next().value;
+      if (!oldest) break;
+      this.neuralCache.delete(oldest[0]);
+      await _optionalChain([this, 'access', _32 => _32.options, 'access', _33 => _33.engine, 'access', _34 => _34.release, 'optionalCall', _35 => _35(oldest[1])]);
+    }
+  }
+  touchCachedFile(text) {
+    const file = this.neuralCache.get(text);
+    if (!file) return void 0;
+    this.neuralCache.delete(text);
+    this.neuralCache.set(text, file);
+    return file;
+  }
+  track(operation) {
+    this.operations.add(operation);
+    operation.then(
+      () => this.operations.delete(operation),
+      () => this.operations.delete(operation)
+    );
+    return operation;
+  }
+  report(caught) {
+    const error = caught instanceof Error ? caught : new Error("Voice operation failed");
+    try {
+      _optionalChain([this, 'access', _36 => _36.options, 'access', _37 => _37.onError, 'optionalCall', _38 => _38(error)]);
+    } catch (e11) {
+    }
+  }
+}, _class2.__initStatic(), _class2);
+
+// src/match/voice/service.ts
+function removeDirectory(path) {
+  const fs = _chunk7OX2DSKIcjs.__require.call(void 0, "expo-file-system");
+  const info = fs.Paths.info(path);
+  if (!info.exists) return;
+  if (info.isDirectory) new fs.Directory(path).delete();
+  else new fs.File(path).delete();
+}
+function createDefaultMatchVoiceService(options = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  let lastError = null;
+  let disposed = false;
+  let lifecycle = "active";
+  let initialized = false;
+  let operationTail = Promise.resolve();
+  let disposePromise = null;
+  let notificationQueue = Promise.resolve();
+  const audio = _nullishCoalesce(options.audio, () => ( createExpoAudioPlayback({ resolveSource: resolveBundledVoiceAsset })));
+  const generatedDirectory = () => _nullishCoalesce(options.generatedRoot, () => ( `${_chunk7OX2DSKIcjs.__require.call(void 0, "expo-file-system").Paths.cache.uri}/pickleball-voice-generated/gemini`));
+  const engine = _nullishCoalesce(options.engine, () => ( (options.tts ? createGeminiVoiceEngine({ ...options.tts, generatedRoot: generatedDirectory() }) : createUnavailableVoiceEngine())));
+  let errorEpoch = 0;
+  const scheduler = new LatestAnnouncementScheduler({
+    engine,
+    audio,
+    onError(error) {
+      lastError = error;
+      errorEpoch += 1;
+      enqueueNotify();
+    }
+  });
+  function notify() {
+    for (const listener of listeners) listener();
+  }
+  function enqueueNotify() {
+    notificationQueue = notificationQueue.then(() => {
+      if (!disposed) notify();
+    });
+  }
+  const unsubscribeAudio = _optionalChain([audio, 'access', _39 => _39.subscribeToRouteChanges, 'optionalCall', _40 => _40(() => enqueueNotify())]);
+  async function sweepGeneratedAudio() {
+    await scheduler.clearCache();
+    try {
+      if (options.removeGeneratedDirectory) {
+        await options.removeGeneratedDirectory(generatedDirectory());
+      } else {
+        removeDirectory(generatedDirectory());
+      }
+    } catch (e12) {
+    }
+  }
+  function runActive(operation) {
+    if (lifecycle !== "active") return Promise.resolve();
+    const result = operationTail.then(async () => {
+      if (lifecycle === "active") await operation();
+    });
+    operationTail = result.catch(() => void 0);
+    return result;
+  }
+  const stillActive = () => lifecycle === "active";
+  return {
+    get audioState() {
+      return audio.getRouteState();
+    },
+    get lastError() {
+      return lastError;
+    },
+    initialize: () => runActive(async () => {
+      if (initialized) return;
+      await audio.configure(_nullishCoalesce(options.audioMode, () => ( "offline")));
+      if (!stillActive()) return;
+      await sweepGeneratedAudio();
+      if (!stillActive()) return;
+      await scheduler.prewarm(["\u0110\u1ED5i giao b\xF3ng.", "\u0110i\u1EC3m th\u1EAFng v\xE1n.", "\u0110\u1ED5i s\xE2n."]);
+      if (!stillActive()) return;
+      initialized = true;
+      notify();
+    }),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    announce(previous, current, event) {
+      if (!stillActive()) return;
+      const epochBefore = errorEpoch;
+      void scheduler.enqueue(buildVietnameseAnnouncement(previous, current, event)).then(
+        () => {
+          if (lastError && errorEpoch === epochBefore && stillActive()) {
+            lastError = null;
+            notify();
+          }
+        },
+        (error) => {
+          lastError = error instanceof Error ? error : new Error("Announcement failed");
+          notify();
+        }
+      );
+    },
+    replayAnnouncement: () => stillActive() ? scheduler.replayLast() : Promise.resolve(),
+    testSpeaker: () => stillActive() ? scheduler.testSpeaker() : Promise.resolve(),
+    configureAudioMode: (mode) => runActive(async () => {
+      await audio.configure(mode);
+      if (stillActive()) enqueueNotify();
+    }),
+    dispose() {
+      if (disposePromise) return disposePromise;
+      lifecycle = "disposing";
+      disposed = true;
+      _optionalChain([unsubscribeAudio, 'optionalCall', _41 => _41()]);
+      disposePromise = (async () => {
+        await operationTail;
+        await scheduler.dispose();
+        await notificationQueue;
+        listeners.clear();
+        lifecycle = "disposed";
+      })();
+      return disposePromise;
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.VoiceError = VoiceError; exports.createExpoAudioPlayback = createExpoAudioPlayback; exports.resolveBundledVoiceAsset = resolveBundledVoiceAsset; exports.createGeminiVoiceEngine = createGeminiVoiceEngine; exports.createUnavailableVoiceEngine = createUnavailableVoiceEngine; exports.buildVietnameseAnnouncement = buildVietnameseAnnouncement; exports.planBundledFallback = planBundledFallback; exports.LatestAnnouncementScheduler = LatestAnnouncementScheduler; exports.createDefaultMatchVoiceService = createDefaultMatchVoiceService;