@nuancelabs/js-sdk 0.0.0-stage → 0.1.0

package/index.js

@@ -0,0 +1,2490 @@
+// src/core/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/core/sdk-version.ts
+var SDK_HEADER = `js/${"0.1.0"}`;
+
+// src/utils.ts
+function normalizeHost(host) {
+  return host.replace(/\/+$/, "");
+}
+
+// src/api/client.ts
+class ApiError extends Error {
+  status;
+  body;
+  constructor(status, detail, body = null) {
+    super(detail);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class NuanceApiClient {
+  host;
+  headersProvider;
+  tokenProvider;
+  tokens = new Map;
+  constructor(config) {
+    this.host = normalizeHost(config.host);
+    this.headersProvider = config.headers;
+    this.tokenProvider = config.token;
+  }
+  async createConversation(request) {
+    const token = this.tokenProvider ? await this.tokenProvider() : undefined;
+    const conversation = await this.request("/conversation", { method: "POST", body: request, token });
+    if (token !== undefined)
+      this.tokens.set(conversation.id, token);
+    return conversation;
+  }
+  async getConversation(conversationId) {
+    return this.request(`/conversation/${conversationId}`, { token: this.tokens.get(conversationId) });
+  }
+  async connectConversation(conversationId, request = {}) {
+    return this.request(`/conversation/${conversationId}/connect`, {
+      method: "POST",
+      body: request,
+      token: this.tokens.get(conversationId)
+    });
+  }
+  async heartbeatConversation(conversationId) {
+    return await this.request(`/conversation/${conversationId}/heartbeat`, { method: "POST", token: this.tokens.get(conversationId) });
+  }
+  async abandonConversation(conversationId) {
+    return await this.request(`/conversation/${conversationId}/abandon`, { method: "POST", token: this.tokens.get(conversationId) });
+  }
+  async request(path, options) {
+    const headers = new Headers(await this.resolveHeaders());
+    headers.set("X-Nuance-SDK", SDK_HEADER);
+    if (options?.token !== undefined) {
+      headers.set("Authorization", `Bearer ${options.token}`);
+    }
+    if (options?.body !== undefined) {
+      headers.set("Content-Type", "application/json");
+    }
+    const response = await fetch(`${this.host}${path}`, {
+      method: options?.method ?? "GET",
+      headers,
+      body: options?.body !== undefined ? JSON.stringify(options.body) : undefined
+    });
+    if (!response.ok) {
+      let detail = response.statusText;
+      let body = null;
+      try {
+        body = await response.json();
+        if (isRecord(body) && typeof body.detail === "string") {
+          detail = body.detail;
+        }
+      } catch {
+        body = null;
+      }
+      throw new ApiError(response.status, detail, body);
+    }
+    if (response.status === 204) {
+      return;
+    }
+    return response.json();
+  }
+  async resolveHeaders() {
+    return this.headersProvider ? await this.headersProvider() : {};
+  }
+}
+
+// src/core/active-session-error.ts
+class ActiveSessionError extends Error {
+  constructor() {
+    super("an active conversation session already exists");
+    this.name = "ActiveSessionError";
+  }
+}
+
+// src/core/legal-required-error.ts
+class LegalRequiredError extends Error {
+  constructor() {
+    super("the current terms of service must be accepted first");
+    this.name = "LegalRequiredError";
+  }
+}
+
+// src/core/maintenance-error.ts
+class MaintenanceError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MaintenanceError";
+  }
+}
+
+// src/core/media-error.ts
+function reasonFor(cause) {
+  const name = cause instanceof Error ? cause.name : "";
+  switch (name) {
+    case "NotAllowedError":
+    case "SecurityError":
+      return "permission-denied";
+    case "NotFoundError":
+    case "OverconstrainedError":
+      return "device-not-found";
+    case "NotReadableError":
+    case "AbortError":
+      return "device-in-use";
+    default:
+      return "unknown";
+  }
+}
+
+class MediaAccessError extends Error {
+  device;
+  reason;
+  constructor(cause, device = "unknown") {
+    const reason = reasonFor(cause);
+    super(`media access failed: ${device} ${reason}`);
+    this.name = "MediaAccessError";
+    this.device = device;
+    this.reason = reason;
+  }
+}
+async function ensureMicrophoneAccess(deviceId) {
+  try {
+    const stream = await navigator.mediaDevices.getUserMedia({
+      audio: deviceId ? { deviceId: { ideal: deviceId } } : true
+    });
+    for (const track of stream.getTracks())
+      track.stop();
+  } catch (error) {
+    throw new MediaAccessError(error, "microphone");
+  }
+}
+
+// src/core/policy-curfew-error.ts
+class PolicyCurfewError extends Error {
+  retryAfterSeconds;
+  constructor(retryAfterSeconds) {
+    super("new sessions are paused after repeated policy violations");
+    this.name = "PolicyCurfewError";
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+}
+
+// src/core/ticker.ts
+var WORKER_SOURCE = "onmessage = (e) => { setInterval(() => postMessage(0), e.data); };";
+function backgroundTicker(host) {
+  return (tick, intervalMs) => {
+    const stopTimer = workerInterval(host.Worker, tick, intervalMs) ?? pageInterval(tick, intervalMs);
+    const page = host.document;
+    const onVisibility = () => {
+      if (page?.visibilityState === "visible")
+        tick();
+    };
+    page?.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      stopTimer();
+      page?.removeEventListener("visibilitychange", onVisibility);
+    };
+  };
+}
+function workerInterval(WorkerType, tick, intervalMs) {
+  if (WorkerType === undefined || typeof URL.createObjectURL !== "function") {
+    return null;
+  }
+  const url = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: "text/javascript" }));
+  let worker;
+  try {
+    worker = new WorkerType(url);
+  } catch {
+    URL.revokeObjectURL(url);
+    return null;
+  }
+  let fallback = null;
+  worker.onmessage = () => tick();
+  worker.onerror = () => {
+    worker.terminate();
+    fallback ??= pageInterval(tick, intervalMs);
+  };
+  worker.postMessage(intervalMs);
+  return () => {
+    worker.terminate();
+    fallback?.();
+    URL.revokeObjectURL(url);
+  };
+}
+function pageInterval(tick, intervalMs) {
+  const id = setInterval(tick, intervalMs);
+  return () => clearInterval(id);
+}
+var pageTicker = backgroundTicker(globalThis);
+
+// src/providers/livekit/conversation.ts
+import {
+  ConnectionQuality,
+  ConnectionState as ConnectionState2,
+  Room,
+  RoomEvent as RoomEvent3
+} from "livekit-client";
+
+// src/providers/livekit/tracks.ts
+class LiveKitVideoTrack {
+  track;
+  attachedElement = null;
+  constructor(track) {
+    this.track = track;
+  }
+  attach(element) {
+    this.track.attach(element);
+    this.attachedElement = element;
+  }
+  detach() {
+    if (this.attachedElement) {
+      this.track.detach(this.attachedElement);
+      this.attachedElement = null;
+    }
+  }
+  get isEnabled() {
+    return !this.track.isMuted;
+  }
+  get isPlaying() {
+    const element = this.attachedElement;
+    return element !== null && !element.paused && element.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA;
+  }
+}
+
+class LiveKitAudioTrack {
+  track;
+  get mediaStreamTrack() {
+    return this.track.mediaStreamTrack ?? null;
+  }
+  attachedElement = null;
+  muted = false;
+  constructor(track) {
+    this.track = track;
+  }
+  attach(element) {
+    this.track.attach(element);
+    element.muted = this.muted;
+    this.attachedElement = element;
+  }
+  detach() {
+    if (this.attachedElement) {
+      this.track.detach(this.attachedElement);
+      this.attachedElement = null;
+    }
+  }
+  setMuted(muted) {
+    this.muted = muted;
+    if (this.attachedElement) {
+      this.attachedElement.muted = muted;
+    }
+  }
+  get isEnabled() {
+    return !this.track.isMuted;
+  }
+}
+
+// src/providers/livekit/avatar-participant.ts
+class LiveKitAvatarParticipant {
+  participant;
+  locallyMuted = false;
+  _ready = false;
+  _videoTrack = null;
+  _audioTrack = null;
+  lastVideoSource = null;
+  lastAudioSource = null;
+  constructor(participant) {
+    this.participant = participant;
+  }
+  updateParticipant(participant, keepReady = false) {
+    if (!keepReady && (participant === null || this.participant !== null && participant !== this.participant)) {
+      this._ready = false;
+    }
+    this.participant = participant;
+    return this.updateTracks();
+  }
+  markReady() {
+    this._ready = true;
+    this.applyMute();
+  }
+  applyMute() {
+    this._audioTrack?.setMuted(this.locallyMuted || !this._ready);
+  }
+  updateTracks() {
+    let changed = false;
+    const videoSource = this.findTrack("video");
+    if (videoSource !== this.lastVideoSource) {
+      this._videoTrack?.detach();
+      this._videoTrack = videoSource ? new LiveKitVideoTrack(videoSource) : null;
+      this.lastVideoSource = videoSource;
+      changed = true;
+    }
+    const audioSource = this.findTrack("audio");
+    if (audioSource !== this.lastAudioSource) {
+      this._audioTrack?.detach();
+      this._audioTrack = audioSource ? new LiveKitAudioTrack(audioSource) : null;
+      this.applyMute();
+      this.lastAudioSource = audioSource;
+      changed = true;
+    }
+    return changed;
+  }
+  get videoTrack() {
+    return this._videoTrack;
+  }
+  get audioTrack() {
+    return this._audioTrack;
+  }
+  async muteAudio() {
+    this.locallyMuted = true;
+    this.applyMute();
+  }
+  async unmuteAudio() {
+    this.locallyMuted = false;
+    this.applyMute();
+  }
+  get isMuted() {
+    return this.locallyMuted;
+  }
+  get isVideoPlaying() {
+    return this._videoTrack?.isPlaying ?? false;
+  }
+  get isVideoEnabled() {
+    return this._videoTrack !== null;
+  }
+  get isReady() {
+    return this._ready;
+  }
+  findTrack(kind) {
+    if (!this.participant)
+      return null;
+    for (const pub of this.participant.trackPublications.values()) {
+      if (pub.track?.kind === kind)
+        return pub.track;
+    }
+    return null;
+  }
+}
+
+// src/providers/livekit/layer-fallback.ts
+import { Track, VideoQuality } from "livekit-client";
+var LAYER_FALLBACK_TIMING = {
+  sampleMs: 1000,
+  slowFps: 12,
+  stuckSamples: 3,
+  holdMs: 30000,
+  maxHoldMs: 120000
+};
+
+class LayerFallback {
+  read;
+  pin;
+  timing;
+  timer = null;
+  previous = null;
+  slow = 0;
+  pinnedUntil = null;
+  hold;
+  sampling = false;
+  constructor(read, pin, timing = LAYER_FALLBACK_TIMING) {
+    this.read = read;
+    this.pin = pin;
+    this.timing = timing;
+    this.hold = timing.holdMs;
+  }
+  start() {
+    if (this.timer !== null)
+      return;
+    this.timer = setInterval(() => {
+      this.sample();
+    }, this.timing.sampleMs);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.previous = null;
+    this.slow = 0;
+  }
+  async sample() {
+    if (this.sampling || this.timer === null)
+      return;
+    this.sampling = true;
+    try {
+      const now = Date.now();
+      if (this.pinnedUntil !== null && now >= this.pinnedUntil) {
+        this.pinnedUntil = null;
+        this.pin("any");
+        this.previous = null;
+      }
+      const rate = await this.read().catch(() => null);
+      if (this.timer === null)
+        return;
+      this.observe(rate, now);
+    } finally {
+      this.sampling = false;
+    }
+  }
+  observe(rate, now) {
+    const previous = this.previous;
+    this.previous = rate;
+    if (this.pinnedUntil !== null || rate === null || previous === null)
+      return;
+    if (rate.framesDecoded === null || previous.framesDecoded === null)
+      return;
+    const seconds = (rate.at - previous.at) / 1000;
+    if (seconds <= 0)
+      return;
+    const fps = (rate.framesDecoded - previous.framesDecoded) / seconds;
+    const full = rate.width !== null && rate.publishedWidth !== null && rate.width >= rate.publishedWidth;
+    this.slow = full && fps < this.timing.slowFps ? this.slow + 1 : 0;
+    if (this.slow < this.timing.stuckSamples)
+      return;
+    this.slow = 0;
+    this.pinnedUntil = now + this.hold;
+    this.hold = Math.min(this.hold * 2, this.timing.maxHoldMs);
+    this.pin("low");
+  }
+}
+async function avatarVideoRate(room) {
+  if (typeof document !== "undefined" && document.hidden)
+    return null;
+  for (const participant of room.remoteParticipants.values()) {
+    const publication = participant.getTrackPublication(Track.Source.Camera);
+    const track = publication?.track;
+    if (!publication?.isSubscribed || !track)
+      continue;
+    const report = await track.getRTCStatsReport();
+    let width = null;
+    let framesDecoded = null;
+    report?.forEach((stat) => {
+      if (stat.type === "inbound-rtp" && stat.kind === "video") {
+        width = typeof stat.frameWidth === "number" ? stat.frameWidth : null;
+        framesDecoded = typeof stat.framesDecoded === "number" ? stat.framesDecoded : null;
+      }
+    });
+    return {
+      width,
+      publishedWidth: publication.dimensions?.width ?? null,
+      framesDecoded,
+      at: Date.now()
+    };
+  }
+  return null;
+}
+function pinAvatarLayer(room, layer) {
+  for (const participant of room.remoteParticipants.values()) {
+    const publication = participant.getTrackPublication(Track.Source.Camera);
+    if (!publication?.isSubscribed)
+      continue;
+    publication.setVideoQuality(layer === "low" ? VideoQuality.LOW : VideoQuality.HIGH);
+    return;
+  }
+}
+
+// src/providers/livekit/network-stats.ts
+import {
+  ConnectionState,
+  ParticipantEvent,
+  RoomEvent,
+  Track as Track2
+} from "livekit-client";
+
+// src/providers/livekit/mic-silence.ts
+var MIC_SILENT_AFTER_MS = 4000;
+
+class MicSilence {
+  silentAfterMs;
+  packets = null;
+  countedAt = null;
+  stillMs = 0;
+  stalled = false;
+  downSince = null;
+  _silent = false;
+  constructor(silentAfterMs = MIC_SILENT_AFTER_MS) {
+    this.silentAfterMs = silentAfterMs;
+  }
+  get silent() {
+    return this._silent;
+  }
+  observe(reading) {
+    if (!reading.connected || !reading.live) {
+      this.reset();
+      return this._silent;
+    }
+    const { at } = reading;
+    const packets = reading.packetsSent;
+    if (packets === null) {
+      this.countedAt = null;
+    } else {
+      if (packets !== this.packets)
+        this.stillMs = 0;
+      else if (this.countedAt !== null)
+        this.stillMs += at - this.countedAt;
+      this.packets = packets;
+      this.countedAt = at;
+      this.stalled = this.stillMs >= this.silentAfterMs;
+    }
+    const down = reading.readyState === "ended" || reading.trackMuted;
+    if (!down)
+      this.downSince = null;
+    else
+      this.downSince ??= at;
+    const trackDown = this.downSince !== null && at - this.downSince >= this.silentAfterMs;
+    this._silent = this.stalled || trackDown;
+    return this._silent;
+  }
+  reset() {
+    this.packets = null;
+    this.countedAt = null;
+    this.stillMs = 0;
+    this.stalled = false;
+    this.downSince = null;
+    this._silent = false;
+  }
+}
+
+// src/providers/livekit/network-stats.ts
+var STATS_TOPIC = "webrtc-stats";
+var SAMPLE_MS = 1000;
+var BATCH = 5;
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function str(value) {
+  return typeof value === "string" && value ? value : null;
+}
+function entries(report) {
+  const out = [];
+  report.forEach((entry) => {
+    out.push(entry);
+  });
+  return out;
+}
+function codecOf(entry, byId) {
+  const codec = entry.codecId ? byId.get(entry.codecId) : undefined;
+  const mime = codec ? str(codec.mimeType) : null;
+  return mime ? mime.replace(/^(audio|video)\//, "") : null;
+}
+function digestInbound(entry, byId) {
+  if (!entry)
+    return null;
+  const digest = {
+    packets_received: num(entry.packetsReceived),
+    packets_lost: num(entry.packetsLost),
+    bytes_received: num(entry.bytesReceived),
+    jitter_s: num(entry.jitter),
+    nack_count: num(entry.nackCount),
+    jitter_buffer_delay_s: num(entry.jitterBufferDelay),
+    jitter_buffer_target_delay_s: num(entry.jitterBufferTargetDelay),
+    jitter_buffer_emitted_count: num(entry.jitterBufferEmittedCount),
+    estimated_playout_timestamp_ms: num(entry.estimatedPlayoutTimestamp),
+    codec: codecOf(entry, byId)
+  };
+  if (entry.kind === "audio") {
+    digest.total_samples_received = num(entry.totalSamplesReceived);
+    digest.concealed_samples = num(entry.concealedSamples);
+    digest.silent_concealed_samples = num(entry.silentConcealedSamples);
+    digest.concealment_events = num(entry.concealmentEvents);
+    digest.inserted_samples_for_deceleration = num(entry.insertedSamplesForDeceleration);
+    digest.removed_samples_for_acceleration = num(entry.removedSamplesForAcceleration);
+    digest.audio_level = num(entry.audioLevel);
+    digest.total_samples_duration_s = num(entry.totalSamplesDuration);
+  } else {
+    digest.pli_count = num(entry.pliCount);
+    digest.fir_count = num(entry.firCount);
+    digest.frames_received = num(entry.framesReceived);
+    digest.frames_decoded = num(entry.framesDecoded);
+    digest.frames_dropped = num(entry.framesDropped);
+    digest.frames_per_second = num(entry.framesPerSecond);
+    digest.frame_width = num(entry.frameWidth);
+    digest.frame_height = num(entry.frameHeight);
+    digest.freeze_count = num(entry.freezeCount);
+    digest.total_freeze_duration_s = num(entry.totalFreezesDuration);
+    digest.pause_count = num(entry.pauseCount);
+    digest.total_pause_duration_s = num(entry.totalPausesDuration);
+    digest.total_inter_frame_delay_s = num(entry.totalInterFrameDelay);
+    digest.total_decode_time_s = num(entry.totalDecodeTime);
+    digest.decoder = str(entry.decoderImplementation);
+  }
+  return digest;
+}
+function digestOutbound(entry, byId) {
+  if (!entry)
+    return null;
+  const remote = entry.remoteId ? byId.get(entry.remoteId) : undefined;
+  const digest = {
+    packets_sent: num(entry.packetsSent),
+    bytes_sent: num(entry.bytesSent),
+    retransmitted_packets_sent: num(entry.retransmittedPacketsSent),
+    nack_count: num(entry.nackCount),
+    target_bitrate: num(entry.targetBitrate),
+    remote_rtt_s: remote ? num(remote.roundTripTime) : null,
+    remote_fraction_lost: remote ? num(remote.fractionLost) : null,
+    remote_jitter_s: remote ? num(remote.jitter) : null,
+    remote_packets_lost: remote ? num(remote.packetsLost) : null,
+    codec: codecOf(entry, byId)
+  };
+  if (entry.kind === "video") {
+    digest.pli_count = num(entry.pliCount);
+    digest.fir_count = num(entry.firCount);
+    digest.frames_sent = num(entry.framesSent);
+    digest.frames_encoded = num(entry.framesEncoded);
+    digest.frames_per_second = num(entry.framesPerSecond);
+    digest.frame_width = num(entry.frameWidth);
+    digest.frame_height = num(entry.frameHeight);
+    digest.total_encode_time_s = num(entry.totalEncodeTime);
+    digest.quality_limitation_reason = str(entry.qualityLimitationReason);
+    const durations = entry.qualityLimitationDurations;
+    digest.quality_limitation_durations_s = durations && typeof durations === "object" ? durations : null;
+    digest.encoder = str(entry.encoderImplementation);
+  }
+  return digest;
+}
+var NO_LINK = {
+  rtt_s: null,
+  candidate_type: null,
+  protocol: null,
+  avail_out_bps: null,
+  avail_in_bps: null
+};
+function digestLink(all, byId) {
+  let pair;
+  for (const transport of all) {
+    if (transport.type !== "transport")
+      continue;
+    const id = str(transport.selectedCandidatePairId);
+    if (id) {
+      pair = byId.get(id);
+      if (pair)
+        break;
+    }
+  }
+  if (!pair) {
+    pair = all.find((entry) => entry.type === "candidate-pair" && entry.nominated === true && entry.state === "succeeded");
+  }
+  if (!pair)
+    return NO_LINK;
+  const localId = str(pair.localCandidateId);
+  const local = localId ? byId.get(localId) : undefined;
+  return {
+    rtt_s: num(pair.currentRoundTripTime),
+    candidate_type: local ? str(local.candidateType) : null,
+    protocol: local ? str(local.protocol) : null,
+    avail_out_bps: num(pair.availableOutgoingBitrate),
+    avail_in_bps: num(pair.availableIncomingBitrate)
+  };
+}
+function buildSample(reports, hidden) {
+  const perReport = [
+    reports.avatarAudio,
+    reports.avatarVideo,
+    reports.mic,
+    reports.camera
+  ].map((report) => report ? entries(report) : null);
+  const byId = new Map;
+  for (const list of perReport) {
+    if (list)
+      for (const entry of list)
+        byId.set(entry.id, entry);
+  }
+  let link = NO_LINK;
+  for (const list of perReport) {
+    if (!list)
+      continue;
+    const candidate = digestLink(list, byId);
+    if (candidate.rtt_s != null || candidate.candidate_type) {
+      link = candidate;
+      break;
+    }
+  }
+  const inboundOf = (list) => list ? digestInbound(list.find((entry) => entry.type === "inbound-rtp"), byId) : null;
+  const outboundOf = (list) => list ? digestOutbound(list.find((entry) => entry.type === "outbound-rtp" && entry.active !== false), byId) : null;
+  const avatarAudio = inboundOf(perReport[0]);
+  const avatarVideo = inboundOf(perReport[1]);
+  const mic = outboundOf(perReport[2]);
+  if (mic && reports.micTrack) {
+    mic.track_muted = reports.micTrack.muted;
+    mic.track_ready_state = reports.micTrack.readyState;
+    mic.track_enabled = reports.micTrack.enabled;
+  }
+  const audioPlayout = avatarAudio?.estimated_playout_timestamp_ms ?? null;
+  const videoPlayout = avatarVideo?.estimated_playout_timestamp_ms ?? null;
+  return {
+    ts: Date.now() / 1000,
+    hidden,
+    ...link,
+    av_offset_ms: audioPlayout != null && videoPlayout != null ? audioPlayout - videoPlayout : null,
+    avatar_audio: avatarAudio,
+    avatar_video: avatarVideo,
+    mic,
+    camera: outboundOf(perReport[3])
+  };
+}
+function environment() {
+  if (typeof navigator === "undefined")
+    return null;
+  const connection = navigator.connection;
+  return {
+    user_agent: str(navigator.userAgent),
+    platform: str(navigator.platform),
+    hardware_concurrency: num(navigator.hardwareConcurrency),
+    connection_type: connection ? str(connection.effectiveType) ?? str(connection.type) : null,
+    connection_downlink_mbps: connection ? num(connection.downlink) : null,
+    connection_rtt_ms: connection ? num(connection.rtt) : null,
+    viewport: typeof window !== "undefined" && window.innerWidth ? `${window.innerWidth}x${window.innerHeight}` : null
+  };
+}
+function hasStats(track) {
+  return typeof track === "object" && track !== null && typeof track.getRTCStatsReport === "function";
+}
+
+class NetworkStatsReporter {
+  room;
+  env;
+  onMicSilent;
+  micSilence = new MicSilence;
+  timer = null;
+  seq = 0;
+  pending = [];
+  stopped = false;
+  onVisibility = () => {
+    if (document.visibilityState === "hidden")
+      this.flush();
+  };
+  onPageHide = () => {
+    this.flush();
+  };
+  onLinkChange = () => {
+    this.resetMic();
+  };
+  onMicMute = (publication) => {
+    if (publication.source === Track2.Source.Microphone)
+      this.resetMic();
+  };
+  constructor(room, onMicSilent = () => {}) {
+    this.room = room;
+    this.env = environment();
+    this.onMicSilent = onMicSilent;
+  }
+  start() {
+    if (this.timer !== null || this.stopped)
+      return;
+    this.timer = setInterval(() => {
+      this.sample();
+    }, SAMPLE_MS);
+    document.addEventListener("visibilitychange", this.onVisibility);
+    window.addEventListener("pagehide", this.onPageHide);
+    this.room.on(RoomEvent.Reconnecting, this.onLinkChange).on(RoomEvent.Reconnected, this.onLinkChange).on(RoomEvent.Disconnected, this.onLinkChange);
+    this.room.localParticipant.on(ParticipantEvent.TrackMuted, this.onMicMute).on(ParticipantEvent.TrackUnmuted, this.onMicMute);
+  }
+  stop() {
+    if (!this.teardown())
+      return Promise.resolve();
+    return this.flush();
+  }
+  abandon() {
+    this.teardown();
+    this.pending = [];
+  }
+  teardown() {
+    if (this.stopped)
+      return false;
+    this.stopped = true;
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    document.removeEventListener("visibilitychange", this.onVisibility);
+    window.removeEventListener("pagehide", this.onPageHide);
+    this.room.off(RoomEvent.Reconnecting, this.onLinkChange).off(RoomEvent.Reconnected, this.onLinkChange).off(RoomEvent.Disconnected, this.onLinkChange);
+    this.room.localParticipant.off(ParticipantEvent.TrackMuted, this.onMicMute).off(ParticipantEvent.TrackUnmuted, this.onMicMute);
+    this.resetMic();
+    return true;
+  }
+  resetMic() {
+    const was = this.micSilence.silent;
+    this.micSilence.reset();
+    if (was)
+      this.onMicSilent(false);
+  }
+  remoteTrack(source) {
+    for (const participant of this.room.remoteParticipants.values()) {
+      const publication = participant.getTrackPublication(source);
+      if (publication?.isSubscribed && hasStats(publication.track)) {
+        return publication.track;
+      }
+    }
+    return null;
+  }
+  localTrack(source) {
+    const publication = this.room.localParticipant.getTrackPublication(source);
+    return publication && !publication.isMuted && hasStats(publication.track) ? publication.track : null;
+  }
+  async report(track) {
+    if (!track)
+      return null;
+    try {
+      return await track.getRTCStatsReport() ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async sample() {
+    if (this.stopped)
+      return;
+    try {
+      const [avatarAudio, avatarVideo, mic, camera] = await Promise.all([
+        this.report(this.remoteTrack(Track2.Source.Microphone)),
+        this.report(this.remoteTrack(Track2.Source.Camera)),
+        this.report(this.localTrack(Track2.Source.Microphone)),
+        this.report(this.localTrack(Track2.Source.Camera))
+      ]);
+      if (this.stopped)
+        return;
+      const micPublication = this.room.localParticipant.getTrackPublication(Track2.Source.Microphone);
+      const micTrack = micPublication?.track?.mediaStreamTrack ?? null;
+      const sample = avatarAudio || avatarVideo || mic || camera ? buildSample({ avatarAudio, avatarVideo, mic, camera, micTrack }, document.hidden) : null;
+      this.watchMic(!!micPublication && !micPublication.isMuted && micTrack !== null, micTrack, mic ? sample?.mic?.packets_sent ?? 0 : null);
+      if (!sample)
+        return;
+      this.pending.push(sample);
+      if (this.pending.length >= BATCH)
+        this.flush();
+    } catch {}
+  }
+  watchMic(live, track, packetsSent) {
+    const was = this.micSilence.silent;
+    const silent = this.micSilence.observe({
+      at: Date.now(),
+      connected: this.room.state === ConnectionState.Connected,
+      live,
+      packetsSent,
+      readyState: track?.readyState ?? null,
+      trackMuted: track?.muted ?? false
+    });
+    if (silent !== was)
+      this.onMicSilent(silent);
+  }
+  async flush() {
+    if (!this.pending.length)
+      return;
+    const packet = {
+      type: "webrtc_stats",
+      seq: this.seq++,
+      ts: Date.now() / 1000,
+      env: this.env,
+      samples: this.pending
+    };
+    this.pending = [];
+    try {
+      await this.room.localParticipant.publishData(new TextEncoder().encode(JSON.stringify(packet)), { reliable: true, topic: STATS_TOPIC });
+    } catch {}
+  }
+}
+
+// src/providers/livekit/presentation.ts
+import { Track as Track3 } from "livekit-client";
+var PRESENTATION_TIMING = {
+  sampleMs: 250,
+  settleMs: 3000,
+  steadySamples: 4,
+  maxWaitMs: 12000
+};
+
+class PresentationWatch {
+  read;
+  onPresented;
+  timing;
+  timer = null;
+  startedAt = 0;
+  steady = 0;
+  sampling = false;
+  constructor(read, onPresented, timing = PRESENTATION_TIMING) {
+    this.read = read;
+    this.onPresented = onPresented;
+    this.timing = timing;
+  }
+  start() {
+    if (this.timer !== null)
+      return;
+    this.startedAt = Date.now();
+    this.timer = setInterval(() => {
+      this.sample();
+    }, this.timing.sampleMs);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async sample() {
+    if (this.sampling || this.timer === null)
+      return;
+    this.sampling = true;
+    try {
+      const size = await this.read().catch(() => ({ width: null, publishedWidth: null }));
+      if (this.timer === null)
+        return;
+      const full = size.width !== null && size.publishedWidth !== null && size.width >= size.publishedWidth;
+      this.steady = full ? this.steady + 1 : 0;
+      const elapsed = Date.now() - this.startedAt;
+      if (elapsed >= this.timing.settleMs && this.steady >= this.timing.steadySamples) {
+        this.finish("full-size");
+      } else if (elapsed >= this.timing.maxWaitMs) {
+        this.finish("timed-out");
+      }
+    } finally {
+      this.sampling = false;
+    }
+  }
+  finish(by) {
+    this.stop();
+    this.onPresented(by);
+  }
+}
+async function avatarVideoSize(room) {
+  for (const participant of room.remoteParticipants.values()) {
+    const publication = participant.getTrackPublication(Track3.Source.Camera);
+    const track = publication?.track;
+    if (!publication?.isSubscribed || !track)
+      continue;
+    const publishedWidth = publication.dimensions?.width ?? null;
+    const report = await track.getRTCStatsReport();
+    let width = null;
+    report?.forEach((stat) => {
+      if (stat.type === "inbound-rtp" && stat.kind === "video") {
+        width = typeof stat.frameWidth === "number" ? stat.frameWidth : null;
+      }
+    });
+    return { width, publishedWidth };
+  }
+  return { width: null, publishedWidth: null };
+}
+
+// src/providers/livekit/ready-fallback.ts
+import { Track as Track4 } from "livekit-client";
+var READY_FALLBACK_TIMING = {
+  sampleMs: 500,
+  delayMs: 5000,
+  maxWaitMs: 12000
+};
+
+class ReadyFallback {
+  read;
+  elementPlaying;
+  onFallback;
+  timing;
+  timer = null;
+  startedAt = 0;
+  lastFrames = null;
+  sampling = false;
+  constructor(read, elementPlaying, onFallback, timing = READY_FALLBACK_TIMING) {
+    this.read = read;
+    this.elementPlaying = elementPlaying;
+    this.onFallback = onFallback;
+    this.timing = timing;
+  }
+  start() {
+    if (this.timer !== null)
+      return;
+    this.startedAt = Date.now();
+    this.lastFrames = null;
+    this.timer = setInterval(() => {
+      this.sample();
+    }, this.timing.sampleMs);
+  }
+  get running() {
+    return this.timer !== null;
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async sample() {
+    if (this.sampling || this.timer === null)
+      return;
+    this.sampling = true;
+    try {
+      const frames = await this.read().catch(() => null);
+      if (this.timer === null)
+        return;
+      const playing = frames !== null && this.lastFrames !== null && frames > this.lastFrames;
+      this.lastFrames = frames;
+      const elapsed = Date.now() - this.startedAt;
+      const unmeasured = frames === null && elapsed >= this.timing.maxWaitMs && this.elementPlaying();
+      if (playing && elapsed >= this.timing.delayMs || unmeasured) {
+        this.stop();
+        this.onFallback();
+      }
+    } finally {
+      this.sampling = false;
+    }
+  }
+}
+async function avatarFramesDecoded(room) {
+  for (const participant of room.remoteParticipants.values()) {
+    const publication = participant.getTrackPublication(Track4.Source.Camera);
+    const track = publication?.track;
+    if (!publication?.isSubscribed || !track)
+      continue;
+    const report = await track.getRTCStatsReport();
+    let frames = null;
+    report?.forEach((stat) => {
+      if (stat.type === "inbound-rtp" && stat.kind === "video") {
+        frames = typeof stat.framesDecoded === "number" ? stat.framesDecoded : null;
+      }
+    });
+    return frames;
+  }
+  return null;
+}
+
+// src/providers/livekit/signals.ts
+function decode(payload) {
+  try {
+    const decoded = JSON.parse(new TextDecoder().decode(payload));
+    return isRecord(decoded) ? decoded : null;
+  } catch {
+    return null;
+  }
+}
+function endReason(reason) {
+  if (reason === "policy_violation")
+    return "policy-violation";
+  if (reason === "time_limit")
+    return "time-limit";
+  return "ended";
+}
+function parseSessionEvent(payload) {
+  const decoded = decode(payload);
+  if (!decoded)
+    return null;
+  if (decoded.type === "session.output_ready") {
+    return { type: "output-ready" };
+  }
+  if (decoded.type === "command.result") {
+    return {
+      type: "command-result",
+      id: typeof decoded.id === "string" ? decoded.id : null,
+      result: {
+        status: decoded.status === "applied" ? "applied" : "rejected",
+        error: typeof decoded.error === "string" ? decoded.error : null
+      }
+    };
+  }
+  if (decoded.type === "session.status" && decoded.status === "ended") {
+    return {
+      type: "ended",
+      reason: endReason(decoded.reason),
+      byClient: decoded.reason === "client_ended"
+    };
+  }
+  if (decoded.type === "error" && decoded.fatal === true) {
+    return { type: "ended", reason: endReason(decoded.code), byClient: false };
+  }
+  if (decoded.type === "error" && decoded.code === "bad_command") {
+    return { type: "command-unreadable" };
+  }
+  return { type: "other" };
+}
+function parseRuntimeSignal(payload) {
+  const decoded = decode(payload);
+  if (decoded?.type === "output_ready") {
+    return { type: "output-ready" };
+  }
+  if (decoded?.type === "session_ended") {
+    return { type: "session-ended", reason: endReason(decoded.reason) };
+  }
+  if (decoded?.type === "link_poor") {
+    return { type: "link-poor" };
+  }
+  return null;
+}
+function clockSyncPong(payload, receivedAt, now) {
+  const decoded = decode(payload);
+  if (decoded?.type !== "clock_sync_ping")
+    return null;
+  const reply = {
+    type: "clock_sync_pong",
+    seq: decoded.seq,
+    t0: decoded.t0,
+    t1: receivedAt,
+    t2: now()
+  };
+  return new TextEncoder().encode(JSON.stringify(reply));
+}
+function parseDataEvent(payload) {
+  const decoded = decode(payload);
+  if (!decoded)
+    return null;
+  return {
+    type: "data.event",
+    version: 1,
+    category: typeof decoded.category === "string" ? decoded.category : "",
+    source: typeof decoded.source === "string" ? decoded.source : "",
+    kind: typeof decoded.kind === "string" ? decoded.kind : typeof decoded.type === "string" ? decoded.type : "",
+    session_id: typeof decoded.session_id === "string" ? decoded.session_id : null,
+    request_id: decoded.request_id != null ? decoded.request_id : null,
+    timestamp_s: typeof decoded.timestamp_s === "number" ? decoded.timestamp_s : null,
+    severity: "info",
+    payload: decoded
+  };
+}
+
+// src/providers/livekit/user-participant.ts
+import {
+  AudioPresets,
+  ParticipantEvent as ParticipantEvent2,
+  RoomEvent as RoomEvent2,
+  Track as Track5
+} from "livekit-client";
+
+// src/core/camera.ts
+function cameraFacing(track) {
+  const facing = track.getSettings().facingMode;
+  return facing === "user" || facing === "environment" ? facing : null;
+}
+function requireCameraFacing(track, facing) {
+  const requested = typeof facing === "string" ? facing : !Array.isArray(facing) ? facing?.exact : undefined;
+  if (typeof requested !== "string")
+    return;
+  if (!track || track.getSettings().facingMode !== requested)
+    throw new DOMException("Requested camera direction is unavailable", "OverconstrainedError");
+}
+
+// src/providers/livekit/user-participant.ts
+function microphonePublishOptions(resilient) {
+  if (!resilient)
+    return;
+  return { dtx: false, audioPreset: AudioPresets.speech };
+}
+
+class LiveKitUserParticipant {
+  room;
+  onTracksChanged;
+  onSpeakingChanged;
+  onMicrophoneChanged;
+  onCameraChanged;
+  inputs = {
+    audioinput: { changing: false, unavailable: false },
+    videoinput: { changing: false, unavailable: false }
+  };
+  disposed = false;
+  selectedCameraFacing = null;
+  initialCameraFacing;
+  microphoneOptions;
+  _videoTrack = null;
+  _audioTrack = null;
+  lastVideoSource = null;
+  lastAudioSource = null;
+  _isSpeaking = false;
+  speakingHandler = null;
+  constructor(room, onTracksChanged, onSpeakingChanged, onMicrophoneChanged, onCameraChanged = () => {}, initialCameraFacing, resilient = false) {
+    this.room = room;
+    this.onTracksChanged = onTracksChanged;
+    this.onSpeakingChanged = onSpeakingChanged;
+    this.onMicrophoneChanged = onMicrophoneChanged;
+    this.onCameraChanged = onCameraChanged;
+    this.initialCameraFacing = initialCameraFacing;
+    this.microphoneOptions = microphonePublishOptions(resilient);
+    this.room.on(RoomEvent2.ActiveDeviceChanged, this.handleDeviceChanged);
+  }
+  updateTracks() {
+    let changed = false;
+    const videoPub = this.room.localParticipant.getTrackPublication(Track5.Source.Camera);
+    const videoSource = videoPub?.track ?? null;
+    if (videoSource !== this.lastVideoSource) {
+      this._videoTrack?.detach();
+      this._videoTrack = videoSource ? new LiveKitVideoTrack(videoSource) : null;
+      this.lastVideoSource = videoSource;
+      changed = true;
+    }
+    const audioPub = this.room.localParticipant.getTrackPublication(Track5.Source.Microphone);
+    const audioSource = audioPub?.track ?? null;
+    if (audioSource !== this.lastAudioSource) {
+      this._audioTrack?.detach();
+      this._audioTrack = audioSource ? new LiveKitAudioTrack(audioSource) : null;
+      this.lastAudioSource = audioSource;
+      changed = true;
+    }
+    return changed;
+  }
+  get videoTrack() {
+    return this._videoTrack;
+  }
+  get audioTrack() {
+    return this._audioTrack;
+  }
+  get microphoneId() {
+    return this.inputId("audioinput");
+  }
+  get cameraId() {
+    return this.inputId("videoinput");
+  }
+  get cameraFacing() {
+    if (this.disposed || this.inputs.videoinput.unavailable)
+      return null;
+    const track = this.inputTrack("videoinput")?.mediaStreamTrack;
+    return this.isVideoEnabled && track?.readyState === "live" ? cameraFacing(track) : this.initialCameraFacing ?? this.selectedCameraFacing;
+  }
+  inputId(kind) {
+    if (this.disposed || this.inputs[kind].unavailable)
+      return null;
+    const enabled = kind === "audioinput" ? !this.isMuted : this.isVideoEnabled;
+    if (!enabled)
+      return this.room.getActiveDevice(kind) ?? null;
+    const track = this.inputTrack(kind)?.mediaStreamTrack;
+    return track?.readyState === "live" ? track.getSettings().deviceId ?? this.room.getActiveDevice(kind) ?? null : null;
+  }
+  async setMicrophone(deviceId) {
+    await this.setInputDevice("audioinput", { deviceId });
+  }
+  async setCamera(deviceId) {
+    await this.setInputDevice("videoinput", { deviceId });
+  }
+  async setCameraFacing(facing) {
+    await this.setInputDevice("videoinput", { facing });
+  }
+  async setInputDevice(kind, selection) {
+    this.beginInputChange(kind);
+    const state = this.inputs[kind];
+    const previous = this.inputId(kind);
+    try {
+      await this.switchInput(kind, selection);
+      if (kind === "videoinput")
+        this.initialCameraFacing = undefined;
+      state.unavailable = false;
+    } catch (error) {
+      let recovered = false;
+      for (const fallback of new Set([previous, "default"])) {
+        if (this.disposed || !fallback)
+          continue;
+        try {
+          await this.switchInput(kind, { deviceId: fallback });
+          state.unavailable = false;
+          recovered = true;
+          break;
+        } catch {}
+      }
+      if (!recovered && !this.disposed) {
+        state.unavailable = true;
+        await this.applyEnabled(kind, false);
+      }
+      throw new MediaAccessError(error, kind === "audioinput" ? "microphone" : "camera");
+    } finally {
+      state.changing = false;
+      if (!this.disposed) {
+        if (this.updateTracks())
+          this.onTracksChanged();
+        this.notifyInput(kind);
+      }
+    }
+  }
+  inputTrack(kind) {
+    const publication = this.room.localParticipant.getTrackPublication(kind === "audioinput" ? Track5.Source.Microphone : Track5.Source.Camera);
+    return kind === "audioinput" ? publication?.audioTrack : publication?.videoTrack;
+  }
+  async switchInput(kind, selection) {
+    const track = this.inputTrack(kind);
+    if (this.disposed || !track && kind === "audioinput")
+      throw new Error("Input is unavailable");
+    try {
+      let deviceId = "deviceId" in selection ? selection.deviceId : "";
+      let facing = null;
+      if ("facing" in selection || !track || track.isMuted) {
+        if ("facing" in selection)
+          track?.mediaStreamTrack.stop();
+        const constraints = "facing" in selection ? { facingMode: { exact: selection.facing } } : {
+          deviceId: deviceId === "default" ? "default" : { exact: deviceId }
+        };
+        const probe = await navigator.mediaDevices.getUserMedia({
+          audio: kind === "audioinput" ? constraints : false,
+          video: kind === "videoinput" ? constraints : false
+        });
+        try {
+          if (kind === "videoinput") {
+            const capture = probe.getVideoTracks()[0];
+            if ("facing" in selection) {
+              requireCameraFacing(capture, selection.facing);
+              deviceId = capture?.getSettings().deviceId ?? "";
+              if (!deviceId)
+                throw new DOMException("Camera device ID is unavailable", "NotFoundError");
+            }
+            if (capture)
+              facing = cameraFacing(capture);
+          }
+        } finally {
+          for (const capture of probe.getTracks())
+            capture.stop();
+        }
+        if (this.disposed)
+          throw new Error("Participant is disconnected");
+      }
+      const changed = await this.room.switchActiveDevice(kind, deviceId, deviceId !== "default");
+      if (this.disposed)
+        throw new Error("Participant is disconnected");
+      if (!changed && deviceId !== "default")
+        throw new Error("Input did not change");
+      if (kind === "videoinput") {
+        const current = this.inputTrack(kind)?.mediaStreamTrack;
+        this.selectedCameraFacing = facing ?? (current?.readyState === "live" ? cameraFacing(current) : null);
+      }
+    } finally {
+      if (this.disposed) {
+        track?.stop();
+        this.inputTrack(kind)?.stop();
+      }
+    }
+  }
+  handleDeviceChanged = (kind) => {
+    if (kind === "audiooutput" || this.disposed)
+      return;
+    if (!this.inputs[kind].changing) {
+      this.inputs[kind].unavailable = false;
+      if (kind === "videoinput") {
+        const track = this.inputTrack(kind)?.mediaStreamTrack;
+        this.selectedCameraFacing = track?.readyState === "live" ? cameraFacing(track) : null;
+      }
+      this.notifyInput(kind);
+    }
+  };
+  cleanup() {
+    this.disposed = true;
+    this.room.off(RoomEvent2.ActiveDeviceChanged, this.handleDeviceChanged);
+    if (this.inputs.audioinput.changing)
+      this.inputTrack("audioinput")?.stop();
+    if (this.inputs.videoinput.changing)
+      this.inputTrack("videoinput")?.stop();
+    this.stopSpeakingDetection();
+  }
+  get isSpeaking() {
+    return this._isSpeaking;
+  }
+  async enableVideo() {
+    await this.setInputEnabled("videoinput", true);
+  }
+  async disableVideo() {
+    await this.setInputEnabled("videoinput", false);
+  }
+  async muteAudio() {
+    await this.setInputEnabled("audioinput", false);
+  }
+  async unmuteAudio() {
+    await this.setInputEnabled("audioinput", true);
+  }
+  beginInputChange(kind) {
+    if (this.disposed)
+      throw new Error("Participant is disconnected");
+    if (this.inputs[kind].changing)
+      throw new Error("Input change is in progress");
+    this.inputs[kind].changing = true;
+  }
+  async setInputEnabled(kind, enabled) {
+    this.beginInputChange(kind);
+    const track = this.inputTrack(kind);
+    try {
+      if (kind === "videoinput" && !enabled)
+        this.selectedCameraFacing = this.cameraFacing;
+      if (kind === "videoinput" && enabled && this.initialCameraFacing) {
+        await this.switchInput(kind, { facing: this.initialCameraFacing });
+        this.initialCameraFacing = undefined;
+      }
+      await this.applyEnabled(kind, enabled);
+      if (this.disposed)
+        throw new Error("Participant is disconnected");
+      if (enabled)
+        this.inputs[kind].unavailable = false;
+      if (kind === "videoinput" && enabled) {
+        const current = this.inputTrack(kind)?.mediaStreamTrack;
+        if (current?.readyState === "live")
+          this.selectedCameraFacing = cameraFacing(current);
+      }
+      if (this.updateTracks())
+        this.onTracksChanged();
+      this.notifyInput(kind);
+    } finally {
+      this.inputs[kind].changing = false;
+      if (this.disposed) {
+        track?.stop();
+        this.inputTrack(kind)?.stop();
+      }
+    }
+  }
+  async applyEnabled(kind, enabled) {
+    if (kind === "audioinput")
+      await this.room.localParticipant.setMicrophoneEnabled(enabled, undefined, this.microphoneOptions);
+    else
+      await this.room.localParticipant.setCameraEnabled(enabled);
+  }
+  notifyInput(kind) {
+    if (kind === "audioinput")
+      this.onMicrophoneChanged();
+    else
+      this.onCameraChanged();
+  }
+  get isMuted() {
+    return !this.room.localParticipant.isMicrophoneEnabled;
+  }
+  get isVideoEnabled() {
+    return this.room.localParticipant.isCameraEnabled;
+  }
+  releaseDevices() {
+    for (const pub of this.room.localParticipant.trackPublications.values()) {
+      pub.track?.stop();
+    }
+  }
+  startSpeakingDetection() {
+    this.stopSpeakingDetection();
+    this.speakingHandler = (speaking) => {
+      if (speaking !== this._isSpeaking) {
+        this._isSpeaking = speaking;
+        this.onSpeakingChanged(speaking);
+      }
+    };
+    this.room.localParticipant.on(ParticipantEvent2.IsSpeakingChanged, this.speakingHandler);
+  }
+  stopSpeakingDetection() {
+    if (this.speakingHandler) {
+      this.room.localParticipant.off(ParticipantEvent2.IsSpeakingChanged, this.speakingHandler);
+      this.speakingHandler = null;
+    }
+    if (this._isSpeaking) {
+      this._isSpeaking = false;
+      this.onSpeakingChanged(false);
+    }
+  }
+}
+
+// src/providers/livekit/conversation.ts
+var DATA_EVENT_TOPIC = "nuance.data";
+var SESSION_TOPIC = "nuance.v1";
+var RUNTIME_TOPIC = "runtime";
+var CLOCK_SYNC_TOPIC = "clock-sync";
+var STATS_FLUSH_TIMEOUT_MS = 300;
+var SESSION_END_TIMEOUT_MS = 300;
+var SESSION_END_ID = "client-session-end";
+var COMMAND_TIMEOUT_MS = 5000;
+var BACKGROUND_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+var AVATAR_RETURN_TIMEOUT_MS = 8000;
+function isReconnecting(lkState) {
+  return lkState === ConnectionState2.Reconnecting || lkState === ConnectionState2.SignalReconnecting;
+}
+function mapConnectionState(lkState, resilient = false) {
+  switch (lkState) {
+    case ConnectionState2.Connected:
+      return "connected";
+    case ConnectionState2.Connecting:
+      return "connecting";
+    case ConnectionState2.Reconnecting:
+    case ConnectionState2.SignalReconnecting:
+      return resilient ? "reconnecting" : "connecting";
+    case ConnectionState2.Disconnected:
+      return "disconnected";
+  }
+}
+function mapConnectionQuality(quality) {
+  switch (quality) {
+    case ConnectionQuality.Poor:
+      return "poor";
+    case ConnectionQuality.Lost:
+      return "lost";
+    default:
+      return "good";
+  }
+}
+var QUALITY_RANK = {
+  good: 0,
+  poor: 1,
+  lost: 2
+};
+
+class LiveKitConversation {
+  room;
+  _state = "idle";
+  _user = null;
+  _avatar = new LiveKitAvatarParticipant(null);
+  stats = null;
+  presentation = null;
+  readyFallback = null;
+  layerFallback = null;
+  changeHandlers = new Set;
+  userQuality = "good";
+  avatarQuality = "good";
+  network = "good";
+  eventsRegistered = false;
+  sessionEnded = false;
+  speaksProtocol = false;
+  answered = null;
+  commands = new Map;
+  commandCount = 0;
+  readyOwed = false;
+  everConnected = false;
+  away = false;
+  awayTimer = null;
+  presentationPaused = false;
+  readySending = false;
+  leaving = null;
+  connectGeneration = 0;
+  _id;
+  serverUrl;
+  cameraEnabled;
+  cameraFacing;
+  tokenProvider;
+  opensOnReady;
+  resilient;
+  constructor(config) {
+    this.room = new Room({
+      audioCaptureDefaults: config.mediaDevices?.microphoneId ? { deviceId: { ideal: config.mediaDevices.microphoneId } } : undefined,
+      videoCaptureDefaults: {
+        ...config.videoCapture ? {
+          resolution: {
+            width: config.videoCapture.width,
+            height: config.videoCapture.height,
+            aspectRatio: config.videoCapture.aspectRatio ?? config.videoCapture.width / config.videoCapture.height
+          }
+        } : {},
+        ...config.mediaDevices?.cameraId && !config.mediaDevices.cameraFacing ? { deviceId: { ideal: config.mediaDevices.cameraId } } : {}
+      }
+    });
+    this._id = config.conversationId;
+    this.serverUrl = config.serverUrl;
+    this.cameraEnabled = config.cameraEnabled ?? true;
+    this.cameraFacing = config.mediaDevices?.cameraFacing;
+    this.tokenProvider = config.tokenProvider;
+    this.opensOnReady = config.opensOnReady ?? false;
+    this.resilient = config.resilientReconnect ?? false;
+  }
+  get id() {
+    return this._id;
+  }
+  async connect() {
+    if (this._state === "connecting" || this._state === "connected" || this._state === "reconnecting") {
+      throw new Error(`Cannot connect while in "${this._state}" state`);
+    }
+    this.setState("connecting");
+    this.sessionEnded = false;
+    this.speaksProtocol = false;
+    this.readyOwed = false;
+    this.everConnected = false;
+    if (!this.eventsRegistered) {
+      this.registerRoomEvents();
+      this.eventsRegistered = true;
+    }
+    const generation = this.connectGeneration;
+    const aborted = async () => {
+      if (generation === this.connectGeneration)
+        return false;
+      this._user?.cleanup();
+      this._user?.releaseDevices();
+      await this.room.disconnect();
+      this._user = null;
+      return true;
+    };
+    try {
+      const token = await this.tokenProvider();
+      if (await aborted())
+        return;
+      await this.room.connect(this.serverUrl, token);
+      if (await aborted())
+        return;
+      this._user = new LiveKitUserParticipant(this.room, () => this.emit({ type: "tracks-changed" }), (isSpeaking) => this.emit({
+        type: "speaking-changed",
+        participant: "user",
+        isSpeaking
+      }), () => this.emit({ type: "microphone-changed" }), () => this.emit({ type: "camera-changed" }), this.cameraFacing, this.resilient);
+      this._user.startSpeakingDetection();
+      try {
+        await this._user.unmuteAudio();
+      } catch (error) {
+        if (await aborted())
+          return;
+        throw new MediaAccessError(error, "microphone");
+      }
+      if (await aborted())
+        return;
+      if (this.cameraEnabled) {
+        try {
+          await this._user.enableVideo();
+        } catch {}
+      }
+      if (await aborted())
+        return;
+      this.everConnected = true;
+      this.setState("connected");
+      this.checkForExistingAvatar();
+      this.stats = new NetworkStatsReporter(this.room, (silent) => this.emit({ type: "mic-silent-changed", silent }));
+      this.stats.start();
+    } catch (error) {
+      if (!await aborted())
+        this.setState("failed");
+      throw error;
+    }
+  }
+  disconnect() {
+    this.leaving ??= this.leave().finally(() => {
+      this.leaving = null;
+    });
+    return this.leaving;
+  }
+  async leave() {
+    this.connectGeneration++;
+    this.stopPresentation();
+    this.stopReadyFallback();
+    this.stopLayerFallback();
+    this.clearAway();
+    this._user?.cleanup();
+    this._user?.releaseDevices();
+    await this.flushStats();
+    await this.sendSessionEnd();
+    await this.room.disconnect();
+    this._avatar.updateParticipant(null);
+    this._user = null;
+    this.setState("disconnected");
+  }
+  get state() {
+    return this._state;
+  }
+  get user() {
+    if (!this._user) {
+      throw new Error("Not connected — call connect() first");
+    }
+    return this._user;
+  }
+  get avatar() {
+    return this._avatar;
+  }
+  async setBackground(background) {
+    if (!BACKGROUND_ID.test(background)) {
+      throw new Error(`Not a background id: ${JSON.stringify(background)}`);
+    }
+    return this.command({ type: "scene.background", background });
+  }
+  onChange(handler) {
+    return this.onEvent((event) => {
+      if (event.type !== "data-event")
+        handler(event);
+    });
+  }
+  onEvent(handler) {
+    this.changeHandlers.add(handler);
+    return () => {
+      this.changeHandlers.delete(handler);
+    };
+  }
+  onDataEvent(handler) {
+    return this.onEvent((event) => {
+      if (event.type === "data-event") {
+        handler(event.event);
+      }
+    });
+  }
+  async command(command) {
+    if (this.room.state !== ConnectionState2.Connected) {
+      throw new Error("Not connected — call connect() first");
+    }
+    if (!this.speaksProtocol) {
+      throw new Error("The runtime takes no session commands");
+    }
+    const id = `client-command-${++this.commandCount}`;
+    const answer = Promise.withResolvers();
+    this.commands.set(id, { type: command.type, settle: answer.resolve });
+    let timer;
+    try {
+      return await Promise.race([
+        this.room.localParticipant.publishData(new TextEncoder().encode(JSON.stringify({ ...command, id })), { reliable: true, topic: SESSION_TOPIC }).then(() => answer.promise),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error(`The runtime did not answer ${command.type}`)), COMMAND_TIMEOUT_MS);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      this.commands.delete(id);
+    }
+  }
+  emit(event) {
+    for (const handler of this.changeHandlers) {
+      handler(event);
+    }
+  }
+  setState(state) {
+    this._state = state;
+    this.emit({ type: "state-changed", state });
+  }
+  updateNetwork() {
+    const worst = QUALITY_RANK[this.avatarQuality] > QUALITY_RANK[this.userQuality] ? this.avatarQuality : this.userQuality;
+    if (worst === this.network)
+      return;
+    this.network = worst;
+    this.emit({ type: "network-changed", quality: worst });
+  }
+  isAvatarParticipant(_participant) {
+    return true;
+  }
+  checkForExistingAvatar() {
+    for (const [, participant] of this.room.remoteParticipants) {
+      if (this.isAvatarParticipant(participant)) {
+        const tracksChanged = this._avatar.updateParticipant(participant);
+        this.emit({ type: "avatar-connected" });
+        if (tracksChanged) {
+          this.emit({ type: "tracks-changed" });
+        }
+        this.armReadyFallback();
+        return;
+      }
+    }
+  }
+  registerRoomEvents() {
+    this.room.on(RoomEvent3.ConnectionStateChanged, (lkState) => {
+      if (this._state === "idle")
+        return;
+      if (lkState === ConnectionState2.Disconnected)
+        return;
+      const mapped = mapConnectionState(lkState, this.resilient && this.everConnected);
+      if (mapped === "connected")
+        this.everConnected = true;
+      if (mapped !== this._state) {
+        this.setState(mapped);
+      }
+      if (lkState === ConnectionState2.Connected) {
+        this.sendOwedReady();
+        if (this.away)
+          this.awaitAvatarReturn();
+      }
+    });
+    this.room.on(RoomEvent3.ParticipantConnected, (participant) => {
+      if (this.isAvatarParticipant(participant)) {
+        const tracksChanged = this._avatar.updateParticipant(participant);
+        this.emit({ type: "avatar-connected" });
+        if (tracksChanged) {
+          this.emit({ type: "tracks-changed" });
+        }
+        if (this.away)
+          this.avatarBack();
+      }
+    });
+    this.room.on(RoomEvent3.ParticipantDisconnected, (participant) => {
+      if (!this.isAvatarParticipant(participant))
+        return;
+      if (!this.resilient) {
+        this.avatarLeft();
+        return;
+      }
+      queueMicrotask(() => {
+        if (this.room.state === ConnectionState2.Disconnected)
+          return;
+        if (isReconnecting(this.room.state))
+          this.avatarAway();
+        else
+          this.avatarLeft();
+      });
+    });
+    this.room.on(RoomEvent3.Disconnected, () => {
+      this.stats?.abandon();
+      this.stats = null;
+      this.stopPresentation();
+      this.stopReadyFallback();
+      this.stopLayerFallback();
+      this.clearAway();
+      this.readyOwed = false;
+      this._user?.cleanup();
+      this._avatar.updateParticipant(null);
+      this._user = null;
+      this.userQuality = "good";
+      this.avatarQuality = "good";
+      this.updateNetwork();
+      if (this.resilient) {
+        this.emit({ type: "avatar-disconnected" });
+        if (this._state === "reconnecting" && this.leaving === null) {
+          this.reportEnd("connection-lost");
+        }
+      }
+      this.setState("disconnected");
+    });
+    this.room.on(RoomEvent3.ConnectionQualityChanged, (quality, participant) => {
+      const mapped = mapConnectionQuality(quality);
+      if (participant === this.room.localParticipant) {
+        this.userQuality = mapped;
+      } else if (this.isAvatarParticipant(participant)) {
+        this.avatarQuality = mapped;
+      } else {
+        return;
+      }
+      this.updateNetwork();
+    });
+    this.room.on(RoomEvent3.TrackSubscribed, (_track, _publication, participant) => {
+      if (this.isAvatarParticipant(participant)) {
+        if (this._avatar.updateTracks()) {
+          this.emit({ type: "tracks-changed" });
+        }
+        this.armReadyFallback();
+      }
+    });
+    this.room.on(RoomEvent3.TrackUnsubscribed, (_track, _publication, participant) => {
+      if (this.isAvatarParticipant(participant)) {
+        if (this._avatar.updateTracks()) {
+          this.emit({ type: "tracks-changed" });
+        }
+      }
+    });
+    this.room.on(RoomEvent3.DataReceived, (payload, _participant, _kind, topic) => {
+      if (topic === SESSION_TOPIC) {
+        this.handleSessionEvent(payload);
+        return;
+      }
+      if (topic === RUNTIME_TOPIC) {
+        this.handleRuntimeSignal(payload);
+        return;
+      }
+      if (topic === CLOCK_SYNC_TOPIC) {
+        this.handleClockSyncPing(payload);
+        return;
+      }
+      if (topic !== DATA_EVENT_TOPIC)
+        return;
+      const event = parseDataEvent(payload);
+      if (event === null)
+        return;
+      this.emit({ type: "data-event", event });
+    });
+  }
+  async flushStats() {
+    const stats = this.stats;
+    this.stats = null;
+    if (!stats)
+      return;
+    await Promise.race([
+      stats.stop(),
+      new Promise((resolve) => setTimeout(resolve, STATS_FLUSH_TIMEOUT_MS))
+    ]).catch(() => {
+      return;
+    });
+  }
+  async sendSessionEnd() {
+    if (this.sessionEnded || !this.speaksProtocol || this.room.state !== ConnectionState2.Connected) {
+      return;
+    }
+    this.sessionEnded = true;
+    const answered = new Promise((resolve) => {
+      this.answered = resolve;
+    });
+    const command = new TextEncoder().encode(JSON.stringify({ type: "session.end", id: SESSION_END_ID }));
+    await Promise.race([
+      this.room.localParticipant.publishData(command, { reliable: true, topic: SESSION_TOPIC }).then(() => answered),
+      new Promise((resolve) => setTimeout(resolve, SESSION_END_TIMEOUT_MS))
+    ]).catch(() => {
+      return;
+    });
+    this.answered = null;
+  }
+  handleSessionEvent(payload) {
+    const event = parseSessionEvent(payload);
+    if (event === null)
+      return;
+    this.speaksProtocol = true;
+    if (event.type === "output-ready") {
+      this.markAvatarReady();
+    } else if (event.type === "command-result") {
+      if (event.id === SESSION_END_ID)
+        this.answered?.();
+      else if (event.id !== null) {
+        this.commands.get(event.id)?.settle(event.result);
+      }
+    } else if (event.type === "command-unreadable") {
+      const [oldest] = this.commands;
+      if (oldest) {
+        const [id, { type, settle }] = oldest;
+        this.commands.delete(id);
+        settle({ status: "rejected", error: `unknown command ${type}` });
+      }
+    } else if (event.type === "ended") {
+      this.answered?.();
+      if (!event.byClient)
+        this.reportEnd(event.reason);
+    }
+  }
+  handleRuntimeSignal(payload) {
+    const signal = parseRuntimeSignal(payload);
+    if (signal?.type === "session-ended") {
+      this.reportEnd(signal.reason);
+    } else if (signal?.type === "output-ready") {
+      this.markAvatarReady();
+    } else if (signal?.type === "link-poor") {
+      this.emit({ type: "link-poor" });
+    }
+  }
+  armReadyFallback() {
+    if (!this.resilient || this._avatar.isReady || this._avatar.videoTrack === null || this.readyFallback?.running) {
+      return;
+    }
+    this.readyFallback = new ReadyFallback(() => avatarFramesDecoded(this.room), () => this._avatar.isVideoPlaying, () => {
+      this.readyFallback = null;
+      if (this.opensOnReady)
+        this.speaksProtocol = true;
+      this.markAvatarReady();
+    });
+    this.readyFallback.start();
+  }
+  stopReadyFallback() {
+    this.readyFallback?.stop();
+    this.readyFallback = null;
+  }
+  markAvatarReady() {
+    this.stopReadyFallback();
+    if (this._avatar.isReady)
+      return;
+    this._avatar.markReady();
+    this.startLayerFallback();
+    this.emit({ type: "avatar-ready" });
+    if (!this.opensOnReady) {
+      this.emit({ type: "avatar-presented" });
+      return;
+    }
+    this.startPresentation();
+  }
+  startPresentation() {
+    this.presentation?.stop();
+    this.presentation = new PresentationWatch(() => avatarVideoSize(this.room), () => this.markAvatarPresented());
+    this.presentation.start();
+  }
+  markAvatarPresented() {
+    this.presentation = null;
+    if (this.speaksProtocol && this.room.state === ConnectionState2.Connected) {
+      this.command({ type: "session.ready" }).catch(() => {
+        return;
+      });
+    } else if (this.resilient && this.speaksProtocol && isReconnecting(this.room.state)) {
+      this.readyOwed = true;
+    }
+    this.emit({ type: "avatar-presented" });
+  }
+  sendOwedReady() {
+    if (!this.readyOwed || !this.speaksProtocol || this.readySending)
+      return;
+    this.readySending = true;
+    this.command({ type: "session.ready" }).then(() => {
+      this.readyOwed = false;
+    }).catch(() => {
+      return;
+    }).finally(() => {
+      this.readySending = false;
+    });
+  }
+  avatarLeft() {
+    this.stopPresentation();
+    this.stopReadyFallback();
+    this.stopLayerFallback();
+    this._avatar.updateParticipant(null);
+    this.avatarQuality = "good";
+    this.updateNetwork();
+    this.emit({ type: "avatar-disconnected" });
+  }
+  avatarAway() {
+    this.stopReadyFallback();
+    this.stopLayerFallback();
+    this.away = true;
+    if (this.presentation !== null) {
+      this.stopPresentation();
+      this.presentationPaused = true;
+    }
+    if (this._avatar.updateParticipant(null, true)) {
+      this.emit({ type: "tracks-changed" });
+    }
+    this.avatarQuality = "good";
+    this.updateNetwork();
+  }
+  awaitAvatarReturn() {
+    if (this.awayTimer !== null)
+      return;
+    this.awayTimer = setTimeout(() => {
+      this.awayTimer = null;
+      if (!this.away)
+        return;
+      this.clearAway();
+      this.avatarLeft();
+    }, AVATAR_RETURN_TIMEOUT_MS);
+  }
+  avatarBack() {
+    const resume = this.presentationPaused && this._avatar.isReady;
+    this.clearAway();
+    if (resume)
+      this.startPresentation();
+    if (this._avatar.isReady)
+      this.startLayerFallback();
+  }
+  clearAway() {
+    this.away = false;
+    this.presentationPaused = false;
+    if (this.awayTimer !== null) {
+      clearTimeout(this.awayTimer);
+      this.awayTimer = null;
+    }
+  }
+  startLayerFallback() {
+    if (this.layerFallback !== null)
+      return;
+    this.layerFallback = new LayerFallback(() => avatarVideoRate(this.room), (layer) => pinAvatarLayer(this.room, layer));
+    this.layerFallback.start();
+  }
+  stopLayerFallback() {
+    this.layerFallback?.stop();
+    this.layerFallback = null;
+  }
+  stopPresentation() {
+    this.presentation?.stop();
+    this.presentation = null;
+  }
+  reportEnd(reason) {
+    if (this.sessionEnded)
+      return;
+    this.sessionEnded = true;
+    this.emit({ type: "session-ended", reason });
+  }
+  handleClockSyncPing(payload) {
+    const reply = clockSyncPong(payload, Date.now() / 1000, () => Date.now() / 1000);
+    if (!reply)
+      return;
+    this.room.localParticipant.publishData(reply, {
+      reliable: true,
+      topic: CLOCK_SYNC_TOPIC
+    });
+  }
+}
+
+// src/conversation.ts
+var DEFAULT_HOST = "https://api.nuancelabs.ai";
+var QUEUE_HEARTBEAT_INTERVAL_MS = 5000;
+var HEARTBEAT_INTERVAL_MS = 5000;
+var ADMISSION_FAILED_BEATS = 6;
+var LOST_WINDOW_MS = 30000;
+function createNuanceConversation(options = {}) {
+  return new NuanceConversation(options);
+}
+var TERMINAL_STATUSES = new Set([
+  "failed",
+  "expired",
+  "ended"
+]);
+
+class DisconnectedError extends Error {
+  constructor() {
+    super("Disconnected while connecting");
+    this.name = "DisconnectedError";
+  }
+}
+
+class TerminalStatusError extends Error {
+  constructor(status) {
+    super(`Conversation reached terminal status "${status}"`);
+    this.name = "TerminalStatusError";
+  }
+}
+function isLegalRequiredBody(body) {
+  return isRecord(body) && body.code === "legal_required";
+}
+function isMaintenanceBody(body) {
+  return isRecord(body) && body.code === "maintenance";
+}
+function isCurfewBody(body) {
+  return isRecord(body) && body.code === "policy_curfew";
+}
+function browserTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || undefined;
+  } catch {
+    return;
+  }
+}
+var liveKitProvider = (connection, config) => new LiveKitConversation({
+  ...config,
+  serverUrl: connection.server_url,
+  tokenProvider: async () => connection.participant_token
+});
+
+class NuanceConversation {
+  api;
+  provider;
+  ensureMicrophone;
+  timezone;
+  ticker;
+  sessionOverrides;
+  personality;
+  variant;
+  videoCapture;
+  mediaDevices;
+  resilientReconnect;
+  delegate = null;
+  delegateUnsubscribe = null;
+  stopBeats = null;
+  admitted = null;
+  failedBeats = 0;
+  resilient = false;
+  reconnectingAt = null;
+  lostContact = false;
+  attempt = 0;
+  lastPosition = null;
+  lastEstimate = null;
+  capped = false;
+  ended = false;
+  limitTimer = null;
+  limitAt = null;
+  changeHandlers = new Set;
+  _state = "idle";
+  _id = null;
+  held = null;
+  constructor(options, deps = {}) {
+    this.api = deps.api ?? new NuanceApiClient({
+      host: options.host ?? DEFAULT_HOST,
+      headers: options.headers,
+      token: options.token
+    });
+    this.provider = deps.provider ?? liveKitProvider;
+    this.ensureMicrophone = deps.ensureMicrophone ?? ensureMicrophoneAccess;
+    this.timezone = deps.timezone ?? browserTimezone;
+    this.ticker = deps.ticker ?? pageTicker;
+    this.sessionOverrides = options.sessionOverrides ?? {};
+    this.personality = options.personality;
+    this.variant = options.variant;
+    this.videoCapture = options.videoCapture;
+    this.mediaDevices = options.mediaDevices;
+    this.resilientReconnect = options.resilientReconnect ?? false;
+  }
+  async connect() {
+    if (this._state === "connecting" || this._state === "queued" || this._state === "connected" || this._state === "reconnecting") {
+      throw new Error(`Cannot connect while in "${this._state}" state`);
+    }
+    const attempt = ++this.attempt;
+    this.setState("connecting");
+    this.clearLimit();
+    this.capped = false;
+    this.ended = false;
+    this.reconnectingAt = null;
+    this.lostContact = false;
+    this.lastPosition = null;
+    this.lastEstimate = null;
+    try {
+      const mediaDevices = {
+        ...typeof this.mediaDevices === "function" ? this.mediaDevices() : this.mediaDevices
+      };
+      await this.ensureMicrophone(mediaDevices.microphoneId);
+      let conversation;
+      try {
+        const request = {
+          session_overrides: this.sessionOverrides,
+          client_ready: true
+        };
+        const timezone = this.timezone();
+        if (timezone)
+          request.timezone = timezone;
+        if (this.personality)
+          request.personality = this.personality;
+        if (this.variant)
+          request.variant = this.variant;
+        conversation = await this.api.createConversation(request);
+      } catch (error) {
+        if (error instanceof ApiError && error.status === 409) {
+          throw new ActiveSessionError;
+        }
+        if (error instanceof ApiError && error.status === 403 && isLegalRequiredBody(error.body)) {
+          throw new LegalRequiredError;
+        }
+        if (error instanceof ApiError && error.status === 503 && isMaintenanceBody(error.body)) {
+          throw new MaintenanceError(typeof error.body.detail === "string" ? error.body.detail : "The service is under maintenance");
+        }
+        if (error instanceof ApiError && error.status === 403 && isCurfewBody(error.body)) {
+          throw new PolicyCurfewError(typeof error.body.retry_after_seconds === "number" ? error.body.retry_after_seconds : null);
+        }
+        throw error;
+      }
+      if (attempt !== this.attempt) {
+        await this.api.abandonConversation(conversation.id).catch(() => {});
+        throw new Error("Disconnected while creating the session");
+      }
+      this._id = conversation.id;
+      this.held = conversation.id;
+      this.emit({ type: "session-created", id: conversation.id });
+      this.admitted = Promise.withResolvers();
+      this.startHeartbeat(conversation.id, QUEUE_HEARTBEAT_INTERVAL_MS);
+      await this.admitted.promise;
+      this.delegate = await this.createDelegate(conversation, mediaDevices, attempt);
+      this.delegateUnsubscribe = this.delegate.onEvent((event) => {
+        if (event.type === "state-changed") {
+          this.setState(event.state);
+          return;
+        }
+        if (event.type === "session-ended" && event.reason === "connection-lost") {
+          const held = this.held;
+          this.held = null;
+          this.endSession(event.reason);
+          this.disconnect().catch(() => {});
+          if (held !== null) {
+            this.api.abandonConversation(held).catch(() => {});
+          }
+          return;
+        }
+        if (event.type === "session-ended") {
+          this.endSession(event.reason);
+          return;
+        }
+        this.emit(event);
+      });
+      await this.delegate.connect();
+      this.startHeartbeat(conversation.id, HEARTBEAT_INTERVAL_MS);
+    } catch (error) {
+      if (attempt !== this.attempt) {
+        throw error;
+      }
+      await this.disconnect().catch(() => {});
+      this.setState("failed");
+      throw error;
+    }
+  }
+  async disconnect() {
+    this.attempt += 1;
+    this.clearLimit();
+    this.stopHeartbeat();
+    this.admitted?.reject(new Error("Disconnected while waiting for a slot"));
+    this.admitted = null;
+    this.delegateUnsubscribe?.();
+    this.delegateUnsubscribe = null;
+    await this.delegate?.disconnect();
+    this.delegate = null;
+    await this.release();
+    this.setState("disconnected");
+  }
+  get state() {
+    return this._state;
+  }
+  get id() {
+    return this._id;
+  }
+  get user() {
+    if (!this.delegate) {
+      throw new Error("Not connected — call connect() first");
+    }
+    return this.delegate.user;
+  }
+  get avatar() {
+    if (!this.delegate) {
+      throw new Error("Not connected — call connect() first");
+    }
+    return this.delegate.avatar;
+  }
+  async setBackground(background) {
+    if (!this.delegate) {
+      throw new Error("Not connected — call connect() first");
+    }
+    return this.delegate.setBackground(background);
+  }
+  onChange(handler) {
+    return this.onEvent((event) => {
+      if (event.type !== "data-event")
+        handler(event);
+    });
+  }
+  onEvent(handler) {
+    this.changeHandlers.add(handler);
+    return () => {
+      this.changeHandlers.delete(handler);
+    };
+  }
+  onDataEvent(handler) {
+    return this.onEvent((event) => {
+      if (event.type === "data-event") {
+        handler(event.event);
+      }
+    });
+  }
+  async createDelegate(conversation, mediaDevices, attempt) {
+    if (conversation.provider !== "livekit") {
+      throw new Error(`Unsupported provider ${conversation.provider}`);
+    }
+    const response = await this.api.connectConversation(conversation.id);
+    if (attempt !== this.attempt) {
+      throw new DisconnectedError;
+    }
+    if (response.connection.kind !== "livekit") {
+      throw new Error(`Expected LiveKit connection, received ${response.connection.kind}`);
+    }
+    this.resilient = typeof this.resilientReconnect === "function" ? this.resilientReconnect() : this.resilientReconnect;
+    return this.provider(response.connection, {
+      conversationId: conversation.id,
+      mediaDevices,
+      cameraEnabled: !this.sessionOverrides.disable_camera && mediaDevices.cameraEnabled !== false,
+      videoCapture: this.videoCapture,
+      opensOnReady: conversation.provider_metadata?.client_ready === true,
+      resilientReconnect: this.resilient
+    });
+  }
+  startHeartbeat(conversationId, intervalMs) {
+    this.stopHeartbeat();
+    this.failedBeats = 0;
+    const attempt = this.attempt;
+    let currentMs = intervalMs;
+    const pace = (state) => {
+      const askedMs = state.next_beat_seconds != null ? state.next_beat_seconds * 1000 : intervalMs;
+      if (askedMs === currentMs || attempt !== this.attempt)
+        return;
+      currentMs = askedMs;
+      this.stopBeats?.();
+      this.stopBeats = this.ticker(beat, askedMs);
+    };
+    const beat = () => {
+      const sentAt = Date.now();
+      this.api.heartbeatConversation(conversationId).then((state) => {
+        if (attempt !== this.attempt)
+          return;
+        this.lostContact = this.failedBeats > 0;
+        this.failedBeats = 0;
+        this.applyQueueState(state, sentAt);
+        pace(state);
+      }).catch((error) => {
+        if (attempt !== this.attempt)
+          return;
+        if (!(error instanceof TerminalStatusError)) {
+          this.failedBeats += 1;
+          if (this.admitted && this.failedBeats >= ADMISSION_FAILED_BEATS) {
+            this.admitted.reject(new Error("Lost contact with the server while waiting", {
+              cause: error
+            }));
+            this.admitted = null;
+          }
+          return;
+        }
+        if (this.admitted) {
+          this.admitted.reject(error);
+          this.admitted = null;
+          return;
+        }
+        this.endSession(this.atLimit() ? "time-limit" : this.cutOff() ? "connection-lost" : this.capped ? "time-limit" : "ended");
+      });
+    };
+    beat();
+    this.stopBeats = this.ticker(beat, intervalMs);
+  }
+  applyQueueState(state, sentAt) {
+    if (TERMINAL_STATUSES.has(state.status)) {
+      throw new TerminalStatusError(state.status);
+    }
+    if (state.seconds_remaining != null) {
+      this.capped = true;
+      this.emit({
+        type: "time-remaining",
+        secondsRemaining: state.seconds_remaining
+      });
+      this.armLimit(state.seconds_remaining, sentAt);
+    }
+    if (state.status === "admitted" || state.status === "ready") {
+      this.admitted?.resolve();
+      this.admitted = null;
+      return;
+    }
+    if (state.status !== "queued" || state.position == null) {
+      return;
+    }
+    if (this._state !== "queued") {
+      this.setState("queued");
+    }
+    this.emit({
+      type: "queue-changed",
+      position: state.position,
+      estimatedWaitSeconds: this.smoothEstimate(state.position, state.estimated_wait_seconds ?? null),
+      poolSlots: state.pool_slots ?? null
+    });
+  }
+  smoothEstimate(position, estimate) {
+    if (estimate == null) {
+      return null;
+    }
+    const lostGround = this.lastPosition != null && position > this.lastPosition;
+    this.lastPosition = position;
+    if (lostGround || this.lastEstimate == null) {
+      this.lastEstimate = estimate;
+    } else {
+      this.lastEstimate = Math.min(this.lastEstimate, estimate);
+    }
+    return this.lastEstimate;
+  }
+  armLimit(seconds, sentAt) {
+    this.clearLimit();
+    this.limitAt = sentAt + Math.max(0, seconds) * 1000;
+    this.limitTimer = setTimeout(() => this.endSession("time-limit"), Math.max(0, seconds) * 1000);
+  }
+  clearLimit() {
+    this.limitAt = null;
+    if (this.limitTimer) {
+      clearTimeout(this.limitTimer);
+      this.limitTimer = null;
+    }
+  }
+  async release() {
+    const held = this.held;
+    this.held = null;
+    if (held === null || this.ended) {
+      return;
+    }
+    await this.api.abandonConversation(held).catch(() => {});
+  }
+  endSession(reason) {
+    if (this.ended) {
+      return;
+    }
+    this.ended = true;
+    this.clearLimit();
+    this.stopHeartbeat();
+    this.emit({ type: "session-ended", reason });
+  }
+  stopHeartbeat() {
+    this.stopBeats?.();
+    this.stopBeats = null;
+  }
+  emit(event) {
+    for (const handler of this.changeHandlers) {
+      handler(event);
+    }
+  }
+  atLimit() {
+    return this.limitAt !== null && Date.now() >= this.limitAt - HEARTBEAT_INTERVAL_MS;
+  }
+  cutOff() {
+    if (!this.resilient) {
+      return false;
+    }
+    if (this._state === "reconnecting" || this.lostContact) {
+      return true;
+    }
+    return this.reconnectingAt !== null && Date.now() - this.reconnectingAt < LOST_WINDOW_MS;
+  }
+  setState(state) {
+    if (state === this._state) {
+      return;
+    }
+    if (state === "reconnecting" || this._state === "reconnecting") {
+      this.reconnectingAt = Date.now();
+    }
+    this._state = state;
+    this.emit({ type: "state-changed", state });
+  }
+}
+// src/core/types.ts
+var ConversationState;
+((ConversationState2) => {
+  ConversationState2["Idle"] = "idle";
+  ConversationState2["Queued"] = "queued";
+  ConversationState2["Connecting"] = "connecting";
+  ConversationState2["Connected"] = "connected";
+  ConversationState2["Reconnecting"] = "reconnecting";
+  ConversationState2["Disconnected"] = "disconnected";
+  ConversationState2["Failed"] = "failed";
+})(ConversationState ||= {});
+export {
+  createNuanceConversation,
+  PolicyCurfewError,
+  MediaAccessError,
+  MaintenanceError,
+  LegalRequiredError,
+  ConversationState,
+  ActiveSessionError
+};