@daydreamlive/browser 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1058 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseDaydreamError: () => BaseDaydreamError,
+  Broadcast: () => Broadcast,
+  ConnectionError: () => ConnectionError,
+  DEFAULT_AUDIO_BITRATE: () => DEFAULT_AUDIO_BITRATE,
+  DEFAULT_ICE_SERVERS: () => DEFAULT_ICE_SERVERS,
+  DEFAULT_VIDEO_BITRATE: () => DEFAULT_VIDEO_BITRATE,
+  NetworkError: () => NetworkError,
+  Player: () => Player,
+  StreamNotFoundError: () => StreamNotFoundError,
+  UnauthorizedError: () => UnauthorizedError,
+  createBroadcast: () => createBroadcast2,
+  createPlayer: () => createPlayer2,
+  livepeerResponseHandler: () => livepeerResponseHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var DEFAULT_ICE_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" },
+  { urls: "stun:stun1.l.google.com:19302" },
+  { urls: "stun:stun.cloudflare.com:3478" }
+];
+var DEFAULT_VIDEO_BITRATE = 2e6;
+var DEFAULT_AUDIO_BITRATE = 64e3;
+
+// src/errors.ts
+var BaseDaydreamError = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "DaydreamError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+var NetworkError = class extends BaseDaydreamError {
+  constructor(message, cause) {
+    super("NETWORK_ERROR", message, cause);
+    this.name = "NetworkError";
+  }
+};
+var ConnectionError = class extends BaseDaydreamError {
+  constructor(message, cause) {
+    super("CONNECTION_FAILED", message, cause);
+    this.name = "ConnectionError";
+  }
+};
+var StreamNotFoundError = class extends BaseDaydreamError {
+  constructor(message, cause) {
+    super("STREAM_NOT_FOUND", message, cause);
+    this.name = "StreamNotFoundError";
+  }
+};
+var UnauthorizedError = class extends BaseDaydreamError {
+  constructor(message, cause) {
+    super("UNAUTHORIZED", message, cause);
+    this.name = "UnauthorizedError";
+  }
+};
+
+// src/internal/dependencies.ts
+var defaultMediaStreamFactory = {
+  create: () => new MediaStream()
+};
+var defaultPeerConnectionFactory = {
+  create: (config) => new RTCPeerConnection(config)
+};
+var defaultFetch = globalThis.fetch.bind(globalThis);
+var defaultTimerProvider = {
+  setTimeout: (cb, ms) => globalThis.setTimeout(cb, ms),
+  clearTimeout: (id) => globalThis.clearTimeout(id),
+  setInterval: (cb, ms) => globalThis.setInterval(cb, ms),
+  clearInterval: (id) => globalThis.clearInterval(id)
+};
+
+// src/internal/WHIPClient.ts
+var PLAYBACK_ID_PATTERN = /([/+])([^/+?]+)$/;
+var PLAYBACK_ID_PLACEHOLDER = "__PLAYBACK_ID__";
+var LRURedirectCache = class {
+  constructor(maxSize = 10) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const cached = this.cache.get(key);
+    if (cached) {
+      this.cache.delete(key);
+      this.cache.set(key, cached);
+    }
+    return cached;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+  }
+};
+function preferH264(sdp) {
+  const lines = sdp.split("\r\n");
+  const mLineIndex = lines.findIndex((line) => line.startsWith("m=video"));
+  if (mLineIndex === -1) return sdp;
+  const codecRegex = /a=rtpmap:(\d+) H264(\/\d+)+/;
+  const codecLine = lines.find((line) => codecRegex.test(line));
+  if (!codecLine) return sdp;
+  const match = codecRegex.exec(codecLine);
+  const codecPayload = match?.[1];
+  if (!codecPayload) return sdp;
+  const mLine = lines[mLineIndex];
+  if (!mLine) return sdp;
+  const mLineElements = mLine.split(" ");
+  const reorderedMLine = [
+    ...mLineElements.slice(0, 3),
+    codecPayload,
+    ...mLineElements.slice(3).filter((payload) => payload !== codecPayload)
+  ];
+  lines[mLineIndex] = reorderedMLine.join(" ");
+  return lines.join("\r\n");
+}
+var sharedRedirectCache = new LRURedirectCache();
+var WHIPClient = class {
+  constructor(config) {
+    this.pc = null;
+    this.resourceUrl = null;
+    this.abortController = null;
+    this.statsTimer = null;
+    this.videoSender = null;
+    this.audioSender = null;
+    this.videoTransceiver = null;
+    this.audioTransceiver = null;
+    this.iceGatheringTimer = null;
+    this.url = config.url;
+    this.iceServers = config.iceServers ?? DEFAULT_ICE_SERVERS;
+    this.videoBitrate = config.videoBitrate ?? DEFAULT_VIDEO_BITRATE;
+    this.audioBitrate = config.audioBitrate ?? DEFAULT_AUDIO_BITRATE;
+    this.maxFramerate = config.maxFramerate;
+    this.onStats = config.onStats;
+    this.statsIntervalMs = config.statsIntervalMs ?? 5e3;
+    this.onResponse = config.onResponse;
+    this.pcFactory = config.peerConnectionFactory ?? defaultPeerConnectionFactory;
+    this.fetch = config.fetch ?? defaultFetch;
+    this.timers = config.timers ?? defaultTimerProvider;
+    this.redirectCache = config.redirectCache ?? sharedRedirectCache;
+    this.skipIceGathering = config.skipIceGathering ?? true;
+  }
+  async connect(stream) {
+    this.cleanup();
+    this.pc = this.pcFactory.create({
+      iceServers: this.iceServers,
+      iceCandidatePoolSize: 10
+    });
+    this.videoTransceiver = this.pc.addTransceiver("video", {
+      direction: "sendonly"
+    });
+    this.audioTransceiver = this.pc.addTransceiver("audio", {
+      direction: "sendonly"
+    });
+    this.videoSender = this.videoTransceiver.sender;
+    this.audioSender = this.audioTransceiver.sender;
+    const videoTrack = stream.getVideoTracks()[0];
+    const audioTrack = stream.getAudioTracks()[0];
+    if (videoTrack) {
+      if (videoTrack.contentHint === "") {
+        videoTrack.contentHint = "motion";
+      }
+      await this.videoSender.replaceTrack(videoTrack);
+    }
+    if (audioTrack) {
+      await this.audioSender.replaceTrack(audioTrack);
+    }
+    this.setCodecPreferences();
+    await this.applyBitrateConstraints();
+    const offer = await this.pc.createOffer({
+      offerToReceiveAudio: false,
+      offerToReceiveVideo: false
+    });
+    const enhancedSdp = preferH264(offer.sdp ?? "");
+    await this.pc.setLocalDescription({ type: "offer", sdp: enhancedSdp });
+    if (!this.skipIceGathering) {
+      await this.waitForIceGathering();
+    }
+    this.abortController = new AbortController();
+    const timeoutId = this.timers.setTimeout(
+      () => this.abortController?.abort(),
+      1e4
+    );
+    try {
+      const fetchUrl = this.getUrlWithCachedRedirect();
+      const response = await this.fetch(fetchUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/sdp" },
+        body: this.pc.localDescription.sdp,
+        signal: this.abortController.signal
+      });
+      this.timers.clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new ConnectionError(
+          `WHIP connection failed: ${response.status} ${response.statusText} ${errorText}`
+        );
+      }
+      this.cacheRedirectIfNeeded(fetchUrl, response.url);
+      const location = response.headers.get("location");
+      if (location) {
+        this.resourceUrl = new URL(location, this.url).toString();
+      }
+      const responseResult = this.onResponse?.(response);
+      const answerSdp = await response.text();
+      await this.pc.setRemoteDescription({ type: "answer", sdp: answerSdp });
+      await this.applyBitrateConstraints();
+      this.startStatsTimer();
+      return { whepUrl: responseResult?.whepUrl ?? null };
+    } catch (error) {
+      this.timers.clearTimeout(timeoutId);
+      if (error instanceof ConnectionError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Connection timeout");
+      }
+      throw new NetworkError("Failed to establish connection", error);
+    }
+  }
+  setCodecPreferences() {
+    if (!this.videoTransceiver?.setCodecPreferences) return;
+    try {
+      const caps = RTCRtpSender.getCapabilities("video");
+      if (!caps?.codecs?.length) return;
+      const h264Codecs = caps.codecs.filter(
+        (c) => c.mimeType.toLowerCase().includes("h264")
+      );
+      if (h264Codecs.length) {
+        this.videoTransceiver.setCodecPreferences(h264Codecs);
+      }
+    } catch {
+    }
+  }
+  async applyBitrateConstraints() {
+    if (!this.pc) return;
+    const senders = this.pc.getSenders();
+    for (const sender of senders) {
+      if (!sender.track) continue;
+      const params = sender.getParameters();
+      if (!params.encodings) params.encodings = [{}];
+      const encoding = params.encodings[0];
+      if (!encoding) continue;
+      if (sender.track.kind === "video") {
+        encoding.maxBitrate = this.videoBitrate;
+        if (this.maxFramerate && this.maxFramerate > 0) {
+          encoding.maxFramerate = this.maxFramerate;
+        }
+        encoding.scaleResolutionDownBy = 1;
+        encoding.priority = "high";
+        encoding.networkPriority = "high";
+        params.degradationPreference = "maintain-resolution";
+      } else if (sender.track.kind === "audio") {
+        encoding.maxBitrate = this.audioBitrate;
+        encoding.priority = "medium";
+        encoding.networkPriority = "medium";
+      }
+      try {
+        await sender.setParameters(params);
+      } catch {
+      }
+    }
+  }
+  waitForIceGathering() {
+    return new Promise((resolve) => {
+      if (!this.pc) {
+        resolve();
+        return;
+      }
+      if (this.pc.iceGatheringState === "complete") {
+        resolve();
+        return;
+      }
+      const onStateChange = () => {
+        if (this.pc?.iceGatheringState === "complete") {
+          this.pc.removeEventListener("icegatheringstatechange", onStateChange);
+          if (this.iceGatheringTimer !== null) {
+            this.timers.clearTimeout(this.iceGatheringTimer);
+            this.iceGatheringTimer = null;
+          }
+          resolve();
+        }
+      };
+      this.pc.addEventListener("icegatheringstatechange", onStateChange);
+      this.iceGatheringTimer = this.timers.setTimeout(() => {
+        this.pc?.removeEventListener("icegatheringstatechange", onStateChange);
+        this.iceGatheringTimer = null;
+        resolve();
+      }, 1e3);
+    });
+  }
+  startStatsTimer() {
+    if (!this.onStats || !this.pc) return;
+    this.stopStatsTimer();
+    this.statsTimer = this.timers.setInterval(async () => {
+      if (!this.pc) return;
+      try {
+        const report = await this.pc.getStats();
+        this.onStats?.(report);
+      } catch {
+      }
+    }, this.statsIntervalMs);
+  }
+  stopStatsTimer() {
+    if (this.statsTimer !== null) {
+      this.timers.clearInterval(this.statsTimer);
+      this.statsTimer = null;
+    }
+  }
+  async replaceTrack(track) {
+    if (!this.pc) {
+      throw new ConnectionError("Not connected");
+    }
+    const sender = track.kind === "video" ? this.videoSender : this.audioSender;
+    if (!sender) {
+      throw new ConnectionError(
+        `No sender found for track kind: ${track.kind}`
+      );
+    }
+    await sender.replaceTrack(track);
+    await this.applyBitrateConstraints();
+  }
+  setMaxFramerate(fps) {
+    this.maxFramerate = fps;
+    void this.applyBitrateConstraints();
+  }
+  cleanup() {
+    this.stopStatsTimer();
+    if (this.iceGatheringTimer !== null) {
+      this.timers.clearTimeout(this.iceGatheringTimer);
+      this.iceGatheringTimer = null;
+    }
+    if (this.abortController) {
+      try {
+        this.abortController.abort();
+      } catch {
+      }
+      this.abortController = null;
+    }
+    if (this.pc) {
+      try {
+        this.pc.getTransceivers().forEach((t) => {
+          try {
+            t.stop();
+          } catch {
+          }
+        });
+      } catch {
+      }
+      try {
+        this.pc.close();
+      } catch {
+      }
+      this.pc = null;
+    }
+    this.videoSender = null;
+    this.audioSender = null;
+    this.videoTransceiver = null;
+    this.audioTransceiver = null;
+  }
+  async disconnect() {
+    if (this.resourceUrl) {
+      try {
+        await this.fetch(this.resourceUrl, { method: "DELETE" });
+      } catch {
+      }
+    }
+    this.cleanup();
+    this.resourceUrl = null;
+  }
+  getPeerConnection() {
+    return this.pc;
+  }
+  restartIce() {
+    if (this.pc) {
+      try {
+        this.pc.restartIce();
+      } catch {
+      }
+    }
+  }
+  isConnected() {
+    return this.pc !== null && this.pc.connectionState === "connected";
+  }
+  getUrlWithCachedRedirect() {
+    const originalUrl = new URL(this.url);
+    const playbackIdMatch = originalUrl.pathname.match(PLAYBACK_ID_PATTERN);
+    const playbackId = playbackIdMatch?.[2];
+    const cachedTemplate = this.redirectCache.get(this.url);
+    if (!cachedTemplate || !playbackId) {
+      return this.url;
+    }
+    const redirectedUrl = new URL(cachedTemplate);
+    redirectedUrl.pathname = cachedTemplate.pathname.replace(
+      PLAYBACK_ID_PLACEHOLDER,
+      playbackId
+    );
+    return redirectedUrl.toString();
+  }
+  cacheRedirectIfNeeded(requestUrl, responseUrl) {
+    if (requestUrl === responseUrl) return;
+    try {
+      const actualRedirect = new URL(responseUrl);
+      const template = new URL(actualRedirect);
+      template.pathname = template.pathname.replace(
+        PLAYBACK_ID_PATTERN,
+        `$1${PLAYBACK_ID_PLACEHOLDER}`
+      );
+      this.redirectCache.set(this.url, template);
+    } catch {
+    }
+  }
+};
+
+// src/internal/TypedEventEmitter.ts
+var TypedEventEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+    return this;
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+    return this;
+  }
+  emit(event, ...args) {
+    this.listeners.get(event)?.forEach((handler) => {
+      handler(...args);
+    });
+  }
+  clearListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/internal/StateMachine.ts
+function createStateMachine(initial, transitions, onChange) {
+  let current = initial;
+  return {
+    get current() {
+      return current;
+    },
+    can(next) {
+      return transitions[current].includes(next);
+    },
+    transition(next) {
+      if (!transitions[current].includes(next)) return false;
+      const prev = current;
+      current = next;
+      onChange?.(prev, next);
+      return true;
+    },
+    force(next) {
+      const prev = current;
+      current = next;
+      onChange?.(prev, next);
+    }
+  };
+}
+
+// src/Broadcast.ts
+var BROADCAST_TRANSITIONS = {
+  connecting: ["live", "error"],
+  live: ["reconnecting", "ended"],
+  reconnecting: ["live", "ended"],
+  ended: [],
+  error: ["connecting"]
+};
+var Broadcast = class extends TypedEventEmitter {
+  constructor(config) {
+    super();
+    this._whepUrl = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimeout = null;
+    this.disconnectedGraceTimeout = null;
+    this.currentStream = config.stream;
+    this.reconnectConfig = {
+      enabled: config.reconnect?.enabled ?? true,
+      maxAttempts: config.reconnect?.maxAttempts ?? 5,
+      baseDelayMs: config.reconnect?.baseDelayMs ?? 1e3
+    };
+    this.whipClient = new WHIPClient({
+      url: config.whipUrl,
+      ...config.whipConfig
+    });
+    this.stateMachine = createStateMachine(
+      "connecting",
+      BROADCAST_TRANSITIONS,
+      (_from, to) => this.emit("stateChange", to)
+    );
+  }
+  get state() {
+    return this.stateMachine.current;
+  }
+  get whepUrl() {
+    return this._whepUrl;
+  }
+  get stream() {
+    return this.currentStream;
+  }
+  async connect() {
+    try {
+      const result = await this.whipClient.connect(this.currentStream);
+      if (result.whepUrl) {
+        this._whepUrl = result.whepUrl;
+      }
+      this.setupConnectionMonitoring();
+      this.stateMachine.transition("live");
+    } catch (error) {
+      this.stateMachine.transition("error");
+      const daydreamError = error instanceof Error ? error : new ConnectionError("Failed to connect", error);
+      this.emit("error", daydreamError);
+      throw daydreamError;
+    }
+  }
+  async stop() {
+    this.stateMachine.force("ended");
+    this.clearTimeouts();
+    await this.whipClient.disconnect();
+    this.clearListeners();
+  }
+  async replaceStream(newStream) {
+    if (!this.whipClient.isConnected()) {
+      this.currentStream = newStream;
+      return;
+    }
+    const videoTrack = newStream.getVideoTracks()[0];
+    const audioTrack = newStream.getAudioTracks()[0];
+    try {
+      if (videoTrack) {
+        await this.whipClient.replaceTrack(videoTrack);
+      }
+      if (audioTrack) {
+        await this.whipClient.replaceTrack(audioTrack);
+      }
+      this.currentStream = newStream;
+    } catch {
+      this.currentStream = newStream;
+      this.scheduleReconnect();
+    }
+  }
+  setupConnectionMonitoring() {
+    const pc = this.whipClient.getPeerConnection();
+    if (!pc) return;
+    pc.onconnectionstatechange = () => {
+      if (this.state === "ended") return;
+      const connState = pc.connectionState;
+      if (connState === "connected") {
+        this.clearGraceTimeout();
+        if (this.state === "reconnecting") {
+          this.stateMachine.transition("live");
+          this.reconnectAttempts = 0;
+        }
+        return;
+      }
+      if (connState === "disconnected") {
+        this.clearGraceTimeout();
+        this.whipClient.restartIce();
+        this.disconnectedGraceTimeout = setTimeout(() => {
+          if (this.state === "ended") return;
+          const currentState = pc.connectionState;
+          if (currentState === "disconnected") {
+            this.scheduleReconnect();
+          }
+        }, 2e3);
+        return;
+      }
+      if (connState === "failed" || connState === "closed") {
+        this.clearGraceTimeout();
+        this.scheduleReconnect();
+      }
+    };
+  }
+  clearGraceTimeout() {
+    if (this.disconnectedGraceTimeout) {
+      clearTimeout(this.disconnectedGraceTimeout);
+      this.disconnectedGraceTimeout = null;
+    }
+  }
+  clearReconnectTimeout() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  clearTimeouts() {
+    this.clearGraceTimeout();
+    this.clearReconnectTimeout();
+  }
+  scheduleReconnect() {
+    if (this.state === "ended") return;
+    if (!this.reconnectConfig.enabled) {
+      this.stateMachine.transition("ended");
+      return;
+    }
+    const maxAttempts = this.reconnectConfig.maxAttempts ?? 5;
+    if (this.reconnectAttempts >= maxAttempts) {
+      this.stateMachine.transition("ended");
+      return;
+    }
+    this.clearReconnectTimeout();
+    this.stateMachine.transition("reconnecting");
+    const baseDelay = this.reconnectConfig.baseDelayMs ?? 1e3;
+    const delay = baseDelay * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    this.reconnectTimeout = setTimeout(async () => {
+      if (this.state === "ended") return;
+      try {
+        await this.whipClient.disconnect();
+        const result = await this.whipClient.connect(this.currentStream);
+        if (result.whepUrl) {
+          this._whepUrl = result.whepUrl;
+        }
+        this.setupConnectionMonitoring();
+        this.stateMachine.transition("live");
+        this.reconnectAttempts = 0;
+      } catch {
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+};
+function createBroadcast(options) {
+  const {
+    whipUrl,
+    stream,
+    reconnect,
+    video,
+    onStats,
+    statsIntervalMs,
+    onResponse
+  } = options;
+  return new Broadcast({
+    whipUrl,
+    stream,
+    reconnect,
+    whipConfig: {
+      videoBitrate: video?.bitrate,
+      maxFramerate: video?.maxFramerate,
+      onStats,
+      statsIntervalMs,
+      onResponse
+    }
+  });
+}
+
+// src/internal/WHEPClient.ts
+var WHEPClient = class {
+  constructor(config) {
+    this.pc = null;
+    this.resourceUrl = null;
+    this.stream = null;
+    this.abortController = null;
+    this.statsTimer = null;
+    this.iceGatheringTimer = null;
+    this.url = config.url;
+    this.iceServers = config.iceServers ?? DEFAULT_ICE_SERVERS;
+    this.onStats = config.onStats;
+    this.statsIntervalMs = config.statsIntervalMs ?? 5e3;
+    this.pcFactory = config.peerConnectionFactory ?? defaultPeerConnectionFactory;
+    this.fetch = config.fetch ?? defaultFetch;
+    this.timers = config.timers ?? defaultTimerProvider;
+    this.mediaStreamFactory = config.mediaStreamFactory ?? defaultMediaStreamFactory;
+  }
+  async connect() {
+    this.cleanup();
+    this.pc = this.pcFactory.create({
+      iceServers: this.iceServers
+    });
+    this.pc.addTransceiver("video", { direction: "recvonly" });
+    this.pc.addTransceiver("audio", { direction: "recvonly" });
+    this.stream = this.mediaStreamFactory.create();
+    this.pc.ontrack = (event) => {
+      const [remoteStream] = event.streams;
+      if (remoteStream) {
+        this.stream = remoteStream;
+      } else if (this.stream) {
+        this.stream.addTrack(event.track);
+      }
+    };
+    const offer = await this.pc.createOffer();
+    await this.pc.setLocalDescription(offer);
+    await this.waitForIceGathering();
+    this.abortController = new AbortController();
+    const timeoutId = this.timers.setTimeout(
+      () => this.abortController?.abort(),
+      1e4
+    );
+    try {
+      const response = await this.fetch(this.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/sdp" },
+        body: this.pc.localDescription.sdp,
+        signal: this.abortController.signal
+      });
+      this.timers.clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new ConnectionError(
+          `WHEP connection failed: ${response.status} ${response.statusText} ${errorText}`
+        );
+      }
+      const location = response.headers.get("location");
+      if (location) {
+        this.resourceUrl = new URL(location, this.url).toString();
+      }
+      const answerSdp = await response.text();
+      await this.pc.setRemoteDescription({ type: "answer", sdp: answerSdp });
+      this.startStatsTimer();
+      return this.stream;
+    } catch (error) {
+      this.timers.clearTimeout(timeoutId);
+      if (error instanceof ConnectionError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError("Connection timeout");
+      }
+      throw new NetworkError("Failed to establish connection", error);
+    }
+  }
+  waitForIceGathering() {
+    return new Promise((resolve) => {
+      if (!this.pc) {
+        resolve();
+        return;
+      }
+      if (this.pc.iceGatheringState === "complete") {
+        resolve();
+        return;
+      }
+      const onStateChange = () => {
+        if (this.pc?.iceGatheringState === "complete") {
+          this.pc.removeEventListener("icegatheringstatechange", onStateChange);
+          if (this.iceGatheringTimer !== null) {
+            this.timers.clearTimeout(this.iceGatheringTimer);
+            this.iceGatheringTimer = null;
+          }
+          resolve();
+        }
+      };
+      this.pc.addEventListener("icegatheringstatechange", onStateChange);
+      this.iceGatheringTimer = this.timers.setTimeout(() => {
+        this.pc?.removeEventListener("icegatheringstatechange", onStateChange);
+        this.iceGatheringTimer = null;
+        resolve();
+      }, 1e3);
+    });
+  }
+  startStatsTimer() {
+    if (!this.onStats || !this.pc) return;
+    this.stopStatsTimer();
+    this.statsTimer = this.timers.setInterval(async () => {
+      if (!this.pc) return;
+      try {
+        const report = await this.pc.getStats();
+        this.onStats?.(report);
+      } catch {
+      }
+    }, this.statsIntervalMs);
+  }
+  stopStatsTimer() {
+    if (this.statsTimer !== null) {
+      this.timers.clearInterval(this.statsTimer);
+      this.statsTimer = null;
+    }
+  }
+  cleanup() {
+    this.stopStatsTimer();
+    if (this.iceGatheringTimer !== null) {
+      this.timers.clearTimeout(this.iceGatheringTimer);
+      this.iceGatheringTimer = null;
+    }
+    if (this.abortController) {
+      try {
+        this.abortController.abort();
+      } catch {
+      }
+      this.abortController = null;
+    }
+    if (this.pc) {
+      try {
+        this.pc.getTransceivers().forEach((t) => {
+          try {
+            t.stop();
+          } catch {
+          }
+        });
+      } catch {
+      }
+      try {
+        this.pc.close();
+      } catch {
+      }
+      this.pc = null;
+    }
+  }
+  async disconnect() {
+    if (this.resourceUrl) {
+      try {
+        await this.fetch(this.resourceUrl, { method: "DELETE" });
+      } catch {
+      }
+    }
+    this.cleanup();
+    this.stream = null;
+    this.resourceUrl = null;
+  }
+  getStream() {
+    return this.stream;
+  }
+  getPeerConnection() {
+    return this.pc;
+  }
+  restartIce() {
+    if (this.pc) {
+      try {
+        this.pc.restartIce();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/Player.ts
+var PLAYER_TRANSITIONS = {
+  connecting: ["playing", "buffering", "error"],
+  playing: ["buffering", "ended"],
+  buffering: ["playing", "ended"],
+  ended: [],
+  error: ["connecting"]
+};
+var Player = class extends TypedEventEmitter {
+  constructor(config) {
+    super();
+    this._stream = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimeout = null;
+    this.disconnectedGraceTimeout = null;
+    this.whepUrl = config.whepUrl;
+    this.whepConfig = config.whepConfig;
+    this.reconnectConfig = {
+      enabled: config.reconnect?.enabled ?? true,
+      maxAttempts: config.reconnect?.maxAttempts ?? 30,
+      baseDelayMs: config.reconnect?.baseDelayMs ?? 200
+    };
+    this.whepClient = new WHEPClient({
+      url: config.whepUrl,
+      ...this.whepConfig
+    });
+    this.stateMachine = createStateMachine(
+      "connecting",
+      PLAYER_TRANSITIONS,
+      (_from, to) => this.emit("stateChange", to)
+    );
+  }
+  get state() {
+    return this.stateMachine.current;
+  }
+  get stream() {
+    return this._stream;
+  }
+  async connect() {
+    try {
+      this._stream = await this.whepClient.connect();
+      this.setupConnectionMonitoring();
+      this.stateMachine.transition("playing");
+      this.reconnectAttempts = 0;
+    } catch (error) {
+      if (this.reconnectConfig.enabled && this.reconnectAttempts < (this.reconnectConfig.maxAttempts ?? 30)) {
+        this.scheduleReconnect();
+        return;
+      }
+      this.stateMachine.transition("error");
+      const daydreamError = error instanceof Error ? error : new ConnectionError("Failed to connect", error);
+      this.emit("error", daydreamError);
+      throw daydreamError;
+    }
+  }
+  attachTo(video) {
+    if (this._stream) {
+      video.srcObject = this._stream;
+    }
+  }
+  async stop() {
+    this.stateMachine.force("ended");
+    this.clearTimeouts();
+    await this.whepClient.disconnect();
+    this._stream = null;
+    this.clearListeners();
+  }
+  setupConnectionMonitoring() {
+    const pc = this.whepClient.getPeerConnection();
+    if (!pc) return;
+    pc.oniceconnectionstatechange = () => {
+      if (this.state === "ended") return;
+      const iceState = pc.iceConnectionState;
+      if (iceState === "connected" || iceState === "completed") {
+        this.clearGraceTimeout();
+        if (this.state === "buffering") {
+          this.stateMachine.transition("playing");
+          this.reconnectAttempts = 0;
+        }
+        return;
+      }
+      if (iceState === "disconnected") {
+        this.clearGraceTimeout();
+        this.whepClient.restartIce();
+        this.disconnectedGraceTimeout = setTimeout(() => {
+          if (this.state === "ended") return;
+          const currentState = pc.iceConnectionState;
+          if (currentState === "disconnected") {
+            this.scheduleReconnect();
+          }
+        }, 2e3);
+        return;
+      }
+      if (iceState === "failed" || iceState === "closed") {
+        this.clearGraceTimeout();
+        this.scheduleReconnect();
+      }
+    };
+  }
+  clearGraceTimeout() {
+    if (this.disconnectedGraceTimeout) {
+      clearTimeout(this.disconnectedGraceTimeout);
+      this.disconnectedGraceTimeout = null;
+    }
+  }
+  clearReconnectTimeout() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  clearTimeouts() {
+    this.clearGraceTimeout();
+    this.clearReconnectTimeout();
+  }
+  scheduleReconnect() {
+    if (this.state === "ended") return;
+    if (!this.reconnectConfig.enabled) {
+      this.stateMachine.transition("ended");
+      return;
+    }
+    const maxAttempts = this.reconnectConfig.maxAttempts ?? 10;
+    if (this.reconnectAttempts >= maxAttempts) {
+      this.stateMachine.transition("ended");
+      return;
+    }
+    this.clearReconnectTimeout();
+    this.stateMachine.transition("buffering");
+    const baseDelay = this.reconnectConfig.baseDelayMs ?? 300;
+    const delay = this.calculateReconnectDelay(
+      this.reconnectAttempts,
+      baseDelay
+    );
+    this.reconnectAttempts++;
+    this.reconnectTimeout = setTimeout(async () => {
+      if (this.state === "ended") return;
+      try {
+        await this.whepClient.disconnect();
+        this.whepClient = new WHEPClient({
+          url: this.whepUrl,
+          ...this.whepConfig
+        });
+        this._stream = await this.whepClient.connect();
+        this.setupConnectionMonitoring();
+        this.stateMachine.transition("playing");
+        this.reconnectAttempts = 0;
+      } catch {
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  calculateReconnectDelay(attempt, baseDelay) {
+    const linearPhaseEndCount = 10;
+    const maxDelay = 6e4;
+    if (attempt === 0) return 0;
+    if (attempt <= linearPhaseEndCount) return baseDelay;
+    const exponentialAttempt = attempt - linearPhaseEndCount;
+    const delay = 500 * Math.pow(2, exponentialAttempt - 1);
+    return Math.min(delay, maxDelay);
+  }
+};
+function createPlayer(whepUrl, options) {
+  return new Player({
+    whepUrl,
+    reconnect: options?.reconnect,
+    whepConfig: {
+      onStats: options?.onStats,
+      statsIntervalMs: options?.statsIntervalMs
+    }
+  });
+}
+
+// src/index.ts
+var livepeerResponseHandler = (response) => ({
+  whepUrl: response.headers.get("livepeer-playback-url") ?? void 0
+});
+function createBroadcast2(options) {
+  return createBroadcast({
+    ...options,
+    onResponse: livepeerResponseHandler
+  });
+}
+function createPlayer2(whepUrl, options) {
+  return createPlayer(whepUrl, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseDaydreamError,
+  Broadcast,
+  ConnectionError,
+  DEFAULT_AUDIO_BITRATE,
+  DEFAULT_ICE_SERVERS,
+  DEFAULT_VIDEO_BITRATE,
+  NetworkError,
+  Player,
+  StreamNotFoundError,
+  UnauthorizedError,
+  createBroadcast,
+  createPlayer,
+  livepeerResponseHandler
+});
+//# sourceMappingURL=index.cjs.map