Chat

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249export type VoiceSessionState = "idle" | "requesting" | "recording" | "stopping" | "ready" | "error";

export interface VoiceSnapshot {
  state: VoiceSessionState;
  elapsedMs: number;
  audio: Blob | null;
  error: string | null;
}

export interface VoiceSessionOptions {
  getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
  MediaRecorder?: typeof globalThis.MediaRecorder;
  now?: () => number;
  setInterval?: typeof globalThis.setInterval;
  clearInterval?: typeof globalThis.clearInterval;
  createObjectURL?: (blob: Blob) => string;
  revokeObjectURL?: (url: string) => void;
}

type Listener = (snapshot: VoiceSnapshot) => void;
type RecorderEvent = Event & { data?: Blob };

const initialSnapshot = (): VoiceSnapshot => ({ state: "idle", elapsedMs: 0, audio: null, error: null });

/** Caller-owned browser recording lifecycle. No recorder provider or upload policy is implied. */
export class VoiceSession {
  private readonly options: Required<Pick<VoiceSessionOptions, "now" | "setInterval" | "clearInterval">> & VoiceSessionOptions;
  private snapshot: VoiceSnapshot = initialSnapshot();
  private listeners = new Set<Listener>();
  private stream: MediaStream | null = null;
  private recorder: MediaRecorder | null = null;
  private recorderListeners: {
    recorder: MediaRecorder;
    data: (event: Event) => void;
    error: () => void;
    stop: () => void;
  } | null = null;
  private chunks: Blob[] = [];
  private timer: ReturnType<typeof globalThis.setInterval> | null = null;
  private generation = 0;
  private activeGeneration = 0;
  private startedAt = 0;
  private stoppedElapsedMs: number | null = null;
  private stopRequested = false;
  private disposed = false;
  private objectUrl: string | null = null;

  constructor(options: VoiceSessionOptions = {}) {
    this.options = {
      now: Date.now,
      setInterval: globalThis.setInterval.bind(globalThis),
      clearInterval: globalThis.clearInterval.bind(globalThis),
      ...options,
    };
  }

  getSnapshot(): VoiceSnapshot { return this.snapshot; }

  subscribe(listener: Listener): () => void {
    this.listeners.add(listener);
    listener(this.snapshot);
    return () => this.listeners.delete(listener);
  }

  async start(): Promise<void> {
    if (this.disposed || this.snapshot.state === "requesting" || this.snapshot.state === "recording" || this.snapshot.state === "stopping") return;

    const generation = ++this.generation;
    this.activeGeneration = generation;
    this.cleanupRecorder();
    this.set({ state: "requesting", elapsedMs: 0, audio: null, error: null });

    const getUserMedia = this.options.getUserMedia ?? globalThis.navigator?.mediaDevices?.getUserMedia?.bind(globalThis.navigator.mediaDevices);
    const Recorder = this.options.MediaRecorder ?? globalThis.MediaRecorder;
    if (!getUserMedia || !Recorder) {
      this.fail(generation, "Voice recording is not supported in this browser.");
      return;
    }

    try {
      const stream = await getUserMedia({ audio: true });
      if (!this.isCurrent(generation, "requesting")) {
        this.stopStream(stream);
        return;
      }

      this.stream = stream;
      this.chunks = [];
      const recorder = new Recorder(stream);
      this.recorder = recorder;
      this.stopRequested = false;
      this.stoppedElapsedMs = null;
      const data = (event: Event) => {
        if (!this.isCurrentRecorder(generation, recorder)) return;
        const blob = (event as RecorderEvent).data;
        if (blob?.size) this.chunks.push(blob);
      };
      const error = () => {
        if (this.isCurrentRecorder(generation, recorder)) this.fail(generation, "Recording stopped because the browser reported an error.");
      };
      const stop = () => {
        if (this.isCurrentRecorder(generation, recorder)) this.finishRecording(generation, recorder);
      };
      this.recorderListeners = { recorder, data, error, stop };
      recorder.addEventListener("dataavailable", data);
      recorder.addEventListener("error", error);
      recorder.addEventListener("stop", stop);
      this.startedAt = this.options.now();
      this.set({ state: "recording", elapsedMs: 0, audio: null, error: null });
      try {
        recorder.start();
      } catch {
        this.fail(generation, "Recording could not be started.");
        return;
      }
      if (!this.isCurrentRecorder(generation, recorder)) return;
      this.timer = this.options.setInterval(() => {
        if (this.isCurrent(generation, "recording") && !this.stopRequested) this.updateElapsed();
      }, 250);
    } catch (error) {
      if (!this.isCurrent(generation, "requesting")) return;
      this.fail(generation, error instanceof DOMException && error.name === "NotAllowedError" ? "Microphone permission was denied." : "Microphone access could not be started.");
    }
  }

  stop(): void {
    if (this.snapshot.state !== "recording" || !this.recorder || this.stopRequested) return;
    this.stopRequested = true;
    this.stopTimer();
    this.stoppedElapsedMs = Math.max(this.snapshot.elapsedMs, this.options.now() - this.startedAt);
    this.set({ state: "stopping", elapsedMs: this.stoppedElapsedMs });
    try {
      this.recorder.stop();
    } catch {
      this.fail(this.activeGeneration, "Recording could not be stopped.");
    }
  }

  cancel(): void {
    if (this.snapshot.state === "idle") return;
    ++this.generation;
    this.activeGeneration = 0;
    this.stopTimer();
    this.set(initialSnapshot());
    this.cleanupRecorder();
  }

  clear(): void { this.cancel(); }

  dispose(): void {
    if (this.disposed) return;
    ++this.generation;
    this.activeGeneration = 0;
    this.disposed = true;
    this.cleanupRecorder();
    this.listeners.clear();
  }

  private finishRecording(generation: number, recorder: MediaRecorder) {
    if (!this.isCurrentRecorder(generation, recorder)) return;
    this.stopTimer();
    const elapsedMs = this.stoppedElapsedMs ?? Math.max(this.snapshot.elapsedMs, this.options.now() - this.startedAt);
    const type = recorder.mimeType || "audio/webm";
    const audio = new Blob(this.chunks, { type });
    this.detachRecorder(recorder);
    this.recorder = null;
    this.chunks = [];
    this.cleanupTracks();
    this.stopRequested = false;
    this.stoppedElapsedMs = null;
    if (!audio.size) {
      this.fail(this.activeGeneration, "No audio was captured. Try recording again.");
      return;
    }
    this.objectUrl = this.options.createObjectURL?.(audio) ?? null;
    this.set({ state: "ready", elapsedMs, audio, error: null });
  }

  private fail(generation: number, error: string) {
    if (generation !== this.activeGeneration || this.disposed) return;
    this.stopTimer();
    this.cleanupRecorder();
    this.set({ state: "error", audio: null, error });
  }

  private updateElapsed() {
    this.set({ elapsedMs: Math.max(0, this.options.now() - this.startedAt) });
  }

  private isCurrent(generation: number, state: VoiceSessionState): boolean {
    return !this.disposed && generation === this.activeGeneration && this.snapshot.state === state;
  }

  private isCurrentRecorder(generation: number, recorder: MediaRecorder): boolean {
    return !this.disposed && generation === this.activeGeneration && this.recorder === recorder && (this.snapshot.state === "recording" || this.snapshot.state === "stopping");
  }

  private stopStream(stream: MediaStream) { stream.getTracks().forEach((track) => track.stop()); }

  private detachRecorder(recorder = this.recorder) {
    const registration = this.recorderListeners;
    if (!registration || registration.recorder !== recorder) return;
    registration.recorder.removeEventListener("dataavailable", registration.data);
    registration.recorder.removeEventListener("error", registration.error);
    registration.recorder.removeEventListener("stop", registration.stop);
    this.recorderListeners = null;
  }

  private stopTimer() {
    if (this.timer !== null) {
      this.options.clearInterval(this.timer);
      this.timer = null;
    }
  }

  private cleanupTracks() {
    if (this.stream) this.stopStream(this.stream);
    this.stream = null;
  }

  private cleanupRecorder() {
    this.stopTimer();
    const recorder = this.recorder;
    this.detachRecorder(recorder);
    this.recorder = null;
    this.chunks = [];
    this.stopRequested = false;
    this.stoppedElapsedMs = null;
    if (recorder && recorder.state !== "inactive") {
      try { recorder.stop(); } catch { /* A recorder can already be stopping. */ }
    }
    this.cleanupTracks();
    if (this.objectUrl) {
      this.options.revokeObjectURL?.(this.objectUrl);
      this.objectUrl = null;
    }
  }

  private set(next: Partial<VoiceSnapshot>) {
    if (this.disposed) return;
    this.snapshot = { ...this.snapshot, ...next };
    [...this.listeners].forEach((listener) => listener(this.snapshot));
  }
}

export function formatVoiceDuration(elapsedMs: number): string {
  const total = Math.floor(Math.max(0, elapsedMs) / 1000);
  return `${Math.floor(total / 60)}:${String(total % 60).padStart(2, "0")}`;
}