@ephia/dova-sdk 1.0.0

package/dist/chunk-DIEWY3IT.js

@@ -0,0 +1,1332 @@
+import {
+  resolveEphiaSdkApiUrl
+} from "./chunk-PSYX674B.js";
+import {
+  initialAudioState
+} from "./chunk-EGIAN7FH.js";
+import {
+  LiveKitTransport,
+  canTransition,
+  dbgState,
+  initialClientState,
+  transitionSessionStatus
+} from "./chunk-LXMCRXXF.js";
+import {
+  EphiaSdkError
+} from "./chunk-N7U5M3VZ.js";
+
+// src/core/client/constants.ts
+import { PROTOCOL_VERSION as WIRE_PROTOCOL_VERSION } from "ephia-protocol";
+var SDK_VERSION = "2.0.0";
+var PROTOCOL_VERSION = WIRE_PROTOCOL_VERSION;
+var AUDIO_SESSIONS_PATH = "/api/v1/audio/sessions";
+var TOKEN_MAX_AGE_MS = 5 * 60 * 1e3;
+var ACTIVE_TOKEN_TTL_MS = 6 * 60 * 60 * 1e3;
+
+// src/core/client/session-api.ts
+import { z } from "zod";
+var createSessionResponseSchema = z.object({
+  session_id: z.string(),
+  room_name: z.string(),
+  token: z.string(),
+  livekit_url: z.string(),
+  protocol_version: z.string().optional(),
+  capabilities: z.object({
+    supports_realtime: z.boolean().optional()
+  }).optional()
+});
+var SessionApiClient = class {
+  opts;
+  _preloadedSession = null;
+  _preloadPromise = null;
+  _preloadToken = 0;
+  _preloadRefreshTimer = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get preloadedSession() {
+    return this._preloadedSession;
+  }
+  get preloadToken() {
+    return this._preloadToken;
+  }
+  incrementPreloadToken() {
+    this._preloadToken++;
+  }
+  takePreloadedSession() {
+    const s = this._preloadedSession;
+    if (!s) return null;
+    this._preloadedSession = null;
+    return {
+      sessionId: s.sessionId,
+      roomName: s.roomName,
+      token: s.token,
+      livekitUrl: s.livekitUrl
+    };
+  }
+  discardPreloadedSession() {
+    const s = this._preloadedSession;
+    this._preloadedSession = null;
+    return s;
+  }
+  clearPreloadPromise() {
+    this._preloadPromise = null;
+  }
+  hasPreloadInFlight() {
+    return this._preloadPromise !== null;
+  }
+  async awaitPreloadIfPending(signal) {
+    const preloadPromise = this._preloadPromise;
+    if (!preloadPromise) return;
+    if (signal?.aborted) {
+      throw new EphiaSdkError("client.start_failed", "Start aborted");
+    }
+    if (!signal) {
+      await preloadPromise;
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const onAbort = () => {
+        signal.removeEventListener("abort", onAbort);
+        reject(new EphiaSdkError("client.start_failed", "Start aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      preloadPromise.then(
+        () => {
+          signal.removeEventListener("abort", onAbort);
+          resolve();
+        },
+        (err) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(err);
+        }
+      );
+    });
+  }
+  cancelTimers() {
+    if (this._preloadRefreshTimer !== null) {
+      clearTimeout(this._preloadRefreshTimer);
+      this._preloadRefreshTimer = null;
+    }
+  }
+  async preload(optionsOrSignal, maybeSignal) {
+    const signal = optionsOrSignal && "aborted" in optionsOrSignal ? optionsOrSignal : maybeSignal;
+    const startOptions = optionsOrSignal && !("aborted" in optionsOrSignal) ? optionsOrSignal : void 0;
+    if (this.opts.isIdle && !this.opts.isIdle()) {
+      console.info("[EphiaAudioClient] preload: skipped, not idle");
+      return;
+    }
+    if (this._preloadedSession) {
+      console.info(
+        "[EphiaAudioClient] preload: already preloaded",
+        this._preloadedSession.sessionId
+      );
+      return;
+    }
+    if (this._preloadPromise) {
+      return this._preloadPromise;
+    }
+    const token = ++this._preloadToken;
+    const preloadPromise = this.createSession(signal, startOptions).then((data) => {
+      if (token !== this._preloadToken) {
+        void this.stopBackendSession(data.sessionId);
+        return;
+      }
+      this._preloadedSession = {
+        ...data,
+        createdAt: Date.now(),
+        initialTargetId: startOptions?.initialTargetId
+      };
+      this.opts.onPrepareConnection?.(data.livekitUrl, data.token);
+      this.opts.onPreloadComplete?.(data);
+      console.info("[EphiaAudioClient] preload:done", data.sessionId);
+      this.schedulePreloadRefresh();
+    }).catch((err) => {
+      if (err instanceof Error && err.name === "AbortError") return;
+      console.warn("[EphiaAudioClient] preload:failed", err);
+      this.opts.onPreloadFailed?.();
+    }).finally(() => {
+      if (this._preloadPromise === preloadPromise) {
+        this._preloadPromise = null;
+      }
+    });
+    this._preloadPromise = preloadPromise;
+    return this._preloadPromise;
+  }
+  schedulePreloadRefresh() {
+    if (this._preloadRefreshTimer !== null) {
+      clearTimeout(this._preloadRefreshTimer);
+    }
+    this._preloadRefreshTimer = setTimeout(() => {
+      this._preloadRefreshTimer = null;
+      if (this.opts.isIdle?.()) {
+        console.info("[EphiaAudioClient] preload: auto-refreshing expired token");
+        const orphaned = this.discardPreloadedSession();
+        if (orphaned) {
+          void this.stopBackendSession(orphaned.sessionId);
+        }
+        this._preloadPromise = null;
+        const options = orphaned?.initialTargetId ? { initialTargetId: orphaned.initialTargetId } : void 0;
+        void this.preload(options).catch(() => {
+        });
+      }
+    }, TOKEN_MAX_AGE_MS * 0.8);
+  }
+  /** Refresh token LiveKit — retourne le nouveau token ou null. */
+  async refreshToken(sessionId) {
+    const apiUrl = resolveEphiaSdkApiUrl(this.opts.apiUrl);
+    const headers = this.authHeaders();
+    try {
+      const r = await fetch(
+        `${apiUrl}${AUDIO_SESSIONS_PATH}/${encodeURIComponent(sessionId)}/token`,
+        { headers }
+      );
+      const data = await r.json();
+      if (data.token) {
+        console.info("[EphiaAudioClient] token refreshed for next reconnect", sessionId);
+        return data.token;
+      }
+    } catch (err) {
+      console.warn("[EphiaAudioClient] token refresh failed (non-fatal)", err);
+    }
+    return null;
+  }
+  get activeTokenRefreshDelayMs() {
+    return ACTIVE_TOKEN_TTL_MS * 0.8;
+  }
+  isPreloadedSessionExpired() {
+    if (!this._preloadedSession) return false;
+    return Date.now() - this._preloadedSession.createdAt > TOKEN_MAX_AGE_MS;
+  }
+  async createSessionWithRetry(signal, startOptions) {
+    const maxRetries = 2;
+    let lastErr;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (signal?.aborted) {
+        throw new EphiaSdkError("client.start_failed", "Start aborted");
+      }
+      try {
+        return await this.createSession(signal, startOptions);
+      } catch (err) {
+        lastErr = err;
+        if (err instanceof EphiaSdkError) throw err;
+        if (signal?.aborted) throw err;
+        if (attempt < maxRetries) {
+          const delay = 250 * Math.pow(2, attempt) + Math.random() * 100;
+          console.warn(
+            `[EphiaAudioClient] createSession:retry attempt=${attempt + 1} delay=${Math.round(delay)}ms`,
+            err
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastErr;
+  }
+  async createSession(signal, startOptions) {
+    const apiUrl = resolveEphiaSdkApiUrl(this.opts.apiUrl);
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.authHeaders()
+    };
+    const so = this.opts.sessionOptions;
+    const body = {
+      session_mode: "dictation",
+      client_type: this.opts.clientType ?? "sdk",
+      language: so?.language ?? "fr",
+      mode: so?.mode ?? "smart_s",
+      debug_chunks: so?.debugChunks ?? false,
+      sdk_version: SDK_VERSION,
+      protocol_version: String(PROTOCOL_VERSION)
+    };
+    if (startOptions?.initialTargetId) {
+      body.initial_target_id = startOptions.initialTargetId;
+    }
+    const response = await fetch(`${apiUrl}${AUDIO_SESSIONS_PATH}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal
+    });
+    const rawText = await response.text();
+    if (!response.ok) {
+      let message = `Failed to create session: ${response.statusText}`;
+      try {
+        const errBody = JSON.parse(rawText);
+        const detail = errBody.detail;
+        if (typeof detail === "string") {
+          message = detail;
+        } else if (Array.isArray(detail)) {
+          message = detail.map((item) => {
+            const loc = item.loc?.join(".") ?? "body";
+            return `${loc}: ${item.msg ?? item.type ?? "validation error"}`;
+          }).join(" \u2014 ");
+        } else if (detail && typeof detail === "object") {
+          const parts = [detail.message, detail.hint].filter(Boolean);
+          if (parts.length > 0) message = parts.join(" \u2014 ");
+        }
+      } catch {
+        if (rawText) message = rawText;
+      }
+      throw new EphiaSdkError("session.create_failed", message, {
+        status: response.status
+      });
+    }
+    const parsed = createSessionResponseSchema.safeParse(JSON.parse(rawText));
+    if (!parsed.success) {
+      throw new EphiaSdkError(
+        "session.create_failed",
+        "Invalid session response from backend",
+        { issues: parsed.error.issues }
+      );
+    }
+    return {
+      sessionId: parsed.data.session_id,
+      roomName: parsed.data.room_name,
+      token: parsed.data.token,
+      livekitUrl: parsed.data.livekit_url
+    };
+  }
+  async stopBackendSession(sessionId) {
+    try {
+      const apiUrl = resolveEphiaSdkApiUrl(this.opts.apiUrl);
+      const headers = {
+        "Content-Type": "application/json",
+        ...this.authHeaders()
+      };
+      await fetch(`${apiUrl}${AUDIO_SESSIONS_PATH}/${encodeURIComponent(sessionId)}/stop`, {
+        method: "POST",
+        headers
+      });
+      console.info("[EphiaAudioClient] stopBackendSession:done", sessionId);
+    } catch (err) {
+      console.warn("[EphiaAudioClient] stopBackendSession:failed", sessionId, err);
+    }
+  }
+  /** Best-effort stop on tab close (fetch keepalive supports auth headers). */
+  stopBackendSessionOnPageHide(sessionId) {
+    if (typeof window === "undefined" || !sessionId) return;
+    try {
+      const apiUrl = resolveEphiaSdkApiUrl(this.opts.apiUrl);
+      const headers = {
+        "Content-Type": "application/json",
+        ...this.authHeaders()
+      };
+      void fetch(`${apiUrl}${AUDIO_SESSIONS_PATH}/${encodeURIComponent(sessionId)}/stop`, {
+        method: "POST",
+        headers,
+        keepalive: true
+      });
+    } catch {
+    }
+  }
+  authHeaders() {
+    const headers = {};
+    if (this.opts.apiKey) {
+      headers["X-API-Key"] = this.opts.apiKey;
+    } else if (this.opts.bearerToken) {
+      headers["Authorization"] = `Bearer ${this.opts.bearerToken}`;
+    }
+    if (this.opts.clientType) {
+      headers["X-Ephia-Client"] = this.opts.clientType;
+      headers["X-Ephia-App"] = this.opts.clientType;
+    }
+    return headers;
+  }
+};
+
+// src/core/client/audio-capture.ts
+import { Room } from "livekit-client";
+
+// src/core/audio/audio-worklet-source.ts
+var AUDIO_WORKLET_SOURCE = `
+class AudioCaptureProcessor extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0];
+    if (input.length > 0) {
+      this.port.postMessage(new Float32Array(input[0]));
+    }
+    return true;
+  }
+}
+registerProcessor('ephia-audio-capture', AudioCaptureProcessor);
+`;
+var sharedWorkletModuleUrl = null;
+function getAudioWorkletModuleUrl() {
+  if (!sharedWorkletModuleUrl) {
+    sharedWorkletModuleUrl = URL.createObjectURL(
+      new Blob([AUDIO_WORKLET_SOURCE], { type: "application/javascript" })
+    );
+  }
+  return sharedWorkletModuleUrl;
+}
+
+// src/core/audio/voice-level-meter.ts
+var VOLUME_THROTTLE_MS = 33;
+var SILENCE_THRESHOLD_RMS = 5e-3;
+var RAW_RMS_SCALE = 7;
+var TARGET_SAMPLE_RATE = 16e3;
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function isAudioContextClosed(audioContext) {
+  return audioContext.state === "closed";
+}
+function resampleLinear(input, sourceSampleRate, targetSampleRate) {
+  if (sourceSampleRate === targetSampleRate || input.length <= 1) {
+    return input;
+  }
+  const outputLength = Math.max(
+    1,
+    Math.round(input.length * targetSampleRate / sourceSampleRate)
+  );
+  const output = new Float32Array(outputLength);
+  const scale = sourceSampleRate / targetSampleRate;
+  for (let i = 0; i < outputLength; i += 1) {
+    const sourceIndex = i * scale;
+    const leftIndex = Math.floor(sourceIndex);
+    const rightIndex = Math.min(leftIndex + 1, input.length - 1);
+    const fraction = sourceIndex - leftIndex;
+    const left = input[leftIndex] ?? 0;
+    const right = input[rightIndex] ?? left;
+    output[i] = left + (right - left) * fraction;
+  }
+  return output;
+}
+var VoiceLevelMeter = class {
+  audioContext = null;
+  processor = null;
+  silentGain = null;
+  source = null;
+  callbacks = /* @__PURE__ */ new Set();
+  pendingRms = 0;
+  lastVolumeUpdateMs = 0;
+  volumeTimer = null;
+  _pipelineReady = null;
+  // Startup capture state (shared pipeline avec StartupAudioBuffer)
+  _captureBuffers = [];
+  _captureTotalSamples = 0;
+  _captureMaxSamples = 0;
+  _captureEnabled = false;
+  _actualSampleRate = TARGET_SAMPLE_RATE;
+  attach(stream) {
+    this.detach();
+    const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+    if (!AudioContextClass) {
+      console.warn("[VoiceLevelMeter] AudioContext not supported");
+      return Promise.resolve();
+    }
+    this._pipelineReady = this._startWorkletPipeline(stream, AudioContextClass);
+    return this._pipelineReady;
+  }
+  isAttached() {
+    return this.processor !== null;
+  }
+  async _startWorkletPipeline(stream, AudioContextClass) {
+    try {
+      const audioContext = new AudioContextClass({
+        sampleRate: TARGET_SAMPLE_RATE,
+        latencyHint: "interactive"
+      });
+      this.audioContext = audioContext;
+      this._actualSampleRate = audioContext.sampleRate || TARGET_SAMPLE_RATE;
+      if (audioContext.state === "suspended") {
+        await audioContext.resume();
+      }
+      if (this.audioContext !== audioContext || isAudioContextClosed(audioContext)) {
+        return;
+      }
+      await audioContext.audioWorklet.addModule(getAudioWorkletModuleUrl());
+      if (this.audioContext !== audioContext || isAudioContextClosed(audioContext)) {
+        return;
+      }
+      const source = audioContext.createMediaStreamSource(stream);
+      const processor = new AudioWorkletNode(audioContext, "ephia-audio-capture");
+      const silentGain = audioContext.createGain();
+      silentGain.gain.value = 0;
+      processor.connect(silentGain);
+      silentGain.connect(audioContext.destination);
+      processor.port.onmessage = (event) => {
+        const inputData = event.data;
+        if (!inputData?.length) return;
+        if (this._captureEnabled) {
+          const chunk = new Float32Array(inputData);
+          this._captureBuffers.push(chunk);
+          this._captureTotalSamples += chunk.length;
+          while (this._captureTotalSamples > this._captureMaxSamples && this._captureBuffers.length > 0) {
+            const removed = this._captureBuffers.shift();
+            this._captureTotalSamples -= removed.length;
+          }
+        }
+        let sum = 0;
+        for (let i = 0; i < inputData.length; i++) {
+          const x = inputData[i];
+          sum += x * x;
+        }
+        const rawRms = Math.sqrt(sum / inputData.length);
+        this.pendingRms = clamp01(rawRms * RAW_RMS_SCALE);
+        const now = Date.now();
+        if (this.volumeTimer === null && now - this.lastVolumeUpdateMs > VOLUME_THROTTLE_MS) {
+          this.volumeTimer = setTimeout(() => {
+            this.volumeTimer = null;
+            this.lastVolumeUpdateMs = Date.now();
+            this._emitSnapshot();
+          }, VOLUME_THROTTLE_MS);
+        }
+      };
+      this.source = source;
+      this.processor = processor;
+      this.silentGain = silentGain;
+      source.connect(processor);
+    } catch (err) {
+      console.warn("[VoiceLevelMeter] worklet pipeline failed", err);
+      this.detach();
+    }
+  }
+  _emitSnapshot() {
+    const rms = this.pendingRms;
+    const snapshot = {
+      level: clamp01(rms),
+      rms
+    };
+    const isSilent = rms < SILENCE_THRESHOLD_RMS;
+    if (isSilent) {
+      snapshot.level = 0;
+      snapshot.rms = 0;
+    }
+    this.callbacks.forEach((cb) => cb(snapshot));
+  }
+  detach() {
+    if (this.volumeTimer !== null) {
+      clearTimeout(this.volumeTimer);
+      this.volumeTimer = null;
+    }
+    this.pendingRms = 0;
+    this.lastVolumeUpdateMs = 0;
+    if (this.source) {
+      try {
+        this.source.disconnect();
+      } catch {
+      }
+      this.source = null;
+    }
+    if (this.processor) {
+      try {
+        this.processor.port.onmessage = null;
+        this.processor.disconnect();
+      } catch {
+      }
+      this.processor = null;
+    }
+    if (this.silentGain) {
+      try {
+        this.silentGain.disconnect();
+      } catch {
+      }
+      this.silentGain = null;
+    }
+    if (this.audioContext) {
+      this.audioContext.close().catch(() => {
+      });
+      this.audioContext = null;
+    }
+  }
+  onLevel(callback) {
+    this.callbacks.add(callback);
+    return () => {
+      this.callbacks.delete(callback);
+    };
+  }
+  /** Active la capture startup sur le pipeline existant. maxSamples = taille FIFO. */
+  enableStartupCapture(maxSamples) {
+    this._captureBuffers = [];
+    this._captureTotalSamples = 0;
+    this._captureMaxSamples = Math.ceil(
+      maxSamples * this._actualSampleRate / TARGET_SAMPLE_RATE
+    );
+    this._captureEnabled = true;
+  }
+  /** Stoppe la capture et retourne le PCM16 accumulé (ou null si vide). Le level meter continue. */
+  drainStartupCapture() {
+    this._captureEnabled = false;
+    const buffers = this._captureBuffers;
+    const totalSamples = this._captureTotalSamples;
+    this._captureBuffers = [];
+    this._captureTotalSamples = 0;
+    if (buffers.length === 0) return null;
+    const float32 = new Float32Array(totalSamples);
+    let offset = 0;
+    for (const buf of buffers) {
+      float32.set(buf, offset);
+      offset += buf.length;
+    }
+    const resampled = resampleLinear(
+      float32,
+      this._actualSampleRate,
+      TARGET_SAMPLE_RATE
+    );
+    const pcm16 = new Int16Array(resampled.length);
+    for (let i = 0; i < resampled.length; i++) {
+      const s = Math.max(-1, Math.min(1, resampled[i] ?? 0));
+      pcm16[i] = s < 0 ? s * 32768 : s * 32767;
+    }
+    return pcm16.buffer;
+  }
+};
+
+// src/core/client/audio-capture.ts
+var AudioCaptureManager = class {
+  voiceLevelMeter = new VoiceLevelMeter();
+  _activeStream = null;
+  _warmupStream = null;
+  _warmupPromise = null;
+  _levelUnsubscribe;
+  _silenceStartMs = null;
+  _lastAudioState = { ...initialAudioState };
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get lastAudioState() {
+    return this._lastAudioState;
+  }
+  get silenceStartMs() {
+    return this._silenceStartMs;
+  }
+  get hasActiveStream() {
+    return !!this._activeStream;
+  }
+  get hasWarmupStream() {
+    return !!this._warmupStream;
+  }
+  setActiveStream(stream) {
+    this._activeStream = stream;
+  }
+  emitAudioState(state) {
+    this._lastAudioState = { ...state };
+    this.deps.onAudioState(this._lastAudioState);
+  }
+  patchAudioState(patch) {
+    this.emitAudioState({ ...this._lastAudioState, ...patch });
+  }
+  stopAudioLevelImmediately() {
+    this._levelUnsubscribe?.();
+    this._levelUnsubscribe = void 0;
+    this.voiceLevelMeter.detach();
+    this.patchAudioState({
+      level: 0,
+      rms: 0,
+      peak: 0,
+      isSilent: true,
+      silenceDurationMs: 0,
+      localAudioPublished: false,
+      muted: false
+    });
+  }
+  async warmupMic() {
+    if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) return;
+    if (this._warmupStream && this._warmupStream.getAudioTracks().some((t) => t.readyState === "live")) {
+      console.info("[EphiaAudioClient] warmupMic: already warmed up");
+      return;
+    }
+    if (this._warmupPromise) {
+      return this._warmupPromise;
+    }
+    this._warmupPromise = this.acquireMicStream().then(async (stream) => {
+      this._warmupStream = stream;
+      await this.voiceLevelMeter.attach(stream);
+      console.info("[EphiaAudioClient] warmupMic:done", {
+        trackCount: stream.getAudioTracks().length
+      });
+    }).catch((err) => {
+      console.warn("[EphiaAudioClient] warmupMic:failed", err);
+    }).finally(() => {
+      this._warmupPromise = null;
+    });
+    return this._warmupPromise;
+  }
+  injectWarmupStream(stream) {
+    this.cleanupWarmupStream();
+    this._warmupStream = stream;
+    this.voiceLevelMeter.attach(stream).catch(() => {
+    });
+  }
+  enableStartupCapture(maxSamples) {
+    this.voiceLevelMeter.enableStartupCapture(maxSamples);
+  }
+  drainStartupCapture() {
+    return this.voiceLevelMeter.drainStartupCapture();
+  }
+  async acquireMicStream(deviceId) {
+    if (this._warmupStream && this._warmupStream.getAudioTracks().some((t) => t.readyState === "live")) {
+      const warmupTracks = this._warmupStream.getAudioTracks();
+      const warmupDeviceId = warmupTracks[0]?.getSettings().deviceId;
+      if (!deviceId || warmupDeviceId === deviceId) {
+        console.info("[EphiaAudioClient] getUserMedia: using warmed-up stream", {
+          warmupDeviceId
+        });
+        const stream2 = this._warmupStream;
+        this._warmupStream = null;
+        return stream2;
+      }
+      console.info("[EphiaAudioClient] getUserMedia: warmup device mismatch, releasing warmup", {
+        warmupDeviceId,
+        requestedDeviceId: deviceId
+      });
+      this.cleanupWarmupStream();
+    }
+    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+      const isSecure = typeof window !== "undefined" && window.isSecureContext === false;
+      throw new EphiaSdkError(
+        "audio.no_input_device",
+        isSecure ? "getUserMedia not available in non-secure context (requires HTTPS or localhost)" : "getUserMedia not available in this browser/context"
+      );
+    }
+    console.info("[EphiaAudioClient] getUserMedia:start", deviceId ? { deviceId } : void 0);
+    const audioConstraints = {
+      echoCancellation: { ideal: false },
+      noiseSuppression: { ideal: false },
+      autoGainControl: { ideal: false },
+      channelCount: { ideal: 1 },
+      sampleRate: { ideal: 16e3 }
+    };
+    if (deviceId) {
+      audioConstraints.deviceId = { exact: deviceId };
+    }
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: audioConstraints });
+    const tracks = stream.getAudioTracks();
+    console.info("[EphiaAudioClient] getUserMedia:done", {
+      trackCount: tracks.length,
+      tracks: tracks.map((t) => ({
+        id: t.id,
+        label: t.label,
+        readyState: t.readyState
+      }))
+    });
+    return stream;
+  }
+  async setupAudioLevel(stream) {
+    const track = stream.getAudioTracks()[0];
+    if (!track) return;
+    const trackSettings = track.getSettings();
+    const deviceId = trackSettings.deviceId ?? "";
+    const deviceLabel = track.label ?? "";
+    this.emitAudioState({
+      permission: "granted",
+      hasInputDevice: true,
+      inputDeviceId: deviceId,
+      inputDeviceLabel: deviceLabel,
+      level: 0,
+      rms: 0,
+      peak: 0,
+      isSilent: false,
+      silenceDurationMs: 0,
+      muted: track.muted,
+      localAudioPublished: false,
+      micReady: true,
+      speaking: false
+    });
+    this._levelUnsubscribe?.();
+    if (!this.voiceLevelMeter.isAttached()) {
+      try {
+        await this.voiceLevelMeter.attach(stream);
+      } catch (err) {
+        console.warn(
+          "[EphiaAudioClient] _setupAudioLevel: voiceLevelMeter attach failed (non-fatal)",
+          err
+        );
+      }
+    }
+    this._levelUnsubscribe = this.voiceLevelMeter.onLevel((snapshot) => {
+      const isSilent = snapshot.level < 5e-3;
+      if (isSilent && this._silenceStartMs === null) {
+        this._silenceStartMs = Date.now();
+      } else if (!isSilent) {
+        this._silenceStartMs = null;
+      }
+      const silenceDurationMs = isSilent && this._silenceStartMs !== null ? Date.now() - this._silenceStartMs : 0;
+      this.patchAudioState({
+        permission: "granted",
+        hasInputDevice: true,
+        inputDeviceId: deviceId,
+        inputDeviceLabel: deviceLabel,
+        level: snapshot.level,
+        rms: snapshot.rms,
+        peak: snapshot.rms,
+        isSilent,
+        silenceDurationMs,
+        muted: track.muted,
+        localAudioPublished: this.deps.getLocalAudioPublished(),
+        micReady: true
+      });
+    });
+  }
+  cleanupActiveStream() {
+    this._levelUnsubscribe?.();
+    this._levelUnsubscribe = void 0;
+    this._silenceStartMs = null;
+    this.voiceLevelMeter.detach();
+    if (this._activeStream) {
+      this._activeStream.getTracks().forEach((t) => t.stop());
+      this._activeStream = null;
+    }
+  }
+  cleanupWarmupStream() {
+    if (this._warmupStream) {
+      this._warmupStream.getTracks().forEach((t) => t.stop());
+      this._warmupStream = null;
+    }
+    this._warmupPromise = null;
+  }
+  async getAvailableMicrophones() {
+    return Room.getLocalDevices("audioinput");
+  }
+};
+
+// src/core/client/EphiaAudioClient.ts
+var EphiaAudioClient = class {
+  options;
+  transport;
+  state = { ...initialClientState };
+  _unbindTransport;
+  _stopping = false;
+  _intentionalDisconnect = false;
+  _startAbortController = null;
+  _lastConnectParams = null;
+  _tokenRefreshTimer = null;
+  _serverSessionClosed = false;
+  sessionApi;
+  audio;
+  constructor(options = {}) {
+    this.options = options;
+    this.transport = options.transport ?? new LiveKitTransport();
+    this.sessionApi = new SessionApiClient({
+      apiUrl: options.apiUrl,
+      apiKey: options.apiKey,
+      bearerToken: options.bearerToken,
+      clientType: options.clientType,
+      sessionOptions: options.sessionOptions,
+      isIdle: () => this.state.status === "idle",
+      onPrepareConnection: (url, token) => {
+        this.transport.prepareConnection?.(url, token).catch(() => {
+        });
+      },
+      onPreloadComplete: () => {
+        this._emitSdkDebug("sdk.preload.done", { ts: Date.now() });
+      },
+      onPreloadFailed: () => {
+        this._emitSdkDebug("sdk.preload.failed", { ts: Date.now() });
+      }
+    });
+    this.audio = new AudioCaptureManager({
+      onAudioState: (s) => this.options.onAudioState?.(s),
+      getLocalAudioPublished: () => this.state.isMicEnabled
+    });
+  }
+  async preload(optionsOrSignal, maybeSignal) {
+    if (this.state.status !== "idle") return;
+    if (optionsOrSignal && "aborted" in optionsOrSignal) {
+      return this.sessionApi.preload(optionsOrSignal);
+    }
+    return this.sessionApi.preload(optionsOrSignal, maybeSignal);
+  }
+  releasePreloadedSession() {
+    this.sessionApi.cancelTimers();
+    const orphaned = this.sessionApi.discardPreloadedSession();
+    if (orphaned) {
+      this.sessionApi.stopBackendSession(orphaned.sessionId).catch(() => {
+      });
+    }
+  }
+  async warmupMic() {
+    return this.audio.warmupMic();
+  }
+  injectWarmupStream(stream) {
+    this.audio.injectWarmupStream(stream);
+  }
+  async start(options) {
+    if (this.state.status === "ended" || this.state.status === "error") {
+      this._resetForStart();
+    }
+    if (this.state.status === "paused" && this._hasReusableRoom()) {
+      await this._resumeAudio(options);
+      return { sessionId: this.state.sessionId };
+    }
+    if (!canTransition(this.state.status, "creating_session")) {
+      throw new EphiaSdkError(
+        "client.invalid_state",
+        `Cannot start while status is ${this.state.status}`
+      );
+    }
+    this._setStatus("creating_session");
+    this._startAbortController = new AbortController();
+    const { signal } = this._startAbortController;
+    let acquiredStream;
+    let sessionData;
+    try {
+      const micPromise = this.audio.acquireMicStream(this.options.preferredAudioInputDeviceId).then((stream) => {
+        if (!signal.aborted) {
+          acquiredStream = stream;
+          this.audio.setActiveStream(stream);
+        } else {
+          stream.getTracks().forEach((t) => t.stop());
+        }
+      });
+      let sessionPromise;
+      const preloaded = this.sessionApi.takePreloadedSession();
+      if (preloaded) {
+        sessionData = preloaded;
+        this.state = { ...this.state, sessionId: preloaded.sessionId, roomName: preloaded.roomName };
+        this.options.onStateChange?.(this.getState());
+        sessionPromise = Promise.resolve();
+      } else {
+        if (this.sessionApi.hasPreloadInFlight()) {
+          await this.sessionApi.awaitPreloadIfPending(signal);
+          const fromFlight = this.sessionApi.takePreloadedSession();
+          if (fromFlight) {
+            sessionData = fromFlight;
+            this.state = { ...this.state, sessionId: fromFlight.sessionId, roomName: fromFlight.roomName };
+            this.options.onStateChange?.(this.getState());
+            sessionPromise = Promise.resolve();
+          } else {
+            sessionPromise = this.sessionApi.createSessionWithRetry(signal, options).then((data) => {
+              if (!signal.aborted) {
+                sessionData = data;
+                this.state = { ...this.state, sessionId: data.sessionId, roomName: data.roomName };
+                this.options.onStateChange?.(this.getState());
+              }
+            });
+          }
+        } else {
+          sessionPromise = this.sessionApi.createSessionWithRetry(signal, options).then((data) => {
+            if (!signal.aborted) {
+              sessionData = data;
+              this.state = { ...this.state, sessionId: data.sessionId, roomName: data.roomName };
+              this.options.onStateChange?.(this.getState());
+            }
+          });
+        }
+      }
+      await Promise.all([micPromise, sessionPromise]);
+      if (signal.aborted) {
+        this._handleStartAborted();
+        return { sessionId: null };
+      }
+      if (!acquiredStream || !sessionData) {
+        throw new EphiaSdkError("client.start_failed", "Missing stream or session");
+      }
+      this._setStatus("connecting_transport");
+      this._unbindTransport?.();
+      this._unbindTransport = this._bindTransportEvents();
+      const connectParams = {
+        livekitUrl: sessionData.livekitUrl,
+        token: sessionData.token,
+        roomName: sessionData.roomName,
+        sessionId: sessionData.sessionId
+      };
+      this._lastConnectParams = connectParams;
+      this._scheduleTokenRefresh(sessionData.sessionId);
+      await this._connectTransportWithRetry(connectParams, signal);
+      await this._sendInitialTargetBeforeAudio(options?.initialTargetId, signal);
+      if (signal.aborted) {
+        await this._disconnectTransport().catch(() => {
+        });
+        this._handleStartAborted();
+        return { sessionId: null };
+      }
+      this._setStatus("ready");
+      const track = acquiredStream.getAudioTracks()[0];
+      if (!track) {
+        throw new EphiaSdkError("audio.no_input_device", "No audio track");
+      }
+      if (!track.enabled) track.enabled = true;
+      try {
+        await this.transport.publishAudio(track, { enableNoiseFilter: this.options.noiseFilter });
+      } catch (err) {
+        if (err instanceof EphiaSdkError) throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new EphiaSdkError("audio.track_publish_failed", message);
+      }
+      if (signal.aborted) {
+        await this.transport.unpublishAudio().catch(() => {
+        });
+        await this._disconnectTransport().catch(() => {
+        });
+        this._handleStartAborted();
+        return { sessionId: null };
+      }
+      this._setStatus("recording");
+      this.state = { ...this.state, isMicEnabled: true };
+      this.options.onStateChange?.(this.getState());
+      await this.audio.setupAudioLevel(acquiredStream);
+      this._emitSdkDebug("sdk.record.started", { sessionId: sessionData.sessionId, ts: Date.now() });
+      return { sessionId: sessionData.sessionId };
+    } catch (err) {
+      if (signal.aborted) {
+        await this._disconnectTransport().catch(() => {
+        });
+        this._handleStartAborted();
+        return { sessionId: null };
+      }
+      const code = err instanceof EphiaSdkError ? err.code : "client.start_failed";
+      const message = err instanceof Error ? err.message : String(err);
+      this._setErrorState(code, message);
+      this.audio.cleanupActiveStream();
+      await this._disconnectTransport().catch(() => {
+      });
+      throw err;
+    } finally {
+      if (this._startAbortController?.signal === signal) {
+        this._startAbortController = null;
+      }
+    }
+  }
+  /** Arrête l'enregistrement sans fermer la room (reprise possible via start()). */
+  async stop() {
+    if (this._stopping) return;
+    this.audio.stopAudioLevelImmediately?.();
+    if (this._startAbortController) {
+      this._stopping = true;
+      this._startAbortController.abort();
+      this._startAbortController = null;
+      this._handleStartAborted();
+      this._stopping = false;
+      return;
+    }
+    if (this.state.status === "idle" || this.state.status === "paused" || this.state.status === "ended" || this.state.status === "error" || this.state.status === "disposed") {
+      return;
+    }
+    if (this.state.status === "creating_session" || this.state.status === "connecting_transport") {
+      this._stopping = true;
+      await this._disconnectTransport().catch(() => {
+      });
+      this._handleStartAborted();
+      this._stopping = false;
+      return;
+    }
+    this._stopping = true;
+    try {
+      await this.transport.unpublishAudio().catch(() => {
+      });
+      this.audio.cleanupActiveStream();
+      this.state = { ...this.state, isMicEnabled: false };
+      this._setStatus("paused");
+      this.options.onStateChange?.(this.getState());
+    } finally {
+      this._stopping = false;
+    }
+  }
+  /** Termine complètement la session : déconnecte la room et stop le backend. */
+  async endSession() {
+    if (this._stopping) return;
+    this.audio.stopAudioLevelImmediately?.();
+    if (this._startAbortController) {
+      this._stopping = true;
+      this._startAbortController.abort();
+      this._startAbortController = null;
+      this._handleStartAborted();
+      this._stopping = false;
+      return;
+    }
+    if (this.state.status === "idle" || this.state.status === "ended" || this.state.status === "disposed") {
+      return;
+    }
+    this._stopping = true;
+    const sessionId = this.state.sessionId;
+    try {
+      await this.transport.unpublishAudio().catch(() => {
+      });
+      this.audio.cleanupActiveStream();
+      this._intentionalDisconnect = true;
+      await this._disconnectTransport().catch(() => {
+      });
+      if (sessionId) {
+        this.sessionApi.stopBackendSession(sessionId).catch(() => {
+        });
+      }
+      this._markSessionEnded();
+    } finally {
+      this._intentionalDisconnect = false;
+      this._stopping = false;
+    }
+  }
+  registerPageHideStop() {
+    if (typeof window === "undefined") return () => {
+    };
+    const handler = () => {
+      const sessionId = this.state.sessionId;
+      if (sessionId) this.sessionApi.stopBackendSessionOnPageHide(sessionId);
+    };
+    window.addEventListener("pagehide", handler);
+    return () => window.removeEventListener("pagehide", handler);
+  }
+  async dispose() {
+    if (this._startAbortController) {
+      this._startAbortController.abort();
+      this._startAbortController = null;
+      this._handleStartAborted();
+      return;
+    }
+    const status = this.state.status;
+    if (status === "recording" || status === "ready") {
+      await this.endSession();
+      return;
+    }
+    this.sessionApi.cancelTimers();
+    const orphaned = this.sessionApi.discardPreloadedSession();
+    if (orphaned) this.sessionApi.stopBackendSession(orphaned.sessionId).catch(() => {
+    });
+    this._intentionalDisconnect = true;
+    await this._disconnectTransport().catch(() => {
+    });
+    this._intentionalDisconnect = false;
+    this._unbindTransport?.();
+    this._unbindTransport = void 0;
+    this.audio.cleanupActiveStream();
+    this.audio.cleanupWarmupStream?.();
+    this.state = { ...this.state, status: "disposed" };
+    this.options.onStateChange?.(this.getState());
+  }
+  getState() {
+    return { ...this.state };
+  }
+  setPreferredAudioInputDeviceId(deviceId) {
+    this.options = { ...this.options, preferredAudioInputDeviceId: deviceId };
+  }
+  onTransportState(callback) {
+    return this.transport.onTransportState(callback);
+  }
+  onServerEvent(callback) {
+    return this.transport.onServerEvent(callback);
+  }
+  async sendMessage(message) {
+    await this.transport.sendMessage(message);
+  }
+  async getAvailableMicrophones() {
+    return this.audio.getAvailableMicrophones();
+  }
+  async switchMicrophone(deviceId) {
+    await this.transport.switchActiveDevice?.("audioinput", deviceId);
+  }
+  exportTrace() {
+    return {
+      sdkVersion: SDK_VERSION,
+      protocolVersion: PROTOCOL_VERSION,
+      sessionId: this.state.sessionId,
+      state: this.state
+    };
+  }
+  getDebugSnapshot() {
+    return {
+      sdkVersion: SDK_VERSION,
+      protocolVersion: PROTOCOL_VERSION,
+      state: this.state,
+      lastAudioState: this.audio.lastAudioState,
+      stopping: this._stopping,
+      intentionalDisconnect: this._intentionalDisconnect,
+      preloadedSession: this.sessionApi.preloadedSession,
+      lastConnectParams: this._lastConnectParams ? { ...this._lastConnectParams, token: "[redacted]" } : null,
+      hasActiveStream: this.audio.hasActiveStream
+    };
+  }
+  // ── Internals ────────────────────────────────────────────────────────────────
+  _bindTransportEvents() {
+    const unsubServerEvent = this.transport.onServerEvent((event) => {
+      if (event.type === "session.error") {
+        this._setErrorState(event.payload.code, event.payload.message);
+        this._serverSessionClosed = true;
+      }
+      if (event.type === "session.status") {
+        if (event.payload.status === "closed") {
+          this._serverSessionClosed = true;
+        } else if (event.payload.status === "ready") {
+          this._serverSessionClosed = false;
+        }
+      }
+    });
+    const unsubState = this.transport.onTransportState((tState) => {
+      if (tState.status === "disconnected" && !this._intentionalDisconnect && !this._stopping) {
+        this._setErrorState("transport.disconnected", "Connexion perdue");
+      }
+    });
+    const unsubError = this.transport.onError((err) => {
+      this._setErrorState(err.code, err.message);
+    });
+    return () => {
+      unsubServerEvent();
+      unsubState();
+      unsubError();
+    };
+  }
+  async _resumeAudio(options) {
+    if (this.state.isMicEnabled) return;
+    try {
+      const stream = await this.audio.acquireMicStream(this.options.preferredAudioInputDeviceId);
+      if (!stream) throw new EphiaSdkError("audio.no_input_device", "No mic stream");
+      this.audio.setActiveStream(stream);
+      const track = stream.getAudioTracks()[0];
+      if (!track) throw new EphiaSdkError("audio.no_input_device", "No audio track");
+      await this._sendInitialTargetBeforeAudio(options?.initialTargetId);
+      try {
+        await this.transport.publishAudio(track, { enableNoiseFilter: this.options.noiseFilter });
+      } catch (err) {
+        if (err instanceof EphiaSdkError) throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new EphiaSdkError("audio.track_publish_failed", message);
+      }
+      await this.transport.sendMessage({
+        type: "session.resume",
+        payload: {
+          context: options?.context
+        }
+      });
+      this._setStatus("recording");
+      this.state = { ...this.state, isMicEnabled: true };
+      this.options.onStateChange?.(this.getState());
+      await this.audio.setupAudioLevel(stream);
+    } catch (err) {
+      const code = err instanceof EphiaSdkError ? err.code : "client.start_failed";
+      const message = err instanceof Error ? err.message : String(err);
+      this._setErrorState(code, message);
+      this.audio.cleanupActiveStream();
+      throw err;
+    }
+  }
+  _hasReusableRoom() {
+    const status = this.transport.getState().status;
+    return !!this.state.sessionId && (status === "connected" || status === "reconnected");
+  }
+  _handleStartAborted() {
+    this.audio.cleanupActiveStream();
+    const orphaned = this.sessionApi.discardPreloadedSession();
+    if (orphaned) this.sessionApi.stopBackendSession(orphaned.sessionId).catch(() => {
+    });
+    this._forceIdle();
+  }
+  _forceIdle() {
+    this.state = { ...this.state, status: "idle", isMicEnabled: false };
+    this.options.onStateChange?.(this.getState());
+  }
+  _resetForStart() {
+    this._unbindTransport?.();
+    this._unbindTransport = void 0;
+    this.audio.cleanupActiveStream();
+    const orphaned = this.sessionApi.discardPreloadedSession();
+    if (orphaned) this.sessionApi.stopBackendSession(orphaned.sessionId).catch(() => {
+    });
+    this.sessionApi.cancelTimers();
+    if (this._tokenRefreshTimer !== null) {
+      clearTimeout(this._tokenRefreshTimer);
+      this._tokenRefreshTimer = null;
+    }
+    this._lastConnectParams = null;
+    this.state = {
+      ...this.state,
+      status: "idle",
+      sessionId: null,
+      roomName: null,
+      error: null,
+      isMicEnabled: false
+    };
+  }
+  _markSessionEnded() {
+    this._unbindTransport?.();
+    this._unbindTransport = void 0;
+    if (this._tokenRefreshTimer !== null) {
+      clearTimeout(this._tokenRefreshTimer);
+      this._tokenRefreshTimer = null;
+    }
+    this._lastConnectParams = null;
+    if (this.state.status !== "ended" && this.state.status !== "error" && this.state.status !== "disposed") {
+      this._setStatus("ended");
+    }
+    this.state = { ...this.state, isMicEnabled: false };
+    this.options.onStateChange?.(this.getState());
+  }
+  _setStatus(next) {
+    const current = this.state.status;
+    if (current === next) return;
+    const status = transitionSessionStatus(current, next);
+    this.state = { ...this.state, status };
+    dbgState("sdk.client", this.getDebugSnapshot());
+    this.options.onStateChange?.(this.getState());
+  }
+  _setErrorState(code, message) {
+    const error = { code, message };
+    const current = this.state.status;
+    if (canTransition(current, "error")) {
+      this._setStatus("error");
+    } else {
+      this.state = { ...this.state, status: "error" };
+    }
+    this.state = { ...this.state, error, isMicEnabled: false };
+    this.options.onStateChange?.(this.getState());
+    this.options.onError?.(error);
+  }
+  _scheduleTokenRefresh(sessionId) {
+    if (this._tokenRefreshTimer !== null) clearTimeout(this._tokenRefreshTimer);
+    this._tokenRefreshTimer = setTimeout(() => {
+      this._tokenRefreshTimer = null;
+      if (!this._lastConnectParams) return;
+      void this.sessionApi.refreshToken(sessionId).then((token) => {
+        if (token && this._lastConnectParams) {
+          this._lastConnectParams = { ...this._lastConnectParams, token };
+        }
+      });
+    }, this.sessionApi.activeTokenRefreshDelayMs);
+  }
+  async _connectTransportWithRetry(params, signal) {
+    const maxRetries = 2;
+    let lastErr;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (signal?.aborted) throw new EphiaSdkError("client.start_failed", "Start aborted");
+      try {
+        await this.transport.connect(params);
+        return;
+      } catch (err) {
+        lastErr = err;
+        if (err instanceof EphiaSdkError) throw err;
+        if (signal?.aborted) throw err;
+        if (attempt < maxRetries) {
+          const delay = 300 * Math.pow(2, attempt) + Math.random() * 100;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastErr;
+  }
+  async _sendInitialTargetBeforeAudio(targetId, signal) {
+    if (!targetId) return;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      if (signal?.aborted) throw new EphiaSdkError("client.start_failed", "Start aborted");
+      try {
+        await this.transport.sendMessage({
+          type: "session.target.changed",
+          payload: { targetId }
+        });
+        return;
+      } catch (err) {
+        if (attempt === 2) throw err;
+        await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+      }
+    }
+  }
+  async _disconnectTransport() {
+    this._unbindTransport?.();
+    this._unbindTransport = void 0;
+    await this.transport.disconnect();
+  }
+  _emitSdkDebug(type, payload) {
+    if (typeof window === "undefined") return;
+    window.dispatchEvent(
+      new CustomEvent("ephia:sdk-debug", {
+        detail: { type, sessionId: this.state.sessionId ?? null, payload }
+      })
+    );
+  }
+};
+
+export {
+  EphiaAudioClient
+};
+//# sourceMappingURL=chunk-DIEWY3IT.js.map