@mebius-io/web 0.1.0

package/dist/index.cjs

@@ -0,0 +1,723 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Mebius: () => Mebius,
+  MebiusBroadcaster: () => MebiusBroadcaster,
+  MebiusClient: () => MebiusClient,
+  MebiusError: () => MebiusError,
+  MebiusPlayer: () => MebiusPlayer,
+  mebiusError: () => mebiusError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var MebiusError = class _MebiusError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "MebiusError";
+    this.code = code;
+    this.cause = cause;
+    Object.setPrototypeOf(this, _MebiusError.prototype);
+  }
+};
+var DEFAULT_MESSAGES = {
+  TOKEN_EXPIRED: "Your Mebius token has expired. Mint a fresh token and reconnect.",
+  PERMISSION_DENIED: "Camera/microphone permission was denied by the user or browser.",
+  CONNECTION_FAILED: "Could not establish a connection to the Mebius gateway.",
+  NOT_CONNECTED: "Not connected to Mebius. Call connect() before using this client.",
+  STREAM_NOT_FOUND: "The requested stream could not be found on the Mebius gateway.",
+  UNKNOWN: "An unexpected Mebius error occurred."
+};
+function mebiusError(code, message, cause) {
+  return new MebiusError(code, message ?? DEFAULT_MESSAGES[code], cause);
+}
+
+// src/events.ts
+var TypedEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  /** Subscribe to an event. Returns an unsubscribe function. */
+  on(event, cb) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(cb);
+    return () => this.off(event, cb);
+  }
+  /** Unsubscribe a previously-registered listener. */
+  off(event, cb) {
+    this.listeners.get(event)?.delete(cb);
+  }
+  /** Emit an event to all listeners. Internal use. */
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const cb of [...set]) cb(payload);
+  }
+  /** Remove every listener. Internal use during teardown. */
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/internal/view-target.ts
+function resolveVideoElement(target) {
+  if (typeof target !== "string") {
+    if (target instanceof HTMLVideoElement) return target;
+    throw mebiusError("UNKNOWN", "View target must be a <video> element or a CSS selector.");
+  }
+  const el = document.querySelector(target);
+  if (!el) {
+    throw mebiusError("UNKNOWN", `No element matches the selector "${target}".`);
+  }
+  if (!(el instanceof HTMLVideoElement)) {
+    throw mebiusError("UNKNOWN", `Selector "${target}" did not resolve to a <video> element.`);
+  }
+  return el;
+}
+
+// src/internal/webrtc-util.ts
+function waitForIceGathering(pc, timeoutMs = 2e3) {
+  if (pc.iceGatheringState === "complete") return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      pc.removeEventListener("icegatheringstatechange", check);
+      clearTimeout(timer);
+      resolve();
+    };
+    const check = () => {
+      if (pc.iceGatheringState === "complete") done();
+    };
+    const timer = setTimeout(done, timeoutMs);
+    pc.addEventListener("icegatheringstatechange", check);
+  });
+}
+var DEFAULT_RTC_CONFIG = {
+  iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+};
+
+// src/internal/publish-transport.ts
+var WhipPublishTransport = class {
+  constructor(signaling) {
+    this.signaling = signaling;
+    this.pc = null;
+    this.resourceUrl = null;
+  }
+  async start(streamId, stream) {
+    const pc = new RTCPeerConnection(DEFAULT_RTC_CONFIG);
+    this.pc = pc;
+    for (const track of stream.getTracks()) {
+      pc.addTrack(track, stream);
+    }
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    await waitForIceGathering(pc);
+    const localSdp = pc.localDescription?.sdp;
+    if (!localSdp) throw mebiusError("CONNECTION_FAILED", "Failed to create a local session.");
+    const { answerSdp, resourceUrl } = await this.signaling.exchangeSdp(
+      "whip",
+      streamId,
+      localSdp
+    );
+    this.resourceUrl = resourceUrl;
+    await pc.setRemoteDescription({ type: "answer", sdp: answerSdp });
+  }
+  async replaceVideoTrack(track) {
+    const sender = this.pc?.getSenders().find((s) => s.track?.kind === "video");
+    if (sender) await sender.replaceTrack(track);
+  }
+  async stop() {
+    await this.signaling.deleteResource(this.resourceUrl);
+    this.resourceUrl = null;
+    this.pc?.getSenders().forEach((s) => s.track?.stop());
+    this.pc?.close();
+    this.pc = null;
+  }
+  async getStats() {
+    if (!this.pc) return null;
+    const report = await this.pc.getStats();
+    let bitrateKbps = 0;
+    let framesPerSecond = 0;
+    let rttMs;
+    report.forEach((stat) => {
+      if (stat.type === "outbound-rtp" && !stat.isRemote) {
+        if (typeof stat.framesPerSecond === "number") framesPerSecond = stat.framesPerSecond;
+      }
+      if (stat.type === "candidate-pair" && stat.state === "succeeded") {
+        if (typeof stat.availableOutgoingBitrate === "number") {
+          bitrateKbps = Math.round(stat.availableOutgoingBitrate / 1e3);
+        }
+        if (typeof stat.currentRoundTripTime === "number") {
+          rttMs = Math.round(stat.currentRoundTripTime * 1e3);
+        }
+      }
+    });
+    return { bitrateKbps, framesPerSecond, rttMs };
+  }
+};
+
+// src/internal/ll-view-transport.ts
+var WhepViewTransport = class {
+  constructor(signaling) {
+    this.signaling = signaling;
+    this.pc = null;
+    this.resourceUrl = null;
+    this.endedCb = null;
+    this.bufferingCb = null;
+  }
+  onEnded(cb) {
+    this.endedCb = cb;
+  }
+  onBuffering(cb) {
+    this.bufferingCb = cb;
+  }
+  async start(streamId, video) {
+    const pc = new RTCPeerConnection(DEFAULT_RTC_CONFIG);
+    this.pc = pc;
+    const remote = new MediaStream();
+    pc.addTransceiver("video", { direction: "recvonly" });
+    pc.addTransceiver("audio", { direction: "recvonly" });
+    pc.ontrack = (ev) => {
+      remote.addTrack(ev.track);
+      video.srcObject = remote;
+      void video.play().catch(() => {
+      });
+    };
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === "disconnected" || pc.connectionState === "failed") {
+        this.bufferingCb?.();
+      }
+      if (pc.connectionState === "closed") this.endedCb?.();
+    };
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    await waitForIceGathering(pc);
+    const localSdp = pc.localDescription?.sdp;
+    if (!localSdp) throw mebiusError("CONNECTION_FAILED", "Failed to create a local session.");
+    const { answerSdp, resourceUrl } = await this.signaling.exchangeSdp(
+      "whep",
+      streamId,
+      localSdp
+    );
+    this.resourceUrl = resourceUrl;
+    await pc.setRemoteDescription({ type: "answer", sdp: answerSdp });
+  }
+  async stop() {
+    await this.signaling.deleteResource(this.resourceUrl);
+    this.resourceUrl = null;
+    this.pc?.close();
+    this.pc = null;
+  }
+  async getStats() {
+    if (!this.pc) return null;
+    const report = await this.pc.getStats();
+    let bitrateKbps = 0;
+    let framesPerSecond = 0;
+    let latencyMs;
+    report.forEach((stat) => {
+      if (stat.type === "inbound-rtp") {
+        if (typeof stat.framesPerSecond === "number") framesPerSecond = stat.framesPerSecond;
+        if (typeof stat.jitter === "number") latencyMs = Math.round(stat.jitter * 1e3);
+      }
+      if (stat.type === "candidate-pair" && stat.state === "succeeded") {
+        if (typeof stat.availableIncomingBitrate === "number") {
+          bitrateKbps = Math.round(stat.availableIncomingBitrate / 1e3);
+        }
+      }
+    });
+    return { bitrateKbps, framesPerSecond, latencyMs };
+  }
+};
+
+// src/internal/balanced-view-transport.ts
+var FlvViewTransport = class {
+  constructor(signaling) {
+    this.signaling = signaling;
+    this.player = null;
+    this.video = null;
+    this.endedCb = null;
+    this.bufferingCb = null;
+  }
+  onEnded(cb) {
+    this.endedCb = cb;
+  }
+  onBuffering(cb) {
+    this.bufferingCb = cb;
+  }
+  async start(streamId, video) {
+    this.video = video;
+    const url = this.signaling.balancedStreamUrl(streamId);
+    video.addEventListener("ended", () => this.endedCb?.());
+    video.addEventListener("waiting", () => this.bufferingCb?.());
+    let mod;
+    try {
+      const spec = "flv.js";
+      mod = await import(
+        /* @vite-ignore */
+        spec
+      );
+    } catch (cause) {
+      throw mebiusError("CONNECTION_FAILED", "Balanced playback support failed to load.", cause);
+    }
+    const flvjs = mod.default;
+    if (!flvjs.isSupported()) {
+      throw mebiusError("CONNECTION_FAILED", "Balanced playback is not supported in this browser.");
+    }
+    const player = flvjs.createPlayer({ type: "flv", url, isLive: true });
+    this.player = player;
+    player.on(flvjs.Events.ERROR ?? "error", () => this.bufferingCb?.());
+    player.attachMediaElement(video);
+    player.load();
+    await Promise.resolve(player.play()).catch(() => void 0);
+  }
+  async stop() {
+    if (this.player) {
+      this.player.unload();
+      this.player.detachMediaElement();
+      this.player.destroy();
+      this.player = null;
+    }
+    if (this.video) {
+      this.video.removeAttribute("src");
+      this.video.load();
+    }
+    this.video = null;
+  }
+  async getStats() {
+    if (!this.video) return null;
+    return {
+      bitrateKbps: 0,
+      framesPerSecond: 0,
+      latencyMs: void 0
+    };
+  }
+};
+
+// src/internal/scale-view-transport.ts
+var HlsViewTransport = class {
+  constructor(signaling) {
+    this.signaling = signaling;
+    this.hls = null;
+    this.video = null;
+    this.endedCb = null;
+    this.bufferingCb = null;
+  }
+  onEnded(cb) {
+    this.endedCb = cb;
+  }
+  onBuffering(cb) {
+    this.bufferingCb = cb;
+  }
+  async start(streamId, video) {
+    this.video = video;
+    const url = this.signaling.scalePlaylistUrl(streamId);
+    video.addEventListener("ended", () => this.endedCb?.());
+    video.addEventListener("waiting", () => this.bufferingCb?.());
+    if (video.canPlayType("application/vnd.apple.mpegurl")) {
+      video.src = url;
+      await video.play().catch(() => void 0);
+      return;
+    }
+    let mod;
+    try {
+      mod = await import("hls.js");
+    } catch (cause) {
+      throw mebiusError("CONNECTION_FAILED", "Scale playback support failed to load.", cause);
+    }
+    const Hls = mod.default;
+    if (!Hls.isSupported()) {
+      throw mebiusError("CONNECTION_FAILED", "Scale playback is not supported in this browser.");
+    }
+    const hls = new Hls({ lowLatencyMode: true });
+    this.hls = hls;
+    hls.on(Hls.Events.ERROR, (_evt, data) => {
+      if (data.fatal) this.bufferingCb?.();
+    });
+    hls.loadSource(url);
+    hls.attachMedia(video);
+    await video.play().catch(() => void 0);
+  }
+  async stop() {
+    this.hls?.destroy();
+    this.hls = null;
+    if (this.video) {
+      this.video.removeAttribute("src");
+      this.video.load();
+    }
+    this.video = null;
+  }
+  async getStats() {
+    if (!this.video) return null;
+    const level = this.hls?.levels?.[this.hls.currentLevel];
+    return {
+      bitrateKbps: level ? Math.round(level.bitrate / 1e3) : 0,
+      framesPerSecond: 0
+    };
+  }
+};
+
+// src/internal/transport.ts
+function createPublishTransport(signaling) {
+  return new WhipPublishTransport(signaling);
+}
+function createViewTransport(mode, signaling) {
+  switch (mode) {
+    case "low-latency":
+      return new WhepViewTransport(signaling);
+    case "balanced":
+      return new FlvViewTransport(signaling);
+    case "scale":
+      return new HlsViewTransport(signaling);
+  }
+}
+
+// src/broadcaster.ts
+var STATS_INTERVAL_MS = 2e3;
+var MebiusBroadcaster = class extends TypedEmitter {
+  /** @internal */
+  constructor(signaling, options) {
+    super();
+    this.options = options;
+    this.stream = null;
+    this.facingMode = "user";
+    this.statsTimer = null;
+    this.started = false;
+    this.transport = createPublishTransport(signaling);
+  }
+  /** Begin broadcasting under the given stream id. */
+  async start(streamId) {
+    if (this.started) return;
+    this.stream = await this.capture();
+    await this.transport.start(streamId, this.stream);
+    this.started = true;
+    this.startStats();
+    this.emit("started", { streamId });
+  }
+  /** Stop broadcasting and release the camera/microphone. */
+  async stop() {
+    this.stopStats();
+    await this.transport.stop();
+    this.stream?.getTracks().forEach((t) => t.stop());
+    this.stream = null;
+    this.started = false;
+    this.emit("stopped", void 0);
+  }
+  /** Flip between front and back camera (where available). */
+  async switchCamera() {
+    if (!this.stream) return;
+    this.facingMode = this.facingMode === "user" ? "environment" : "user";
+    const next = await navigator.mediaDevices.getUserMedia({
+      video: { facingMode: this.facingMode },
+      audio: false
+    });
+    const newTrack = next.getVideoTracks()[0] ?? null;
+    const oldTrack = this.stream.getVideoTracks()[0];
+    if (oldTrack) {
+      this.stream.removeTrack(oldTrack);
+      oldTrack.stop();
+    }
+    if (newTrack) this.stream.addTrack(newTrack);
+    await this.transport.replaceVideoTrack(newTrack);
+  }
+  /** Mute or unmute the outgoing microphone. */
+  setMicEnabled(enabled) {
+    this.stream?.getAudioTracks().forEach((t) => t.enabled = enabled);
+  }
+  /** Enable or disable the outgoing camera. */
+  setCameraEnabled(enabled) {
+    this.stream?.getVideoTracks().forEach((t) => t.enabled = enabled);
+  }
+  /**
+   * Web convenience: render the local camera preview into a `<video>` element.
+   * This is the web analog of the mobile preview view; it does not affect what
+   * is broadcast.
+   */
+  attachPreview(target) {
+    if (!this.stream) return;
+    const video = resolveVideoElement(target);
+    video.srcObject = this.stream;
+    video.muted = true;
+    void video.play().catch(() => void 0);
+  }
+  async capture() {
+    const video = normalize(this.options.video, true);
+    const audio = normalize(this.options.audio, true);
+    try {
+      return await navigator.mediaDevices.getUserMedia({ video, audio });
+    } catch (cause) {
+      throw mebiusError("PERMISSION_DENIED", void 0, cause);
+    }
+  }
+  startStats() {
+    this.statsTimer = setInterval(async () => {
+      const stats = await this.transport.getStats();
+      if (stats) this.emit("stats", stats);
+    }, STATS_INTERVAL_MS);
+  }
+  stopStats() {
+    if (this.statsTimer) clearInterval(this.statsTimer);
+    this.statsTimer = null;
+  }
+};
+function normalize(c, fallback) {
+  if (c === void 0) return fallback;
+  return c;
+}
+
+// src/player.ts
+var STATS_INTERVAL_MS2 = 2e3;
+var MebiusPlayer = class extends TypedEmitter {
+  /** @internal */
+  constructor(signaling, options) {
+    super();
+    this.video = null;
+    this.statsTimer = null;
+    this.playing = false;
+    this.transport = createViewTransport(options.mode, signaling);
+    this.transport.onEnded(() => {
+      this.playing = false;
+      this.stopStats();
+      this.emit("ended", void 0);
+    });
+    this.transport.onBuffering(() => this.emit("buffering", void 0));
+  }
+  /** Start playing `streamId` into the given video element or selector. */
+  async play(streamId, viewTarget) {
+    if (this.playing) return;
+    this.video = resolveVideoElement(viewTarget);
+    await this.transport.start(streamId, this.video);
+    this.playing = true;
+    this.startStats();
+    this.emit("playing", { streamId });
+  }
+  /** Stop playback and detach from the video element. */
+  async stop() {
+    this.stopStats();
+    await this.transport.stop();
+    this.video = null;
+    this.playing = false;
+  }
+  /** Set output volume in the range 0..1. */
+  setVolume(volume) {
+    const v = Math.min(1, Math.max(0, volume));
+    if (this.video) this.video.volume = v;
+  }
+  startStats() {
+    this.statsTimer = setInterval(async () => {
+      const stats = await this.transport.getStats();
+      if (stats) this.emit("stats", stats);
+    }, STATS_INTERVAL_MS2);
+  }
+  stopStats() {
+    if (this.statsTimer) clearInterval(this.statsTimer);
+    this.statsTimer = null;
+  }
+};
+
+// src/internal/signaling.ts
+var SignalingClient = class {
+  constructor(gateway, token) {
+    this.gateway = gateway;
+    this.token = token;
+  }
+  base() {
+    return this.gateway.replace(/\/+$/, "");
+  }
+  headers(contentType) {
+    const h = { Authorization: `Bearer ${this.token}` };
+    if (contentType) h["Content-Type"] = contentType;
+    return h;
+  }
+  // Build the playlist URL used by scale-mode playback (HLS path, hidden).
+  /** Playlist URL for scale-mode playback. */
+  scalePlaylistUrl(streamId) {
+    return `${this.base()}/hls/${encodeURIComponent(streamId)}/index.m3u8`;
+  }
+  // Build the HTTP-FLV pull URL used by balanced-mode playback. Served by the
+  // CDN (CDN_PULL_FORMAT `.flv`) or an SRS/nginx-rtmp edge in front of the
+  // engine — MediaMTX itself does not vend HTTP-FLV. Hidden from the public API.
+  /** Pull URL for balanced-mode playback. */
+  balancedStreamUrl(streamId) {
+    return `${this.base()}/flv/${encodeURIComponent(streamId)}.flv`;
+  }
+  // Performs the SDP offer/answer exchange for a publish (WHIP) or low-latency
+  // view (WHEP) session. Protocol detail kept in line comments so it never
+  // leaks into the bundled public .d.ts.
+  /**
+   * Run the session offer/answer exchange. Throws a {@link MebiusError} with a
+   * Mebius-flavored code on failure — never the raw protocol name.
+   */
+  async exchangeSdp(kind, streamId, offerSdp) {
+    const url = `${this.base()}/${kind}/${encodeURIComponent(streamId)}`;
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: this.headers("application/sdp"),
+        body: offerSdp
+      });
+    } catch (cause) {
+      throw mebiusError("CONNECTION_FAILED", void 0, cause);
+    }
+    if (res.status === 401 || res.status === 403) {
+      throw mebiusError("TOKEN_EXPIRED");
+    }
+    if (res.status === 404) {
+      throw mebiusError("STREAM_NOT_FOUND");
+    }
+    if (!res.ok) {
+      throw mebiusError("CONNECTION_FAILED", `Mebius gateway returned ${res.status}.`);
+    }
+    const answerSdp = await res.text();
+    const location = res.headers.get("Location");
+    const resourceUrl = location ? new URL(location, url).toString() : null;
+    return { answerSdp, resourceUrl };
+  }
+  /** Tear down a previously-created session resource. Best-effort. */
+  async deleteResource(resourceUrl) {
+    if (!resourceUrl) return;
+    try {
+      await fetch(resourceUrl, { method: "DELETE", headers: this.headers() });
+    } catch {
+    }
+  }
+};
+
+// src/internal/token.ts
+function base64UrlDecode(input) {
+  const padded = input.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = padded.length % 4 === 0 ? "" : "=".repeat(4 - padded.length % 4);
+  const b64 = padded + pad;
+  if (typeof atob === "function") return atob(b64);
+  return Buffer.from(b64, "base64").toString("binary");
+}
+function readToken(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return { expiresAtMs: null };
+  try {
+    const payload = JSON.parse(base64UrlDecode(parts[1] ?? ""));
+    return { expiresAtMs: typeof payload.exp === "number" ? payload.exp * 1e3 : null };
+  } catch {
+    return { expiresAtMs: null };
+  }
+}
+
+// src/client.ts
+var MebiusClient = class extends TypedEmitter {
+  /** @internal */
+  constructor(config2, token) {
+    super();
+    this.token = token;
+    this.expiryTimer = null;
+    this.connected = false;
+    this.signaling = new SignalingClient(config2.gateway, token);
+  }
+  /** @internal Called by {@link Mebius.connect}. */
+  open() {
+    const { expiresAtMs } = readToken(this.token);
+    const now = Date.now();
+    if (expiresAtMs !== null && expiresAtMs <= now) {
+      queueMicrotask(() => this.emit("error", mebiusError("TOKEN_EXPIRED")));
+      return;
+    }
+    this.connected = true;
+    if (expiresAtMs !== null) {
+      this.expiryTimer = setTimeout(
+        () => this.emit("error", mebiusError("TOKEN_EXPIRED")),
+        Math.max(0, expiresAtMs - now)
+      );
+    }
+    queueMicrotask(() => this.emit("connected", void 0));
+  }
+  /** Create a broadcaster bound to this connection. */
+  createBroadcaster(options = {}) {
+    this.assertConnected();
+    return new MebiusBroadcaster(this.signaling, options);
+  }
+  /** Create a player bound to this connection. */
+  createPlayer(options) {
+    this.assertConnected();
+    return new MebiusPlayer(this.signaling, options);
+  }
+  /** Close the connection and release resources. */
+  disconnect(reason) {
+    if (this.expiryTimer) clearTimeout(this.expiryTimer);
+    this.expiryTimer = null;
+    this.connected = false;
+    this.emit("disconnected", { reason });
+    this.removeAllListeners();
+  }
+  assertConnected() {
+    if (!this.connected) throw mebiusError("NOT_CONNECTED");
+  }
+};
+
+// src/mebius.ts
+var config = null;
+var Mebius = {
+  /** Configure the SDK once, before connecting. */
+  init(options) {
+    if (!options.appId) throw mebiusError("UNKNOWN", "Mebius.init requires an appId.");
+    if (!options.gateway) throw mebiusError("UNKNOWN", "Mebius.init requires a gateway URL.");
+    config = { ...options };
+  },
+  /**
+   * Connect using a short-lived token minted by your backend. Returns a
+   * {@link MebiusClient}. Listen for `"connected"` / `"error"` on it.
+   */
+  connect(options) {
+    if (!config) {
+      throw mebiusError("UNKNOWN", "Call Mebius.init() before Mebius.connect().");
+    }
+    if (!options.token) throw mebiusError("UNKNOWN", "Mebius.connect requires a token.");
+    const client = new MebiusClient(config, options.token);
+    client.open();
+    return client;
+  },
+  /** @internal Reset configuration (used in tests). */
+  _reset() {
+    config = null;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Mebius,
+  MebiusBroadcaster,
+  MebiusClient,
+  MebiusError,
+  MebiusPlayer,
+  mebiusError
+});
+//# sourceMappingURL=index.cjs.map