@alia.onl/sdk 7.2.9 → 10.0.0

package/src/lib/speech-recognition.native.ts

@@ -0,0 +1,226 @@
+/**
+ * On-device speech recognition for iOS and Android, through
+ * `expo-speech-recognition` (Apple's Speech framework, Android's
+ * `SpeechRecognizer`). Metro picks this file over `speech-recognition.ts` on
+ * native; the contract is `speech-recognition-types.ts`.
+ *
+ * `expo-speech-recognition` is a peer of the SDK and a native module: an app
+ * must depend on it (the root entry's dictation reaches this file) and list its
+ * config plugin (which writes `NSSpeechRecognitionUsageDescription`,
+ * `NSMicrophoneUsageDescription` and Android's `RECORD_AUDIO` plus the
+ * recognizer-package visibility query), then ship a new native build.
+ *
+ * The module is a process-wide singleton — one recognition at a time — so the
+ * hooks never start a session before the previous one has reported `onEnd`. A
+ * late `end` from an aborted session would otherwise land on its successor's
+ * listeners.
+ */
+
+import type { ExpoSpeechRecognitionErrorCode, ExpoSpeechRecognitionModule as NativeModule } from 'expo-speech-recognition';
+import {
+  clampLevel,
+  matchSpeechLocale,
+  type SpeechRecognizerChoice,
+  type SpeechRecognitionFailure,
+  type SpeechRecognitionFailureCode,
+  type SpeechRecognitionHandlers,
+  type SpeechRecognitionOptions,
+  type SpeechRecognitionSession,
+} from './speech-recognition-types';
+
+type SpeechModule = typeof NativeModule;
+
+let loaded: SpeechModule | null | undefined;
+
+/**
+ * The native module, loaded on first use — never at import.
+ *
+ * `expo-speech-recognition` calls `requireNativeModule` when it is imported,
+ * which THROWS in a binary built before the module was added (an older dev
+ * client, Expo Go). This file is reachable from the SDK's root entry through
+ * dictation, so a top-level import would take the whole app down in such a
+ * build over a feature nobody had touched yet. Loaded here, the same build
+ * answers "not available" and everything else keeps working.
+ */
+function speechModule(): SpeechModule | null {
+  if (loaded !== undefined) return loaded;
+  try {
+    loaded = (require('expo-speech-recognition') as typeof import('expo-speech-recognition'))
+      .ExpoSpeechRecognitionModule;
+  } catch {
+    loaded = null;
+  }
+  return loaded;
+}
+
+export function isSpeechRecognitionAvailable(): boolean {
+  try {
+    return speechModule()?.isRecognitionAvailable() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+export async function requestSpeechRecognitionPermission(): Promise<SpeechRecognitionFailure | null> {
+  const module = speechModule();
+  if (module === null || !isSpeechRecognitionAvailable()) return { code: 'unsupported' };
+  try {
+    const permission = await module.requestPermissionsAsync();
+    return permission.granted ? null : { code: 'not-allowed', detail: permission.status };
+  } catch (error: unknown) {
+    return { code: 'other', detail: error instanceof Error ? error.message : 'permission request failed' };
+  }
+}
+
+function failureOf(error: ExpoSpeechRecognitionErrorCode): SpeechRecognitionFailureCode {
+  switch (error) {
+    case 'not-allowed':
+    case 'service-not-allowed':
+      return 'not-allowed';
+    case 'audio-capture':
+      return 'audio-capture';
+    case 'network':
+      return 'network';
+    case 'language-not-supported':
+      return 'language-not-supported';
+    case 'no-speech':
+    case 'speech-timeout':
+      return 'no-speech';
+    case 'aborted':
+      return 'aborted';
+    default:
+      return 'other';
+  }
+}
+
+/** `volumechange` is -2..10, and anything below 0 is inaudible. */
+const VOLUME_CEILING = 10;
+
+/**
+ * Which recognizer to use for `lang`, and the tag it knows the language by.
+ *
+ * Android leaves recognition to whichever service the device has, and
+ * `SpeechRecognizer` answers a language it cannot do only by failing:
+ * `language-not-supported`, which dictation showed as "does not support this
+ * language" whatever the real reason. On a Pixel the default service is often
+ * Android System Intelligence, which recognizes only the languages whose
+ * packs are downloaded, while another service on the same phone (Google's
+ * speech services) could have done it. So each service is asked what it
+ * recognizes — the default first — and the first that has the language wins,
+ * under the spelling it uses; a service offering only another region of the
+ * language (`es-US` for `es-ES`) is taken over failing.
+ *
+ * A service that reports nothing (Android 12 and older, a service that does
+ * not implement the query) proves nothing, so when none reports, the default
+ * is tried as before, with `silent` set if there were services to ask. iOS has
+ * none to list and goes straight to Apple's recognizer.
+ */
+export async function chooseSpeechRecognizer(lang: string): Promise<SpeechRecognizerChoice> {
+  const module = speechModule();
+  if (module === null) return { failure: { code: 'unsupported' } };
+  const attempt = <T>(read: () => T, fallback: T): T => {
+    try {
+      return read();
+    } catch {
+      return fallback;
+    }
+  };
+  const preferred = attempt(() => module.getDefaultRecognitionService().packageName, '');
+  const services = attempt(() => module.getSpeechRecognitionServices(), [] as string[]);
+  const order = [...new Set([preferred, ...services].filter((name) => name !== ''))];
+
+  let reported = false;
+  let asked = 0;
+  for (const service of order) {
+    let offered: string[];
+    try {
+      offered = (await module.getSupportedLocales({ androidRecognitionServicePackage: service })).locales;
+    } catch {
+      continue;
+    }
+    asked += 1;
+    if (offered.length === 0) continue;
+    reported = true;
+    const tag = matchSpeechLocale(lang, offered);
+    if (tag !== null) return { lang: tag, service, silent: false };
+  }
+  if (reported) return { failure: { code: 'language-not-supported' } };
+  return { lang, silent: asked > 0 };
+}
+
+export function startSpeechRecognition(
+  options: SpeechRecognitionOptions,
+  handlers: SpeechRecognitionHandlers,
+): SpeechRecognitionSession {
+  const module = speechModule();
+  if (module === null) {
+    handlers.onError({ code: 'unsupported' });
+    handlers.onEnd();
+    return { stop: () => undefined, abort: () => undefined };
+  }
+  const ExpoSpeechRecognitionModule = module;
+  let ended = false;
+  /**
+   * Finals already delivered. Android's continuous mode starts a new segment
+   * after every final result, so the utterance is the settled segments plus
+   * whatever is still in flight; iOS only finalizes on stop and always sends
+   * the whole transcript, so this stays empty there.
+   */
+  let settled = '';
+
+  const subscriptions = [
+    ExpoSpeechRecognitionModule.addListener('result', (event) => {
+      if (ended) return;
+      const current = event.results[0]?.transcript ?? '';
+      const transcript = `${settled} ${current}`.replace(/\s+/g, ' ').trim();
+      if (event.isFinal) settled = transcript;
+      handlers.onResult({ transcript, isFinal: event.isFinal });
+    }),
+    ExpoSpeechRecognitionModule.addListener('error', (event) => {
+      if (ended) return;
+      const code = failureOf(event.error);
+      if (code === 'aborted') return;
+      handlers.onError({ code, detail: event.message });
+    }),
+    ExpoSpeechRecognitionModule.addListener('end', () => finish()),
+    ExpoSpeechRecognitionModule.addListener('volumechange', (event) => {
+      if (ended) return;
+      handlers.onLevel?.(clampLevel(event.value / VOLUME_CEILING));
+    }),
+  ];
+
+  function finish(): void {
+    if (ended) return;
+    ended = true;
+    for (const subscription of subscriptions) subscription.remove();
+    handlers.onLevel?.(0);
+    handlers.onEnd();
+  }
+
+  try {
+    ExpoSpeechRecognitionModule.start({
+      lang: options.lang,
+      ...(options.service ? { androidRecognitionServicePackage: options.service } : {}),
+      interimResults: true,
+      continuous: true,
+      addsPunctuation: true,
+      maxAlternatives: 1,
+      volumeChangeEventOptions: { enabled: handlers.onLevel !== undefined, intervalMillis: 100 },
+      ...(options.echoCancellation ? { iosVoiceProcessingEnabled: true } : {}),
+    });
+  } catch (error: unknown) {
+    if (!ended) handlers.onError({ code: 'other', detail: error instanceof Error ? error.message : 'start failed' });
+    finish();
+  }
+
+  return {
+    stop() {
+      if (ended) return;
+      ExpoSpeechRecognitionModule.stop();
+    },
+    abort() {
+      if (ended) return;
+      ExpoSpeechRecognitionModule.abort();
+    },
+  };
+}

package/src/lib/speech-recognition.ts

@@ -0,0 +1,288 @@
+/**
+ * On-device speech recognition for the web: the browser's Web Speech API.
+ *
+ * Metro resolves `speech-recognition.native.ts` on iOS and Android, so this
+ * file is what a web bundle — and every test — gets. See
+ * `speech-recognition-types.ts` for the contract both implement.
+ *
+ * ## Why a microphone stream is opened beside the recognizer
+ *
+ * The Web Speech API reports words, not sound: there is no level event, and a
+ * refused or missing microphone surfaces as a bare `not-allowed` or
+ * `audio-capture` with nothing to tell "blocked" from "busy". Opening the
+ * microphone first with `getUserMedia` answers both. It is where the browser
+ * asks for permission (once — the recognizer shares the origin's grant), its
+ * DOMException names say exactly what is wrong, and an `AnalyserNode` on the
+ * stream is the honest level the dictation trace and the voice field move to.
+ * The stream is never recorded or sent anywhere.
+ *
+ * ## Support
+ *
+ * Chromium browsers and Safari implement it (Chrome as `webkitSpeechRecognition`
+ * and through a Google speech service; Safari through Apple's). Firefox does
+ * not, and `isSpeechRecognitionAvailable()` says so before anything asks for a
+ * microphone.
+ */
+
+import { levelFromDbfs } from './audio-level';
+import type {
+  SpeechRecognitionFailure,
+  SpeechRecognitionFailureCode,
+  SpeechRecognitionHandlers,
+  SpeechRecognitionOptions,
+  SpeechRecognitionSession,
+  SpeechRecognizerChoice,
+} from './speech-recognition-types';
+
+// ── The slice of the Web Speech API this uses ──
+// Declared here rather than taken from lib.dom: TypeScript's DOM library does
+// not ship the prefixed constructor, and the unprefixed one is not everywhere.
+
+interface WebSpeechAlternative { readonly transcript: string }
+interface WebSpeechResult { readonly isFinal: boolean; readonly length: number; readonly [index: number]: WebSpeechAlternative }
+interface WebSpeechResultList { readonly length: number; readonly [index: number]: WebSpeechResult }
+interface WebSpeechResultEvent { readonly results: WebSpeechResultList }
+interface WebSpeechErrorEvent { readonly error: string; readonly message?: string }
+
+interface WebSpeechRecognition {
+  lang: string;
+  continuous: boolean;
+  interimResults: boolean;
+  maxAlternatives: number;
+  onresult: ((event: WebSpeechResultEvent) => void) | null;
+  onerror: ((event: WebSpeechErrorEvent) => void) | null;
+  onend: (() => void) | null;
+  start(): void;
+  stop(): void;
+  abort(): void;
+}
+
+type WebSpeechRecognitionConstructor = new () => WebSpeechRecognition;
+
+function recognitionConstructor(): WebSpeechRecognitionConstructor | null {
+  const scope = globalThis as unknown as {
+    SpeechRecognition?: WebSpeechRecognitionConstructor;
+    webkitSpeechRecognition?: WebSpeechRecognitionConstructor;
+  };
+  return scope.SpeechRecognition ?? scope.webkitSpeechRecognition ?? null;
+}
+
+/** Whether this browser can recognize speech at all. Firefox cannot. */
+export function isSpeechRecognitionAvailable(): boolean {
+  return recognitionConstructor() !== null;
+}
+
+/**
+ * Ask for the microphone before a session needs it.
+ *
+ * The browser asks once per origin; `startSpeechRecognition` opens the stream
+ * itself, so this is only for callers that want the answer up front (voice mode
+ * does, so a refusal ends the call before it starts rather than on the first
+ * word).
+ */
+export async function requestSpeechRecognitionPermission(): Promise<SpeechRecognitionFailure | null> {
+  if (!isSpeechRecognitionAvailable()) return { code: 'unsupported' };
+  const media = globalThis.navigator?.mediaDevices;
+  if (media?.getUserMedia === undefined) return null;
+  try {
+    const stream = await media.getUserMedia({ audio: true });
+    for (const track of stream.getTracks()) track.stop();
+    return null;
+  } catch (error: unknown) {
+    return mediaFailure(error);
+  }
+}
+
+function domErrorName(error: unknown): string {
+  // A DOMException is not always `instanceof Error`, so read `.name` off the object.
+  if (typeof error === 'object' && error !== null && 'name' in error && typeof error.name === 'string') {
+    return error.name;
+  }
+  return '';
+}
+
+function mediaFailure(error: unknown): SpeechRecognitionFailure {
+  const name = domErrorName(error);
+  switch (name) {
+    case 'NotAllowedError':
+    case 'PermissionDeniedError':
+    case 'SecurityError':
+      return { code: 'not-allowed', detail: name };
+    case 'NotFoundError':
+    case 'DevicesNotFoundError':
+    case 'OverconstrainedError':
+    case 'NotReadableError':
+    case 'TrackStartError':
+      return { code: 'audio-capture', detail: name };
+    default:
+      return { code: 'other', detail: name || 'getUserMedia failed' };
+  }
+}
+
+function recognitionFailure(event: WebSpeechErrorEvent): SpeechRecognitionFailure {
+  const map: Record<string, SpeechRecognitionFailureCode> = {
+    'not-allowed': 'not-allowed',
+    'service-not-allowed': 'not-allowed',
+    'audio-capture': 'audio-capture',
+    network: 'network',
+    'language-not-supported': 'language-not-supported',
+    'no-speech': 'no-speech',
+    aborted: 'aborted',
+  };
+  return { code: map[event.error] ?? 'other', detail: event.error };
+}
+
+/** Everything heard so far, as one string: Chrome segments carry their own leading spaces. */
+function transcriptOf(results: WebSpeechResultList): { transcript: string; isFinal: boolean } {
+  let transcript = '';
+  let isFinal = results.length > 0;
+  for (let index = 0; index < results.length; index += 1) {
+    const result = results[index];
+    if (result === undefined) continue;
+    transcript += result[0]?.transcript ?? '';
+    if (!result.isFinal) isFinal = false;
+  }
+  return { transcript: transcript.replace(/\s+/g, ' ').trim(), isFinal };
+}
+
+const LEVEL_INTERVAL_MS = 100;
+
+/** An analyser on the microphone, polled on a clock. Returns its teardown. */
+function meterStream(stream: MediaStream, onLevel: (level: number) => void): () => void {
+  const AudioContextCtor = (globalThis as unknown as { AudioContext?: typeof AudioContext }).AudioContext;
+  if (AudioContextCtor === undefined) return () => undefined;
+  let context: AudioContext;
+  try {
+    context = new AudioContextCtor();
+  } catch {
+    return () => undefined;
+  }
+  if (context.state === 'suspended') context.resume().catch(() => undefined);
+  const analyser = context.createAnalyser();
+  analyser.fftSize = 512;
+  context.createMediaStreamSource(stream).connect(analyser);
+  const buffer = new Float32Array(analyser.fftSize);
+  const timer = setInterval(() => {
+    analyser.getFloatTimeDomainData(buffer);
+    let sum = 0;
+    for (let index = 0; index < buffer.length; index += 1) sum += buffer[index] * buffer[index];
+    const rms = Math.sqrt(sum / buffer.length);
+    onLevel(rms > 0 ? levelFromDbfs(20 * Math.log10(rms)) : 0);
+  }, LEVEL_INTERVAL_MS);
+  return () => {
+    clearInterval(timer);
+    context.close().catch(() => undefined);
+  };
+}
+
+/**
+ * Listen until stopped.
+ *
+ * Continuous with interim results: the caller decides when an utterance is
+ * over (voice mode on a silence timer, dictation on the stop button), because
+ * the browser's own end-of-speech detection cuts people off mid-thought.
+ */
+/**
+ * The browser has one recognizer and no way to ask it which languages it
+ * knows: the language goes as given (see the native file for Android's).
+ */
+export async function chooseSpeechRecognizer(lang: string): Promise<SpeechRecognizerChoice> {
+  return { lang, silent: false };
+}
+
+export function startSpeechRecognition(
+  options: SpeechRecognitionOptions,
+  handlers: SpeechRecognitionHandlers,
+): SpeechRecognitionSession {
+  let recognition: WebSpeechRecognition | null = null;
+  let stream: MediaStream | null = null;
+  let stopMeter: (() => void) | null = null;
+  let ended = false;
+  let stopRequested: 'stop' | 'abort' | null = null;
+
+  const release = (): void => {
+    stopMeter?.();
+    stopMeter = null;
+    if (stream !== null) for (const track of stream.getTracks()) track.stop();
+    stream = null;
+  };
+
+  const finish = (): void => {
+    if (ended) return;
+    ended = true;
+    release();
+    handlers.onLevel?.(0);
+    handlers.onEnd();
+  };
+
+  const fail = (failure: SpeechRecognitionFailure): void => {
+    if (ended) return;
+    handlers.onError(failure);
+    finish();
+  };
+
+  void (async () => {
+    const Recognition = recognitionConstructor();
+    if (Recognition === null) {
+      fail({ code: 'unsupported' });
+      return;
+    }
+
+    const media = globalThis.navigator?.mediaDevices;
+    if (media?.getUserMedia !== undefined) {
+      try {
+        stream = await media.getUserMedia({
+          audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true },
+        });
+      } catch (error: unknown) {
+        fail(mediaFailure(error));
+        return;
+      }
+      if (stopRequested !== null) {
+        finish();
+        return;
+      }
+      if (handlers.onLevel !== undefined) stopMeter = meterStream(stream, handlers.onLevel);
+    }
+
+    const instance = new Recognition();
+    recognition = instance;
+    instance.lang = options.lang;
+    instance.continuous = true;
+    instance.interimResults = true;
+    instance.maxAlternatives = 1;
+    instance.onresult = (event) => {
+      if (ended) return;
+      handlers.onResult(transcriptOf(event.results));
+    };
+    instance.onerror = (event) => {
+      if (ended) return;
+      const failure = recognitionFailure(event);
+      if (failure.code === 'aborted') return;
+      handlers.onError(failure);
+    };
+    instance.onend = finish;
+    try {
+      instance.start();
+    } catch (error: unknown) {
+      fail({ code: 'other', detail: domErrorName(error) || 'start failed' });
+      return;
+    }
+    if (stopRequested === 'stop') instance.stop();
+    if (stopRequested === 'abort') instance.abort();
+  })();
+
+  return {
+    stop() {
+      if (ended) return;
+      stopRequested = 'stop';
+      recognition?.stop();
+    },
+    abort() {
+      if (ended) return;
+      stopRequested = 'abort';
+      if (recognition === null) return;
+      recognition.abort();
+    },
+  };
+}

package/src/lib/speech-synthesis.ts

@@ -0,0 +1,122 @@
+/**
+ * Speech out: ask `POST /v1/audio/speech` for a clip, and play one.
+ *
+ * Shared by read-aloud (`useTTS`) and voice mode (`useVoiceRoom`) so both speak
+ * through the one route Alia has for it — Alia → Oxy → Kaana, billed by Oxy per
+ * call — with the same request body and the same error copy. Voice names are
+ * the PRODUCT's (`male` / `female`); the route maps them, and no upstream voice
+ * name ever appears on this side.
+ */
+
+import { createAudioLevelMeter } from './audio-level';
+
+export type ProductVoice = 'male' | 'female';
+
+export interface SpeechClipRequest {
+  readonly apiUrl: string;
+  readonly token: string;
+  /** A speech model; omitted, the server's own speech model answers. */
+  readonly model?: string;
+  readonly input: string;
+  readonly voice: ProductVoice;
+  readonly speed?: number;
+  /** Both or neither: the route stores the clip on that message when given. */
+  readonly conversationId?: string;
+  readonly messageId?: string;
+  readonly signal: AbortSignal;
+}
+
+/** Synthesize `input` and return the private link the route answers with. */
+export async function requestSpeechClip(request: SpeechClipRequest): Promise<string> {
+  const response = await fetch(`${request.apiUrl}/v1/audio/speech`, {
+    method: 'POST',
+    signal: request.signal,
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${request.token}`,
+    },
+    body: JSON.stringify({
+      model: request.model,
+      input: request.input,
+      voice: request.voice,
+      speed: request.speed,
+      conversationId: request.conversationId,
+      messageId: request.messageId,
+    }),
+  });
+
+  if (!response.ok) {
+    if (response.status === 504) {
+      throw new Error('Request timed out — please try again');
+    }
+    const errData = await response.json().catch(() => ({}));
+    throw new Error(errData.error?.message || errData.error || 'TTS failed');
+  }
+
+  const data = (await response.json()) as { audioUrl?: unknown };
+  request.signal.throwIfAborted();
+  if (typeof data.audioUrl !== 'string' || data.audioUrl === '') throw new Error('TTS failed');
+  return data.audioUrl;
+}
+
+export interface PlayClipOptions {
+  readonly signal: AbortSignal;
+  /** The clip's live level, 0..1, where the platform lets playback be sampled. */
+  readonly onLevel?: (level: number) => void;
+}
+
+/**
+ * Play one clip to its end.
+ *
+ * Resolves when it finishes or when `signal` aborts (the player is released
+ * either way — an interrupted answer stops at once), and rejects if the player
+ * reports an error. `crossOrigin` and sampling are set as `useTTS` sets them;
+ * its comments explain why.
+ */
+export async function playSpeechClip(uri: string, options: PlayClipOptions): Promise<void> {
+  const { signal, onLevel } = options;
+  if (signal.aborted) return;
+  const { createAudioPlayer } = await import('expo-audio');
+  if (signal.aborted) return;
+
+  const player = createAudioPlayer({ uri }, { crossOrigin: 'anonymous' });
+  const release = (): void => {
+    try {
+      player.remove();
+    } catch {
+      // Already removed.
+    }
+  };
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const onAbort = (): void => resolve();
+      signal.addEventListener('abort', onAbort, { once: true });
+      const settle = (settleWith: () => void): void => {
+        signal.removeEventListener('abort', onAbort);
+        settleWith();
+      };
+
+      if (onLevel !== undefined) {
+        player.setAudioSamplingEnabled(true);
+        const meter = createAudioLevelMeter();
+        player.addListener('audioSampleUpdate', (sample) => {
+          const frames = sample.channels[0]?.frames;
+          if (frames === undefined) return;
+          onLevel(meter.push(frames, Date.now()));
+        });
+      }
+      player.addListener('playbackStatusUpdate', (status) => {
+        if (status.error) {
+          settle(() => reject(new Error(String(status.error))));
+          return;
+        }
+        if (status.didJustFinish) settle(resolve);
+      });
+      player.play();
+    });
+  } finally {
+    release();
+    onLevel?.(0);
+  }
+}

package/src/lib/voice-levels.ts

@@ -0,0 +1,60 @@
+import { clampLevel } from './speech-recognition-types';
+
+/**
+ * The two live levels of a voice call — what the microphone hears and what the
+ * call is saying — for whatever draws them.
+ *
+ * It replaced the LiveKit `Room` that `useAudioLevelMonitor` used to take and
+ * put analysers on. The voice loop writes here from the recognizer's level
+ * events and the clip player's samples; the monitor subscribes and hands React
+ * a throttled copy. Writes are cheap and never render anything by themselves.
+ */
+export interface VoiceLevelSource {
+  readonly capture: number;
+  readonly playback: number;
+  subscribe(listener: () => void): () => void;
+}
+
+export class VoiceLevelChannel implements VoiceLevelSource {
+  private captureLevel = 0;
+  private playbackLevel = 0;
+  private readonly listeners = new Set<() => void>();
+
+  get capture(): number {
+    return this.captureLevel;
+  }
+
+  get playback(): number {
+    return this.playbackLevel;
+  }
+
+  setCapture(level: number): void {
+    const next = clampLevel(level);
+    if (next === this.captureLevel) return;
+    this.captureLevel = next;
+    this.emit();
+  }
+
+  setPlayback(level: number): void {
+    const next = clampLevel(level);
+    if (next === this.playbackLevel) return;
+    this.playbackLevel = next;
+    this.emit();
+  }
+
+  reset(): void {
+    this.setCapture(0);
+    this.setPlayback(0);
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  private emit(): void {
+    for (const listener of this.listeners) listener();
+  }
+}