sabha-meetings-react 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,4 +1,1468 @@
 'use strict';
 
+var socket_ioClient = require('socket.io-client');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/api/auth.ts
+function asUser(data) {
+  if (!data?.userId && !data.id) {
+    throw new Error("Auth response missing userId");
+  }
+  return {
+    ...data,
+    userId: data.userId || String(data.id)
+  };
+}
+function sessionFrom(data, cookie) {
+  return {
+    user: asUser(data),
+    accessToken: data.token,
+    refreshToken: data.refreshToken,
+    sessionCookie: cookie ?? void 0
+  };
+}
+var AuthApi = class {
+  constructor(http, getSessionCookie) {
+    this.http = http;
+    this.getSessionCookie = getSessionCookie;
+  }
+  async register(input) {
+    return this.http.request("/api/auth/register", {
+      method: "POST",
+      auth: false,
+      body: input
+    });
+  }
+  async verifyEmail(input) {
+    const data = await this.http.request("/api/auth/verify", {
+      method: "POST",
+      auth: false,
+      body: input
+    });
+    return sessionFrom(data, this.getSessionCookie());
+  }
+  async login(input) {
+    const data = await this.http.request("/api/auth/login", {
+      method: "POST",
+      auth: false,
+      body: input
+    });
+    return sessionFrom(data, this.getSessionCookie());
+  }
+  async refresh(refreshToken) {
+    const data = await this.http.request("/api/auth/refresh", {
+      method: "POST",
+      auth: false,
+      body: { refreshToken }
+    });
+    return {
+      accessToken: data.token,
+      refreshToken: data.refreshToken ?? refreshToken,
+      sessionCookie: this.getSessionCookie()
+    };
+  }
+  async me() {
+    const data = await this.http.request("/api/auth/me", { method: "GET" });
+    return asUser(data);
+  }
+  async logout(refreshToken) {
+    await this.http.request("/api/auth/logout", {
+      method: "POST",
+      body: refreshToken ? { refreshToken } : {}
+    });
+  }
+};
+
+// src/api/meetings.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function normalizeMeeting(raw) {
+  const record = asRecord(raw) ?? {};
+  const nested = asRecord(record.meeting) ?? record;
+  const id = nested.id || record.id;
+  if (!id || typeof id !== "string") {
+    throw new Error("Meeting response is missing an id");
+  }
+  return {
+    ...nested,
+    id,
+    title: typeof nested.title === "string" ? nested.title : "Untitled meeting",
+    notes: typeof nested.notes === "string" ? nested.notes : nested.notes ?? "",
+    code: typeof nested.code === "string" ? nested.code : void 0,
+    startAt: typeof nested.startAt === "string" ? nested.startAt : (/* @__PURE__ */ new Date()).toISOString(),
+    durationMin: typeof nested.durationMin === "number" ? nested.durationMin : 30,
+    timeZone: typeof nested.timeZone === "string" ? nested.timeZone : void 0,
+    groupId: typeof nested.groupId === "string" ? nested.groupId : "",
+    owner: Boolean(nested.owner),
+    canEdit: nested.canEdit !== false,
+    canCancel: nested.canCancel !== false,
+    organizer: nested.organizer,
+    invitees: Array.isArray(nested.invitees) ? nested.invitees : []
+  };
+}
+var MeetingsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const data = await this.http.request("/api/meetings", {
+      method: "GET"
+    });
+    return (data.meetings ?? []).map(normalizeMeeting);
+  }
+  async create(input) {
+    const body = {
+      title: input.title,
+      startAt: input.startAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      durationMin: input.durationMin ?? 30,
+      timeZone: input.timeZone ?? (typeof Intl !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC"),
+      inviteeIds: input.inviteeIds ?? [],
+      ...input.notes !== void 0 ? { notes: input.notes } : {},
+      ...input.groupId !== void 0 ? { groupId: input.groupId } : {}
+    };
+    const data = await this.http.request("/api/meetings", {
+      method: "POST",
+      body
+    });
+    return normalizeMeeting(data.meeting ?? data);
+  }
+  async update(meetingId, input) {
+    const data = await this.http.request(`/api/meetings/${meetingId}`, {
+      method: "PATCH",
+      body: input
+    });
+    return normalizeMeeting(data.meeting ?? data);
+  }
+  async cancel(meetingId) {
+    await this.http.request(`/api/meetings/${meetingId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/errors.ts
+var SabhaError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "SabhaError";
+    this.status = options?.status;
+    this.code = options?.code;
+    this.details = options?.details;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+function toSabhaError(error, fallback = "Sabha request failed") {
+  if (error instanceof SabhaError) return error;
+  if (error instanceof Error) {
+    return new SabhaError(error.message || fallback, { cause: error });
+  }
+  return new SabhaError(fallback, { details: error });
+}
+
+// src/http/client.ts
+function joinUrl(baseUrl, path) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  return `${base}${suffix}`;
+}
+function buildQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
+async function parseBody(response) {
+  if (response.status === 204) return null;
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function messageFromBody(body, fallback) {
+  if (!body || typeof body !== "object") return fallback;
+  const record = body;
+  if (typeof record.message === "string") return record.message;
+  if (typeof record.error === "string") return record.error;
+  return fallback;
+}
+function readSetCookie(response) {
+  const anyHeaders = response.headers;
+  const list = typeof anyHeaders.getSetCookie === "function" ? anyHeaders.getSetCookie() : (() => {
+    const single = response.headers.get("set-cookie");
+    return single ? [single] : [];
+  })();
+  for (const entry of list) {
+    const match = /(?:^|,\s*)vm_session=([^;]+)/i.exec(entry);
+    if (match?.[1]) return match[1];
+  }
+  return null;
+}
+var HttpClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async request(path, options = {}) {
+    const run = async (retried) => {
+      const headers = {
+        Accept: "application/json",
+        ...options.headers
+      };
+      const runtime = globalThis;
+      const isBrowser = typeof runtime.window !== "undefined" && typeof runtime.document !== "undefined";
+      const origin = this.options.getOrigin();
+      if (!isBrowser && origin) headers.Origin = origin;
+      const tokens = this.options.getTokens();
+      const needsAuth = options.auth !== false;
+      if (tokens?.accessToken) {
+        headers.Authorization = `Bearer ${tokens.accessToken}`;
+      } else if (needsAuth && !this.options.withCredentials && !tokens?.sessionCookie) {
+        throw new SabhaError(
+          "Not authenticated. Call login() or pass accessToken/sessionCookie.",
+          { code: "UNAUTHENTICATED" }
+        );
+      }
+      if (tokens?.sessionCookie) {
+        headers.Cookie = `vm_session=${tokens.sessionCookie}`;
+      }
+      if (options.body !== void 0) {
+        headers["Content-Type"] = "application/json";
+      }
+      const response = await fetch(
+        `${joinUrl(this.options.baseUrl, path)}${buildQuery(options.query)}`,
+        {
+          method: options.method ?? (options.body !== void 0 ? "POST" : "GET"),
+          headers,
+          body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+          credentials: this.options.withCredentials ? "include" : "same-origin"
+        }
+      );
+      const session = readSetCookie(response);
+      if (session) this.options.onSessionCookie?.(session);
+      const body = await parseBody(response);
+      if (response.status === 401 && needsAuth && !retried && this.options.onUnauthorized) {
+        const refreshed = await this.options.onUnauthorized();
+        if (refreshed) return run(true);
+      }
+      if (!response.ok) {
+        throw new SabhaError(messageFromBody(body, `HTTP ${response.status}`), {
+          status: response.status,
+          details: body
+        });
+      }
+      return body;
+    };
+    return run(false);
+  }
+};
+
+// src/media/MediaController.ts
+var MediaController = class {
+  constructor(policy) {
+    this.policy = policy;
+    this.micStream = null;
+    this.camStream = null;
+    this.screenStream = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.state = {
+      audioEnabled: false,
+      videoEnabled: false,
+      screenSharing: false,
+      screenOff: policy.screenOff
+    };
+  }
+  getMediaState() {
+    return { ...this.state };
+  }
+  getMicrophoneStream() {
+    return this.micStream;
+  }
+  getCameraStream() {
+    return this.camStream;
+  }
+  getScreenStream() {
+    return this.screenStream;
+  }
+  /** Combined local A/V tracks for attaching to a peer connection / video element. */
+  getLocalStream() {
+    const stream = new MediaStream();
+    this.micStream?.getAudioTracks().forEach((t) => stream.addTrack(t));
+    if (!this.state.screenOff) {
+      this.camStream?.getVideoTracks().forEach((t) => stream.addTrack(t));
+    }
+    return stream;
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  async start(policy) {
+    if (policy) this.policy = { ...this.policy, ...policy };
+    this.state.screenOff = this.policy.screenOff;
+    if (this.policy.audio) await this.setAudioEnabled(true);
+    if (this.policy.video && !this.policy.screenOff) await this.setVideoEnabled(true);
+    return this.getMediaState();
+  }
+  async setAudioEnabled(enabled) {
+    this.ensureMediaDevices();
+    if (!enabled) {
+      this.micStream?.getTracks().forEach((t) => {
+        t.enabled = false;
+        t.stop();
+      });
+      this.micStream = null;
+      return this.publish({ audioEnabled: false });
+    }
+    if (!this.micStream) {
+      this.micStream = await navigator.mediaDevices.getUserMedia({
+        audio: true,
+        video: false
+      });
+    } else {
+      this.micStream.getAudioTracks().forEach((t) => {
+        t.enabled = true;
+      });
+    }
+    return this.publish({ audioEnabled: true });
+  }
+  async setVideoEnabled(enabled) {
+    this.ensureMediaDevices();
+    if (!enabled) {
+      this.camStream?.getTracks().forEach((t) => {
+        t.enabled = false;
+        t.stop();
+      });
+      this.camStream = null;
+      return this.publish({ videoEnabled: false });
+    }
+    if (this.state.screenOff) {
+      throw new SabhaError("Camera is unavailable while screen is off", {
+        code: "SCREEN_OFF"
+      });
+    }
+    if (!this.camStream) {
+      this.camStream = await navigator.mediaDevices.getUserMedia({
+        audio: false,
+        video: { facingMode: "user" }
+      });
+    } else {
+      this.camStream.getVideoTracks().forEach((t) => {
+        t.enabled = true;
+      });
+    }
+    return this.publish({ videoEnabled: true });
+  }
+  async setScreenOff(off) {
+    if (off) {
+      await this.setVideoEnabled(false);
+      await this.stopScreenShare();
+      return this.publish({ screenOff: true, videoEnabled: false, screenSharing: false });
+    }
+    this.publish({ screenOff: false });
+    if (this.policy.video) await this.setVideoEnabled(true);
+    return this.getMediaState();
+  }
+  async startScreenShare() {
+    this.ensureMediaDevices();
+    if (!this.policy.allowScreenShare) {
+      throw new SabhaError("Screen sharing is disabled by media policy", {
+        code: "SCREEN_SHARE_BLOCKED"
+      });
+    }
+    if (this.state.screenOff) {
+      throw new SabhaError("Cannot share screen while screen is off", {
+        code: "SCREEN_OFF"
+      });
+    }
+    this.screenStream = await navigator.mediaDevices.getDisplayMedia({
+      video: true,
+      audio: false
+    });
+    const [track] = this.screenStream.getVideoTracks();
+    track?.addEventListener("ended", () => {
+      void this.stopScreenShare();
+    });
+    return this.publish({ screenSharing: true });
+  }
+  async stopScreenShare() {
+    this.screenStream?.getTracks().forEach((t) => t.stop());
+    this.screenStream = null;
+    return this.publish({ screenSharing: false });
+  }
+  async toggleAudio() {
+    return this.setAudioEnabled(!this.state.audioEnabled);
+  }
+  async toggleVideo() {
+    return this.setVideoEnabled(!this.state.videoEnabled);
+  }
+  stopAll() {
+    this.micStream?.getTracks().forEach((t) => t.stop());
+    this.camStream?.getTracks().forEach((t) => t.stop());
+    this.screenStream?.getTracks().forEach((t) => t.stop());
+    this.micStream = null;
+    this.camStream = null;
+    this.screenStream = null;
+    this.publish({
+      audioEnabled: false,
+      videoEnabled: false,
+      screenSharing: false
+    });
+  }
+  publish(patch) {
+    this.state = { ...this.state, ...patch };
+    const snapshot = this.getMediaState();
+    for (const listener of this.listeners) listener(snapshot);
+    return snapshot;
+  }
+  ensureMediaDevices() {
+    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+      throw new SabhaError("Media devices are not available in this environment", {
+        code: "MEDIA_UNAVAILABLE"
+      });
+    }
+  }
+};
+
+// src/security/ContentProtection.ts
+var ContentProtection = class {
+  constructor(policy) {
+    this.policy = policy;
+    this.enabled = false;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.cleanups = [];
+    this.styleEl = null;
+  }
+  onCaptureAttempt(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  setPolicy(policy) {
+    this.policy = policy;
+    if (this.enabled) {
+      this.disable();
+      this.enable();
+    }
+  }
+  enable() {
+    if (typeof document === "undefined" || this.enabled) return;
+    if (!this.policy.blockScreenshots && !this.policy.blockScreenRecording) return;
+    this.enabled = true;
+    this.injectStyles();
+    this.bindGuards();
+  }
+  disable() {
+    if (!this.enabled) return;
+    this.enabled = false;
+    for (const off of this.cleanups) off();
+    this.cleanups = [];
+    this.styleEl?.remove();
+    this.styleEl = null;
+    document.documentElement.classList.remove("sabha-content-protected");
+  }
+  injectStyles() {
+    const style = document.createElement("style");
+    style.setAttribute("data-sabha-content-protection", "true");
+    style.textContent = `
+      html.sabha-content-protected,
+      html.sabha-content-protected body {
+        -webkit-user-select: none !important;
+        user-select: none !important;
+      }
+      html.sabha-content-protected video,
+      html.sabha-content-protected canvas {
+        -webkit-user-select: none !important;
+        user-select: none !important;
+        pointer-events: auto;
+      }
+      html.sabha-content-protected.sabha-capture-obscured body::after {
+        content: "";
+        position: fixed;
+        inset: 0;
+        background: #000;
+        z-index: 2147483647;
+        pointer-events: none;
+      }
+    `;
+    document.head.appendChild(style);
+    document.documentElement.classList.add("sabha-content-protected");
+    this.styleEl = style;
+  }
+  bindGuards() {
+    const onContextMenu = (event) => {
+      if (!this.policy.blockScreenshots) return;
+      event.preventDefault();
+    };
+    const onKeyDown = (event) => {
+      if (!this.policy.blockScreenshots) return;
+      const key = event.key?.toLowerCase?.() ?? "";
+      const isPrintScreen = key === "printscreen";
+      const isMacShot = (event.metaKey || event.shiftKey) && (key === "3" || key === "4" || key === "5" || key === "6");
+      if (isPrintScreen || isMacShot) {
+        event.preventDefault();
+        this.obscureBriefly();
+        this.emit("screenshot");
+      }
+    };
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") {
+        if (this.policy.blockScreenRecording || this.policy.blockScreenshots) {
+          document.documentElement.classList.add("sabha-capture-obscured");
+          this.emit("visibility");
+        }
+      } else {
+        document.documentElement.classList.remove("sabha-capture-obscured");
+      }
+    };
+    const onBlur = () => {
+      if (this.policy.blockScreenshots) {
+        document.documentElement.classList.add("sabha-capture-obscured");
+        this.emit("screenshot");
+      }
+    };
+    const onFocus = () => {
+      document.documentElement.classList.remove("sabha-capture-obscured");
+    };
+    const originalGetDisplayMedia = navigator.mediaDevices?.getDisplayMedia?.bind(
+      navigator.mediaDevices
+    );
+    if (originalGetDisplayMedia && this.policy.blockScreenRecording) {
+      navigator.mediaDevices.getDisplayMedia = async (_constraints) => {
+        this.emit("recording");
+        this.obscureBriefly();
+        throw new DOMException(
+          "Screen recording is blocked by Sabha meeting policy",
+          "NotAllowedError"
+        );
+      };
+      this.cleanups.push(() => {
+        if (navigator.mediaDevices && originalGetDisplayMedia) {
+          navigator.mediaDevices.getDisplayMedia = originalGetDisplayMedia;
+        }
+      });
+    }
+    document.addEventListener("contextmenu", onContextMenu, true);
+    document.addEventListener("keydown", onKeyDown, true);
+    document.addEventListener("visibilitychange", onVisibility);
+    window.addEventListener("blur", onBlur);
+    window.addEventListener("focus", onFocus);
+    this.cleanups.push(
+      () => document.removeEventListener("contextmenu", onContextMenu, true),
+      () => document.removeEventListener("keydown", onKeyDown, true),
+      () => document.removeEventListener("visibilitychange", onVisibility),
+      () => window.removeEventListener("blur", onBlur),
+      () => window.removeEventListener("focus", onFocus),
+      () => document.documentElement.classList.remove("sabha-capture-obscured")
+    );
+  }
+  obscureBriefly() {
+    document.documentElement.classList.add("sabha-capture-obscured");
+    window.setTimeout(() => {
+      document.documentElement.classList.remove("sabha-capture-obscured");
+    }, 1500);
+  }
+  emit(type) {
+    const payload = { type, at: (/* @__PURE__ */ new Date()).toISOString() };
+    for (const listener of this.listeners) listener(payload);
+  }
+};
+
+// src/types.ts
+var DEFAULT_BASE_URL = "https://sabha-api.sthanave.com";
+var DEFAULT_MEDIA_POLICY = {
+  audio: true,
+  video: true,
+  allowScreenShare: true,
+  screenOff: false,
+  blockScreenshots: true,
+  blockScreenRecording: true
+};
+
+// src/realtime/MeetingConnection.ts
+var DEFAULT_EVENTS = {
+  join: "meeting:join",
+  leave: "meeting:leave",
+  participantJoined: "meeting:participant-joined",
+  participantLeft: "meeting:participant-left",
+  meetingEnded: "meeting:ended",
+  error: "meeting:error",
+  mediaState: "meeting:media-state"
+};
+var MeetingConnection = class {
+  constructor(options) {
+    this.options = options;
+    this.socket = null;
+    this.state = "disconnected";
+    this.listeners = /* @__PURE__ */ new Map();
+    this.mediaUnsub = null;
+    this.captureUnsub = null;
+    this.events = { ...DEFAULT_EVENTS, ...options.events };
+    this.mediaPolicy = { ...DEFAULT_MEDIA_POLICY, ...options.mediaPolicy };
+    this.media = new MediaController(this.mediaPolicy);
+    this.protection = new ContentProtection(this.mediaPolicy);
+  }
+  get meetingId() {
+    return this.options.meetingId;
+  }
+  get connectionState() {
+    return this.state;
+  }
+  getMediaState() {
+    return this.media.getMediaState();
+  }
+  on(event, listener) {
+    const set = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(event, set);
+    return () => {
+      set.delete(listener);
+    };
+  }
+  async connect() {
+    if (this.socket?.connected) {
+      await this.join();
+      return;
+    }
+    this.setState("connecting");
+    await new Promise((resolve, reject) => {
+      const auth = {};
+      if (this.options.accessToken) auth.token = this.options.accessToken;
+      if (this.options.sessionCookie) auth.session = this.options.sessionCookie;
+      const extraHeaders = {};
+      if (this.options.accessToken) {
+        extraHeaders.Authorization = `Bearer ${this.options.accessToken}`;
+      }
+      if (this.options.sessionCookie) {
+        extraHeaders.Cookie = `vm_session=${this.options.sessionCookie}`;
+      }
+      const socket = socket_ioClient.io(this.options.baseUrl, {
+        path: this.options.socketPath,
+        transports: ["websocket", "polling"],
+        withCredentials: this.options.withCredentials !== false,
+        auth,
+        extraHeaders,
+        autoConnect: true
+      });
+      this.socket = socket;
+      const onConnect = () => {
+        cleanup();
+        this.setState("connected");
+        this.bindServerEvents(socket);
+        this.join().then(async () => {
+          this.protection.enable();
+          this.mediaUnsub = this.media.onChange((mediaState) => {
+            this.emit("mediaState", mediaState);
+            socket.emit(this.events.mediaState, {
+              meetingId: this.options.meetingId,
+              ...mediaState
+            });
+          });
+          this.captureUnsub = this.protection.onCaptureAttempt((event) => {
+            this.emit("captureAttempt", event);
+          });
+          await this.media.start(this.mediaPolicy);
+          resolve();
+        }).catch(reject);
+      };
+      const onError = (error) => {
+        cleanup();
+        this.setState("error");
+        this.emit("error", error);
+        reject(
+          new SabhaError(error.message || "Failed to connect to Sabha meetings", {
+            code: "SOCKET_CONNECT_FAILED",
+            cause: error
+          })
+        );
+      };
+      const cleanup = () => {
+        socket.off("connect", onConnect);
+        socket.off("connect_error", onError);
+      };
+      socket.on("connect", onConnect);
+      socket.on("connect_error", onError);
+    });
+  }
+  async setAudioEnabled(enabled) {
+    return this.media.setAudioEnabled(enabled);
+  }
+  async setVideoEnabled(enabled) {
+    return this.media.setVideoEnabled(enabled);
+  }
+  async setScreenOff(off) {
+    return this.media.setScreenOff(off);
+  }
+  async startScreenShare() {
+    return this.media.startScreenShare();
+  }
+  async stopScreenShare() {
+    return this.media.stopScreenShare();
+  }
+  async leave() {
+    const socket = this.socket;
+    this.teardownMedia();
+    if (!socket) return;
+    await new Promise((resolve) => {
+      socket.timeout(5e3).emit(
+        this.events.leave,
+        { meetingId: this.options.meetingId },
+        () => resolve()
+      );
+      setTimeout(() => resolve(), 500);
+    });
+    socket.disconnect();
+    this.socket = null;
+    this.setState("disconnected");
+  }
+  disconnect() {
+    this.teardownMedia();
+    this.socket?.disconnect();
+    this.socket = null;
+    this.setState("disconnected");
+  }
+  emitRaw(event, payload) {
+    if (!this.socket?.connected) {
+      throw new SabhaError("Meeting socket is not connected", {
+        code: "SOCKET_NOT_CONNECTED"
+      });
+    }
+    this.socket.emit(event, payload);
+  }
+  teardownMedia() {
+    this.mediaUnsub?.();
+    this.captureUnsub?.();
+    this.mediaUnsub = null;
+    this.captureUnsub = null;
+    this.media.stopAll();
+    this.protection.disable();
+  }
+  async join() {
+    const socket = this.socket;
+    if (!socket?.connected) {
+      throw new SabhaError("Meeting socket is not connected", {
+        code: "SOCKET_NOT_CONNECTED"
+      });
+    }
+    await new Promise((resolve) => {
+      let settled = false;
+      const done = () => {
+        if (settled) return;
+        settled = true;
+        this.setState("joined");
+        resolve();
+      };
+      socket.timeout(5e3).emit(
+        this.events.join,
+        { meetingId: this.options.meetingId },
+        () => done()
+      );
+      setTimeout(done, 600);
+    });
+  }
+  bindServerEvents(socket) {
+    socket.on(this.events.participantJoined, (payload) => {
+      this.emit("participantJoined", payload);
+      this.emit("raw", { event: this.events.participantJoined, payload });
+    });
+    socket.on(this.events.participantLeft, (payload) => {
+      this.emit("participantLeft", payload);
+      this.emit("raw", { event: this.events.participantLeft, payload });
+    });
+    socket.on(
+      this.events.meetingEnded,
+      (payload) => {
+        this.emit("meetingEnded", {
+          meetingId: payload.meetingId ?? this.options.meetingId,
+          reason: payload.reason
+        });
+        this.emit("raw", { event: this.events.meetingEnded, payload });
+        this.setState("disconnected");
+      }
+    );
+    socket.on(this.events.error, (payload) => {
+      const message = payload && typeof payload === "object" && "message" in payload ? String(payload.message) : "Meeting socket error";
+      const error = new SabhaError(message, {
+        details: payload,
+        code: "MEETING_SOCKET_ERROR"
+      });
+      this.emit("error", error);
+      this.emit("raw", { event: this.events.error, payload });
+    });
+    socket.on("disconnect", () => {
+      this.setState("disconnected");
+    });
+  }
+  setState(state) {
+    this.state = state;
+    this.emit("state", state);
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const listener of set) listener(payload);
+  }
+};
+
+// src/SabhaClient.ts
+var SabhaClient = class {
+  constructor() {
+    this.config = { baseUrl: DEFAULT_BASE_URL };
+    this.tokens = null;
+    this.user = null;
+    this.http = null;
+    this.authApi = null;
+    this.meetingsApi = null;
+    this.activeConnection = null;
+    this.refreshPromise = null;
+    this.mediaPolicy = { ...DEFAULT_MEDIA_POLICY };
+  }
+  configure(config = {}) {
+    const baseUrl = (config.baseUrl ?? this.config.baseUrl ?? DEFAULT_BASE_URL).replace(
+      /\/+$/,
+      ""
+    );
+    this.config = {
+      withCredentials: true,
+      ...this.config,
+      ...config,
+      baseUrl
+    };
+    this.mediaPolicy = {
+      ...DEFAULT_MEDIA_POLICY,
+      ...this.config.mediaPolicy
+    };
+    this.tokens = {
+      accessToken: config.accessToken ?? this.tokens?.accessToken,
+      refreshToken: config.refreshToken ?? this.tokens?.refreshToken,
+      sessionCookie: config.sessionCookie ?? this.tokens?.sessionCookie
+    };
+    if (!this.tokens.accessToken && !this.tokens.sessionCookie && !this.tokens.refreshToken) {
+      if (!config.accessToken && !config.sessionCookie && !config.refreshToken) ;
+    }
+    const hasAnyToken = Boolean(
+      this.tokens.accessToken || this.tokens.sessionCookie || this.tokens.refreshToken
+    );
+    if (!hasAnyToken) this.tokens = null;
+    this.http = new HttpClient({
+      baseUrl,
+      withCredentials: this.config.withCredentials !== false,
+      getOrigin: () => this.getOrigin(),
+      getTokens: () => this.tokens,
+      setTokens: (tokens) => {
+        this.tokens = tokens;
+      },
+      onSessionCookie: (cookie) => {
+        this.tokens = {
+          ...this.tokens ?? {},
+          sessionCookie: cookie ?? void 0
+        };
+      },
+      onUnauthorized: () => this.tryRefresh()
+    });
+    this.authApi = new AuthApi(this.http, () => this.tokens?.sessionCookie);
+    this.meetingsApi = new MeetingsApi(this.http);
+    return this;
+  }
+  getStatus() {
+    const configured = Boolean(this.http && this.config.baseUrl);
+    const authenticated = Boolean(
+      this.tokens?.accessToken || this.tokens?.sessionCookie || this.config.withCredentials !== false && this.user
+    );
+    return {
+      configured,
+      authenticated: authenticated || Boolean(this.user),
+      baseUrl: this.config.baseUrl ?? DEFAULT_BASE_URL
+    };
+  }
+  getAccessToken() {
+    return this.tokens?.accessToken ?? null;
+  }
+  getSessionCookie() {
+    return this.tokens?.sessionCookie ?? null;
+  }
+  getUser() {
+    return this.user;
+  }
+  getMediaPolicy() {
+    return { ...this.mediaPolicy };
+  }
+  setMediaPolicy(policy) {
+    this.mediaPolicy = { ...this.mediaPolicy, ...policy };
+    this.config.mediaPolicy = this.mediaPolicy;
+  }
+  setTokens(tokens) {
+    this.ensureConfigured();
+    this.tokens = tokens;
+  }
+  clearSession() {
+    this.tokens = null;
+    this.user = null;
+    this.activeConnection?.disconnect();
+    this.activeConnection = null;
+  }
+  async login(input) {
+    const session = await this.auth().login(input);
+    this.applySession(session);
+    try {
+      const me = await this.auth().me();
+      this.user = me;
+      session.user = me;
+    } catch (error) {
+      this.clearSession();
+      throw new SabhaError(
+        "Login returned a user profile but no Sabha session was established. The API did not set `vm_session` (and no JWT token was returned), so POST /api/meetings will return 401 Sign in first. Fix session cookies on sabha-api (Set-Cookie: vm_session; SameSite=None; Secure for cross-origin) or return a bearer token from /api/auth/login.",
+        {
+          code: "SESSION_NOT_ESTABLISHED",
+          status: 401,
+          cause: error
+        }
+      );
+    }
+    return session;
+  }
+  /** Throws if /api/auth/me fails — call before create/start meeting. */
+  async ensureAuthenticated() {
+    try {
+      return await this.me();
+    } catch (error) {
+      throw new SabhaError(
+        "Not signed in to Sabha. Call login() first, and ensure the `vm_session` cookie is sent (credentials: 'include', CORS allow-credentials, allow-listed Origin).",
+        {
+          code: "UNAUTHENTICATED",
+          status: 401,
+          cause: error
+        }
+      );
+    }
+  }
+  async register(input) {
+    return this.auth().register(input);
+  }
+  async verifyEmail(input) {
+    const session = await this.auth().verifyEmail(input);
+    this.applySession(session);
+    return session;
+  }
+  async refreshSession() {
+    const refreshToken = this.tokens?.refreshToken;
+    if (!refreshToken) {
+      throw new SabhaError("No refresh token available", { code: "NO_REFRESH_TOKEN" });
+    }
+    const tokens = await this.auth().refresh(refreshToken);
+    this.tokens = { ...this.tokens ?? {}, ...tokens };
+    return tokens;
+  }
+  async me() {
+    const user = await this.auth().me();
+    this.user = user;
+    return user;
+  }
+  async logout() {
+    try {
+      if (this.user || this.tokens) {
+        await this.auth().logout(this.tokens?.refreshToken);
+      }
+    } finally {
+      this.clearSession();
+    }
+  }
+  async listMeetings() {
+    return this.meetings().list();
+  }
+  async createMeeting(input) {
+    await this.ensureAuthenticated();
+    return this.meetings().create(input);
+  }
+  async updateMeeting(meetingId, input) {
+    return this.meetings().update(meetingId, input);
+  }
+  async cancelMeeting(meetingId) {
+    await this.meetings().cancel(meetingId);
+    if (this.activeConnection?.meetingId === meetingId) {
+      this.activeConnection.disconnect();
+      this.activeConnection = null;
+    }
+  }
+  async startMeeting(input) {
+    await this.ensureAuthenticated();
+    let meeting;
+    if (input?.meetingId) {
+      const existing = (await this.listMeetings()).find((m) => m.id === input.meetingId);
+      meeting = existing ?? {
+        id: input.meetingId,
+        title: input.title ?? "Meeting",
+        startAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMin: input.durationMin ?? 30
+      };
+    } else {
+      meeting = await this.meetings().create({
+        title: input?.title ?? "Sabha Meeting",
+        startAt: input?.startAt,
+        durationMin: input?.durationMin,
+        timeZone: input?.timeZone,
+        inviteeIds: input?.inviteeIds,
+        notes: input?.notes,
+        groupId: input?.groupId
+      });
+    }
+    const connection = await this.connect(meeting.id);
+    return { meeting, connection };
+  }
+  async connect(meetingId) {
+    this.ensureConfigured();
+    if (this.activeConnection) {
+      this.activeConnection.disconnect();
+      this.activeConnection = null;
+    }
+    const connection = new MeetingConnection({
+      baseUrl: this.config.baseUrl ?? DEFAULT_BASE_URL,
+      meetingId,
+      accessToken: this.tokens?.accessToken,
+      sessionCookie: this.tokens?.sessionCookie,
+      withCredentials: this.config.withCredentials !== false,
+      socketPath: this.config.socketPath,
+      events: this.config.socketEvents,
+      mediaPolicy: this.mediaPolicy
+    });
+    try {
+      await connection.connect();
+      this.activeConnection = connection;
+      return connection;
+    } catch (error) {
+      connection.disconnect();
+      throw toSabhaError(error, "Failed to connect to Sabha meeting");
+    }
+  }
+  getConnection() {
+    return this.activeConnection;
+  }
+  async leaveMeeting() {
+    if (!this.activeConnection) return;
+    await this.activeConnection.leave();
+    this.activeConnection = null;
+  }
+  applySession(session) {
+    this.user = session.user;
+    this.tokens = {
+      accessToken: session.accessToken ?? this.tokens?.accessToken,
+      refreshToken: session.refreshToken ?? this.tokens?.refreshToken,
+      sessionCookie: session.sessionCookie ?? this.tokens?.sessionCookie
+    };
+  }
+  async tryRefresh() {
+    if (!this.tokens?.refreshToken) return false;
+    if (this.refreshPromise) return this.refreshPromise;
+    this.refreshPromise = (async () => {
+      try {
+        await this.refreshSession();
+        return true;
+      } catch {
+        return false;
+      } finally {
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  getOrigin() {
+    if (this.config.origin) return this.config.origin;
+    const win = globalThis.window;
+    if (win?.location?.origin) return win.location.origin;
+    return void 0;
+  }
+  ensureConfigured() {
+    if (!this.http || !this.authApi || !this.meetingsApi) {
+      this.configure(this.config);
+    }
+    if (!this.http || !this.authApi || !this.meetingsApi) {
+      throw new SabhaError("Sabha client failed to configure", {
+        code: "NOT_CONFIGURED"
+      });
+    }
+  }
+  auth() {
+    this.ensureConfigured();
+    return this.authApi;
+  }
+  meetings() {
+    this.ensureConfigured();
+    return this.meetingsApi;
+  }
+};
+function createSabhaClient(config) {
+  const client = new SabhaClient();
+  client.configure(config ?? { baseUrl: DEFAULT_BASE_URL });
+  return client;
+}
+var SabhaContext = react.createContext(null);
+var idleMedia = {
+  audioEnabled: false,
+  videoEnabled: false,
+  screenSharing: false,
+  screenOff: false
+};
+function SabhaProvider({
+  children,
+  client: clientProp,
+  autoLoadMeetings = true,
+  ...config
+}) {
+  const resolvedConfig = {
+    baseUrl: DEFAULT_BASE_URL,
+    withCredentials: true,
+    ...config
+  };
+  const client = react.useMemo(
+    () => clientProp ?? createSabhaClient(resolvedConfig),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      clientProp,
+      resolvedConfig.baseUrl,
+      resolvedConfig.accessToken,
+      resolvedConfig.sessionCookie,
+      resolvedConfig.origin
+    ]
+  );
+  const [ready, setReady] = react.useState(false);
+  const [authenticated, setAuthenticated] = react.useState(false);
+  const [user, setUser] = react.useState(null);
+  const [meetings, setMeetings] = react.useState([]);
+  const [meetingsLoading, setMeetingsLoading] = react.useState(false);
+  const [connection, setConnection] = react.useState(null);
+  const [connectionState, setConnectionState] = react.useState("disconnected");
+  const [mediaState, setMediaState] = react.useState(idleMedia);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    client.configure(resolvedConfig);
+    setAuthenticated(client.getStatus().authenticated);
+    setUser(client.getUser());
+    setReady(true);
+  }, [
+    client,
+    resolvedConfig.baseUrl,
+    resolvedConfig.accessToken,
+    resolvedConfig.sessionCookie,
+    resolvedConfig.origin,
+    resolvedConfig.withCredentials
+  ]);
+  react.useEffect(() => {
+    if (!connection) {
+      setConnectionState("disconnected");
+      setMediaState(idleMedia);
+      return;
+    }
+    setConnectionState(connection.connectionState);
+    setMediaState(connection.getMediaState());
+    const offState = connection.on("state", setConnectionState);
+    const offMedia = connection.on("mediaState", setMediaState);
+    return () => {
+      offState();
+      offMedia();
+    };
+  }, [connection]);
+  const refreshMeetings = react.useCallback(async () => {
+    setMeetingsLoading(true);
+    setError(null);
+    try {
+      const list = await client.listMeetings();
+      setMeetings(list);
+      setAuthenticated(true);
+      return list;
+    } catch (err) {
+      const next = err instanceof Error ? err : new Error("Failed to load meetings");
+      setError(next);
+      throw next;
+    } finally {
+      setMeetingsLoading(false);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    if (!ready || !autoLoadMeetings) return;
+    void client.me().then((me) => {
+      setUser(me);
+      setAuthenticated(true);
+      return refreshMeetings();
+    }).catch(() => {
+    });
+  }, [ready, autoLoadMeetings, client, refreshMeetings]);
+  const createMeeting = react.useCallback(
+    async (input) => {
+      setError(null);
+      try {
+        const meeting = await client.createMeeting(input);
+        setMeetings((prev) => [meeting, ...prev.filter((m) => m.id !== meeting.id)]);
+        return meeting;
+      } catch (err) {
+        const next = err instanceof Error ? err : new Error("Failed to create meeting");
+        setError(next);
+        throw next;
+      }
+    },
+    [client]
+  );
+  const updateMeeting = react.useCallback(
+    async (meetingId, input) => {
+      setError(null);
+      try {
+        const meeting = await client.updateMeeting(meetingId, input);
+        setMeetings((prev) => prev.map((m) => m.id === meeting.id ? meeting : m));
+        return meeting;
+      } catch (err) {
+        const next = err instanceof Error ? err : new Error("Failed to update meeting");
+        setError(next);
+        throw next;
+      }
+    },
+    [client]
+  );
+  const cancelMeeting = react.useCallback(
+    async (meetingId) => {
+      setError(null);
+      try {
+        await client.cancelMeeting(meetingId);
+        setMeetings((prev) => prev.filter((m) => m.id !== meetingId));
+        if (connection?.meetingId === meetingId) {
+          setConnection(null);
+        }
+      } catch (err) {
+        const next = err instanceof Error ? err : new Error("Failed to cancel meeting");
+        setError(next);
+        throw next;
+      }
+    },
+    [client, connection]
+  );
+  const connect = react.useCallback(
+    async (meetingId) => {
+      setError(null);
+      try {
+        const next = await client.connect(meetingId);
+        setConnection(next);
+        return next;
+      } catch (err) {
+        const nextErr = err instanceof Error ? err : new Error("Failed to connect");
+        setError(nextErr);
+        throw nextErr;
+      }
+    },
+    [client]
+  );
+  const startMeeting = react.useCallback(
+    async (input) => {
+      setError(null);
+      try {
+        const result = await client.startMeeting(input);
+        setMeetings((prev) => [
+          result.meeting,
+          ...prev.filter((m) => m.id !== result.meeting.id)
+        ]);
+        setConnection(result.connection);
+        return result;
+      } catch (err) {
+        const next = err instanceof Error ? err : new Error("Failed to start meeting");
+        setError(next);
+        throw next;
+      }
+    },
+    [client]
+  );
+  const leaveMeeting = react.useCallback(async () => {
+    setError(null);
+    try {
+      await client.leaveMeeting();
+    } finally {
+      setConnection(null);
+      setConnectionState("disconnected");
+      setMediaState(idleMedia);
+    }
+  }, [client]);
+  const login = react.useCallback(
+    async (input) => {
+      setError(null);
+      try {
+        const session = await client.login(input);
+        setAuthenticated(true);
+        setUser(session.user);
+        if (autoLoadMeetings) await refreshMeetings().catch(() => void 0);
+        return session;
+      } catch (err) {
+        const next = err instanceof Error ? err : new Error("Login failed");
+        setError(next);
+        throw next;
+      }
+    },
+    [autoLoadMeetings, client, refreshMeetings]
+  );
+  const logout = react.useCallback(async () => {
+    setError(null);
+    try {
+      await client.logout();
+    } finally {
+      setAuthenticated(false);
+      setUser(null);
+      setMeetings([]);
+      setConnection(null);
+      setConnectionState("disconnected");
+      setMediaState(idleMedia);
+    }
+  }, [client]);
+  const setAudioEnabled = react.useCallback(
+    async (enabled) => {
+      if (!connection) throw new Error("Not connected to a meeting");
+      return connection.setAudioEnabled(enabled);
+    },
+    [connection]
+  );
+  const setVideoEnabled = react.useCallback(
+    async (enabled) => {
+      if (!connection) throw new Error("Not connected to a meeting");
+      return connection.setVideoEnabled(enabled);
+    },
+    [connection]
+  );
+  const setScreenOff = react.useCallback(
+    async (off) => {
+      if (!connection) throw new Error("Not connected to a meeting");
+      return connection.setScreenOff(off);
+    },
+    [connection]
+  );
+  const startScreenShare = react.useCallback(async () => {
+    if (!connection) throw new Error("Not connected to a meeting");
+    return connection.startScreenShare();
+  }, [connection]);
+  const stopScreenShare = react.useCallback(async () => {
+    if (!connection) throw new Error("Not connected to a meeting");
+    return connection.stopScreenShare();
+  }, [connection]);
+  const value = react.useMemo(
+    () => ({
+      client,
+      ready,
+      authenticated,
+      user,
+      meetings,
+      meetingsLoading,
+      connection,
+      connectionState,
+      mediaState,
+      error,
+      refreshMeetings,
+      createMeeting,
+      updateMeeting,
+      cancelMeeting,
+      startMeeting,
+      connect,
+      leaveMeeting,
+      login,
+      logout,
+      setAudioEnabled,
+      setVideoEnabled,
+      setScreenOff,
+      startScreenShare,
+      stopScreenShare,
+      clearError: () => setError(null)
+    }),
+    [
+      client,
+      ready,
+      authenticated,
+      user,
+      meetings,
+      meetingsLoading,
+      connection,
+      connectionState,
+      mediaState,
+      error,
+      refreshMeetings,
+      createMeeting,
+      updateMeeting,
+      cancelMeeting,
+      startMeeting,
+      connect,
+      leaveMeeting,
+      login,
+      logout,
+      setAudioEnabled,
+      setVideoEnabled,
+      setScreenOff,
+      startScreenShare,
+      stopScreenShare
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(SabhaContext.Provider, { value, children });
+}
+function useSabha() {
+  const ctx = react.useContext(SabhaContext);
+  if (!ctx) {
+    throw new Error("useSabha must be used within <SabhaProvider>");
+  }
+  return ctx;
+}
+function useSabhaMeetings() {
+  const {
+    meetings,
+    meetingsLoading,
+    refreshMeetings,
+    createMeeting,
+    updateMeeting,
+    cancelMeeting,
+    startMeeting,
+    connect,
+    leaveMeeting,
+    connection,
+    connectionState,
+    mediaState,
+    setAudioEnabled,
+    setVideoEnabled,
+    setScreenOff,
+    startScreenShare,
+    stopScreenShare,
+    error
+  } = useSabha();
+  return {
+    meetings,
+    meetingsLoading,
+    refreshMeetings,
+    createMeeting,
+    updateMeeting,
+    cancelMeeting,
+    startMeeting,
+    connect,
+    leaveMeeting,
+    connection,
+    connectionState,
+    mediaState,
+    setAudioEnabled,
+    setVideoEnabled,
+    setScreenOff,
+    startScreenShare,
+    stopScreenShare,
+    error
+  };
+}
+
+exports.ContentProtection = ContentProtection;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_MEDIA_POLICY = DEFAULT_MEDIA_POLICY;
+exports.MediaController = MediaController;
+exports.MeetingConnection = MeetingConnection;
+exports.SabhaClient = SabhaClient;
+exports.SabhaError = SabhaError;
+exports.SabhaProvider = SabhaProvider;
+exports.createSabhaClient = createSabhaClient;
+exports.normalizeMeeting = normalizeMeeting;
+exports.toSabhaError = toSabhaError;
+exports.useSabha = useSabha;
+exports.useSabhaMeetings = useSabhaMeetings;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map