@broadcastingplatforms/sdk 0.0.0-dev.52fbff9

package/dist/browser-client.js

@@ -0,0 +1,1983 @@
+"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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/browser-client.ts
+var browser_client_exports = {};
+__export(browser_client_exports, {
+  BrowserClient: () => BrowserClient,
+  createBrowserClient: () => createBrowserClient,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(browser_client_exports);
+
+// src/auth.ts
+var import_jwt_decode = require("jwt-decode");
+
+// src/errors.ts
+var SDKError = class extends Error {
+  /**
+   * Construct an SDKError. Signature is compatible with Error.
+   * You can pass in a message or an options object, as with the Error constructor.
+   * Additional fields (code, etc) may be added via the second argument.
+   */
+  constructor(message, details = {}) {
+    const resolvedMessage = message ?? (typeof details.message === "string" ? details.message : "Unknown error");
+    super(resolvedMessage);
+    /**
+     * Canonical SDK error code.
+     */
+    __publicField(this, "code");
+    /**
+     * HTTP status code if available.
+     */
+    __publicField(this, "statusCode");
+    /**
+     * End-user safe message.
+     */
+    __publicField(this, "userMessage");
+    /**
+     * Optional request metadata (null when unavailable).
+     */
+    __publicField(this, "request");
+    /**
+     * Optional response metadata (null when unavailable).
+     */
+    __publicField(this, "response");
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (details && typeof details === "object") {
+      for (const [key, value] of Object.entries(details)) {
+        if (!["name", "message", "stack"].includes(key)) {
+          this[key] = value;
+        }
+      }
+    }
+    this.name = "SDKError";
+    this.code = details.code ?? "unknown_error";
+    this.statusCode = typeof details.statusCode === "number" ? details.statusCode : void 0;
+    this.userMessage = typeof details.userMessage === "string" ? details.userMessage : this.message;
+    this.request = details.request ?? null;
+    this.response = details.response ?? null;
+  }
+  /**
+   * Serialize the error into a plain object, preserving extra fields.
+   */
+  toJSON() {
+    const extras = { ...this };
+    delete extras.code;
+    delete extras.statusCode;
+    delete extras.message;
+    delete extras.userMessage;
+    delete extras.request;
+    delete extras.response;
+    delete extras.form;
+    delete extras.cause;
+    return {
+      ...extras,
+      code: this.code,
+      statusCode: this.statusCode,
+      message: this.message,
+      userMessage: this.userMessage,
+      request: this.request,
+      response: this.response
+    };
+  }
+};
+var STATUS_CODE_DEFAULTS = {
+  401: {
+    code: "authentication_required",
+    message: "Authentication required",
+    userMessage: "Please log in to continue. Your session may have expired."
+  },
+  403: {
+    code: "permission_denied",
+    message: "Permission denied",
+    userMessage: "You do not have permission to perform this action."
+  },
+  404: {
+    code: "not_found",
+    message: "Resource not found",
+    userMessage: "The requested resource was not found."
+  },
+  422: {
+    code: "validation_failed",
+    message: "Validation failed",
+    userMessage: "The provided information is invalid. Please check your input and try again."
+  },
+  429: {
+    code: "rate_limited",
+    message: "Rate limit exceeded",
+    userMessage: "Too many requests. Please wait a moment and try again."
+  },
+  500: {
+    code: "server_error",
+    message: "Internal server error",
+    userMessage: "Something went wrong on our end. Please try again later."
+  }
+};
+var DEFAULT_ERROR = {
+  code: "unknown_error",
+  userMessage: "An unexpected error occurred. Please try again."
+};
+function createSdkError(message, details = {}) {
+  const statusCode = details.response?.status;
+  const statusValues = statusCode && STATUS_CODE_DEFAULTS[statusCode] ? STATUS_CODE_DEFAULTS[statusCode] : DEFAULT_ERROR;
+  const enrichedDetails = {
+    ...details,
+    statusCode,
+    code: details.code ?? statusValues.code,
+    userMessage: details.userMessage ?? statusValues.userMessage,
+    request: details.request ?? null,
+    response: details.response ?? null
+  };
+  return new SDKError(message, enrichedDetails);
+}
+
+// src/storage.ts
+var DEFAULT_AUTH_COOKIE_NAME = "auth_token";
+var DEFAULT_COOKIE_OPTIONS = {
+  path: "/",
+  sameSite: "lax"
+};
+var isBrowser = () => typeof document !== "undefined";
+var resolveCookieName = (prefix, key) => prefix ? `${prefix}${key}` : key;
+var resolveCookieValue = (value) => {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "object" && typeof value.value === "string") {
+    return value.value;
+  }
+  return null;
+};
+var decodeCookieValue = (value) => decodeURIComponent(value.replace(/\+/g, " "));
+var encodeCookieValue = (value) => encodeURIComponent(value);
+var readCookie = (name) => {
+  if (!isBrowser()) {
+    return null;
+  }
+  const entries = document.cookie ? document.cookie.split("; ") : [];
+  for (const entry of entries) {
+    const [rawKey, ...rest] = entry.split("=");
+    if (rawKey && decodeCookieValue(rawKey) === name) {
+      return decodeCookieValue(rest.join("="));
+    }
+  }
+  return null;
+};
+var writeCookie = (name, value, options) => {
+  if (!isBrowser()) {
+    return;
+  }
+  const parts = [`${encodeCookieValue(name)}=${encodeCookieValue(value)}`];
+  if (options.path) {
+    parts.push(`Path=${options.path}`);
+  }
+  if (options.domain) {
+    parts.push(`Domain=${options.domain}`);
+  }
+  if (options.sameSite) {
+    parts.push(`SameSite=${options.sameSite}`);
+  }
+  if (options.secure) {
+    parts.push("Secure");
+  }
+  if (options.expires instanceof Date) {
+    parts.push(`Expires=${options.expires.toUTCString()}`);
+  } else if (typeof options.expires === "number") {
+    const expires = /* @__PURE__ */ new Date();
+    expires.setDate(expires.getDate() + options.expires);
+    parts.push(`Expires=${expires.toUTCString()}`);
+  }
+  document.cookie = parts.join("; ");
+};
+var deleteCookie = (name, options) => {
+  if (!isBrowser()) {
+    return;
+  }
+  writeCookie(name, "", { ...options, expires: /* @__PURE__ */ new Date(0) });
+};
+var BrowserCookieStorageAdapter = class {
+  constructor(options = {}) {
+    __publicField(this, "cookiePrefix");
+    __publicField(this, "cookieOptions");
+    this.cookiePrefix = options.cookiePrefix ?? "";
+    this.cookieOptions = { ...DEFAULT_COOKIE_OPTIONS, ...options.cookieOptions };
+  }
+  /**
+   * Read a cookie value.
+   */
+  get(key) {
+    const cookieName = resolveCookieName(this.cookiePrefix, key);
+    return readCookie(cookieName);
+  }
+  /**
+   * Persist a cookie value.
+   */
+  set(key, value) {
+    const cookieName = resolveCookieName(this.cookiePrefix, key);
+    writeCookie(cookieName, value, this.cookieOptions);
+  }
+  /**
+   * Delete a persisted cookie value.
+   */
+  delete(key) {
+    const cookieName = resolveCookieName(this.cookiePrefix, key);
+    deleteCookie(cookieName, this.cookieOptions);
+  }
+};
+var ServerCookieAccessorsStorageAdapter = class {
+  constructor(options) {
+    __publicField(this, "cookiePrefix");
+    __publicField(this, "cookieOptions");
+    __publicField(this, "cookies");
+    this.cookies = options.cookies;
+    this.cookiePrefix = options.cookiePrefix ?? "";
+    this.cookieOptions = { ...DEFAULT_COOKIE_OPTIONS, ...options.cookieOptions };
+  }
+  /**
+   * Read a cookie value.
+   */
+  get(key) {
+    const cookieName = resolveCookieName(this.cookiePrefix, key);
+    const value = this.cookies.get(cookieName);
+    return resolveCookieValue(value);
+  }
+  /**
+   * Persist a cookie value.
+   */
+  set(key, value) {
+    const cookieName = resolveCookieName(this.cookiePrefix, key);
+    this.cookies.set(cookieName, value, this.cookieOptions);
+  }
+  /**
+   * Delete a persisted cookie value.
+   */
+  delete(key) {
+    const cookieName = resolveCookieName(this.cookiePrefix, key);
+    this.cookies.delete(cookieName, this.cookieOptions);
+  }
+};
+var NoopStorageAdapter = class {
+  /**
+   * Read a stored value (always null).
+   */
+  get() {
+    return null;
+  }
+  /**
+   * Persist a stored value (no-op).
+   */
+  set() {
+  }
+  /**
+   * Delete a stored value (no-op).
+   */
+  delete() {
+  }
+};
+var createDefaultStorageAdapter = (options = {}) => {
+  if (isBrowser()) {
+    if (options.cookies) {
+      return new ServerCookieAccessorsStorageAdapter({
+        cookies: options.cookies,
+        cookiePrefix: options.cookiePrefix,
+        cookieOptions: options.cookieOptions
+      });
+    }
+    return new BrowserCookieStorageAdapter(options);
+  }
+  if (options.cookies) {
+    return new ServerCookieAccessorsStorageAdapter({
+      cookies: options.cookies,
+      cookiePrefix: options.cookiePrefix,
+      cookieOptions: options.cookieOptions
+    });
+  }
+  return new NoopStorageAdapter();
+};
+
+// src/auth.ts
+var DEFAULT_REFRESH_THRESHOLD_SECONDS = 60;
+var getTokenExpiry = (token) => {
+  try {
+    const payload = (0, import_jwt_decode.jwtDecode)(token);
+    const exp = payload?.exp;
+    return typeof exp === "number" ? exp : null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to decode token";
+    throw createSdkError(message);
+  }
+};
+var AuthClient = class {
+  /**
+   * Create a new auth client instance.
+   */
+  constructor(http, options = {}) {
+    __publicField(this, "http");
+    __publicField(this, "storage");
+    __publicField(this, "storageKey");
+    __publicField(this, "refreshEnabled");
+    __publicField(this, "refreshThresholdSeconds");
+    __publicField(this, "serviceKey");
+    __publicField(this, "currentSession", null);
+    __publicField(this, "stateListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "restorePromise", null);
+    /**
+     * Track whether storage restoration has already been attempted.
+     */
+    __publicField(this, "restoreAttempted", false);
+    this.http = http;
+    this.storage = options.storage ?? new NoopStorageAdapter();
+    this.storageKey = options.storageKey ?? DEFAULT_AUTH_COOKIE_NAME;
+    this.refreshEnabled = options.autoRefresh ?? false;
+    this.refreshThresholdSeconds = options.refreshThresholdSeconds ?? DEFAULT_REFRESH_THRESHOLD_SECONDS;
+    this.serviceKey = options.serviceKey ?? null;
+    this.registerAuthHook();
+  }
+  /**
+   * Set the current bearer token, or clear it when null.
+   */
+  async setToken(token) {
+    if (!token) {
+      await this.storage.delete(this.storageKey);
+      this.currentSession = null;
+      this.emitState("SIGNED_OUT", null);
+      return null;
+    }
+    return this.applyToken(token, "SIGNED_IN");
+  }
+  /**
+   * Get the currently configured token (if any).
+   */
+  getToken() {
+    return this.currentSession ?? this.serviceKey ?? null;
+  }
+  /**
+   * Clear the current token and session.
+   */
+  async clearToken() {
+    await this.setToken(null);
+  }
+  /**
+   * Sign in using a JWT token.
+   */
+  async signInWithToken(token, options = {}) {
+    if (options.verifySession) {
+      this.assertTokenNotExpired(token);
+    }
+    return this.applyToken(token, "SIGNED_IN");
+  }
+  /**
+   * Sign in using email/password credentials.
+   */
+  async signIn(payload) {
+    const { data, request, response } = await this.http.requestWithMetadata(
+      "/v2/auth/login",
+      {
+        method: "POST",
+        body: JSON.stringify(payload)
+      }
+    );
+    const token = this.resolveTokenFromResponse(data, { request, response });
+    return this.applyToken(token, "SIGNED_IN");
+  }
+  /**
+   * Sign out the current user.
+   */
+  async signOut() {
+    try {
+      await this.http.request("/v2/auth/logout", { method: "POST" });
+    } finally {
+      await this.clearToken();
+    }
+  }
+  /**
+   * Get the current session, restoring from storage if needed.
+   */
+  async getSession() {
+    if (this.currentSession) {
+      return this.currentSession;
+    }
+    await this.restoreFromStorage();
+    return this.currentSession;
+  }
+  /**
+   * Refresh the current session token.
+   * Manual refresh is always available; automatic refresh is controlled
+   * by the `autoRefresh` option.
+   */
+  async refreshToken() {
+    if (this.isUsingServiceKey()) {
+      throw createSdkError("Token refresh is unavailable when using a service key");
+    }
+    try {
+      const { data, request, response } = await this.http.requestWithMetadata(
+        "/v2/auth/refresh",
+        { method: "POST" }
+      );
+      const token = this.resolveTokenFromResponse(data, { request, response });
+      return await this.applyToken(token, "TOKEN_REFRESHED");
+    } catch (error) {
+      await this.clearToken();
+      throw error;
+    }
+  }
+  /**
+   * Subscribe to auth state changes.
+   */
+  onAuthStateChange(callback) {
+    this.stateListeners.add(callback);
+    return () => {
+      this.stateListeners.delete(callback);
+    };
+  }
+  emitState(event, token) {
+    for (const listener of this.stateListeners) {
+      listener(event, token);
+    }
+  }
+  /**
+   * Register the auth header hook for outgoing HTTP requests.
+   */
+  registerAuthHook() {
+    this.http.onBeforeRequest(async (request) => {
+      if (!this.http.isSameOrigin(request.url)) {
+        return;
+      }
+      const token = await this.resolveRequestToken();
+      if (!token) {
+        return;
+      }
+      const headers = {
+        ...request.init.headers ?? {}
+      };
+      if (headers.Authorization || headers.authorization) {
+        return;
+      }
+      return {
+        ...request,
+        init: {
+          ...request.init,
+          headers: {
+            ...headers,
+            Authorization: `Bearer ${token}`
+          }
+        }
+      };
+    });
+  }
+  /**
+   * Resolve the bearer token to use for outgoing requests.
+   */
+  async resolveRequestToken() {
+    if (this.currentSession) {
+      return this.currentSession;
+    }
+    if (this.serviceKey) {
+      return this.serviceKey;
+    }
+    return await this.getSession();
+  }
+  /**
+   * Persist a token update and notify listeners.
+   */
+  async applyToken(token, event) {
+    await Promise.resolve(this.storage.set(this.storageKey, token));
+    this.currentSession = token;
+    this.emitState(event, token);
+    return token;
+  }
+  /**
+   * Restore a persisted token from storage when needed.
+   */
+  async restoreFromStorage() {
+    if (this.restorePromise) {
+      return this.restorePromise;
+    }
+    if (this.restoreAttempted) {
+      return;
+    }
+    if (this.serviceKey) {
+      this.restoreAttempted = true;
+      return;
+    }
+    this.restorePromise = (async () => {
+      const storedToken = await Promise.resolve(
+        this.storage.get(this.storageKey)
+      );
+      if (!storedToken) {
+        return;
+      }
+      let exp = null;
+      if (this.refreshEnabled) {
+        try {
+          exp = getTokenExpiry(storedToken);
+        } catch {
+          this.currentSession = null;
+          await Promise.resolve(this.storage.delete(this.storageKey));
+          return;
+        }
+      }
+      const hadSession = this.currentSession !== null;
+      this.currentSession = storedToken;
+      if (!hadSession) {
+        this.emitState("SIGNED_IN", storedToken);
+      }
+      if (this.refreshEnabled && exp !== null) {
+        const now = Math.floor(Date.now() / 1e3);
+        if (exp - now <= this.refreshThresholdSeconds) {
+          try {
+            await this.refreshToken();
+          } catch {
+          }
+        }
+      }
+    })();
+    try {
+      await this.restorePromise;
+    } finally {
+      this.restorePromise = null;
+      this.restoreAttempted = true;
+    }
+  }
+  /**
+   * Determine if the client is currently using the service key.
+   */
+  isUsingServiceKey() {
+    return !!this.serviceKey && !this.currentSession;
+  }
+  /**
+   * Resolve the auth token from a response payload and request metadata.
+   */
+  resolveTokenFromResponse(response, metadata) {
+    if (response.error || response.error_description) {
+      const message = response.error_description ?? response.error ?? "Authentication failed";
+      throw createSdkError(message, {
+        request: metadata.request,
+        response: metadata.response,
+        userMessage: message
+      });
+    }
+    const token = response.access_token ?? response.token;
+    if (!token) {
+      throw createSdkError("Missing access token in response", {
+        request: metadata.request,
+        response: metadata.response
+      });
+    }
+    return token;
+  }
+  assertTokenNotExpired(token) {
+    const exp = getTokenExpiry(token);
+    if (exp === null) {
+      return;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (exp < now) {
+      throw createSdkError("Token has expired");
+    }
+  }
+};
+
+// src/channels.ts
+var ChannelsClient = class {
+  /**
+   * Create a new channels client instance.
+   */
+  constructor(http) {
+    __publicField(this, "http");
+    this.http = http;
+  }
+  /**
+   * Fetch a channel by username.
+   */
+  async get(username, options = {}) {
+    const rest = { ...options, body: void 0 };
+    return this.http.request(
+      `/v2/channels/${encodeURIComponent(String(username))}`,
+      {
+        ...rest,
+        method: "GET"
+      }
+    );
+  }
+  /**
+   * Follow a channel by slug.
+   */
+  async follow(channelSlug, options = {}) {
+    return this.http.request(
+      `/v2/channels/${encodeURIComponent(channelSlug)}/follow`,
+      {
+        ...options,
+        method: "POST"
+      }
+    );
+  }
+  /**
+   * Unfollow a channel by slug.
+   */
+  async unfollow(channelSlug, options = {}) {
+    return this.http.request(
+      `/v2/channels/${encodeURIComponent(channelSlug)}/unfollow`,
+      {
+        ...options,
+        method: "POST"
+      }
+    );
+  }
+};
+
+// src/resource.ts
+var buildQueryString = (params) => {
+  if (!params) {
+    return "";
+  }
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === null || item === void 0) {
+          continue;
+        }
+        searchParams.append(`${key}[]`, String(item));
+      }
+      continue;
+    }
+    if (value === null || value === void 0) {
+      continue;
+    }
+    searchParams.set(key, String(value));
+  }
+  return searchParams.toString();
+};
+
+// src/chat.ts
+var ChatClient = class {
+  /**
+   * Create a new chat client instance.
+   */
+  constructor(http) {
+    __publicField(this, "http");
+    this.http = http;
+  }
+  /**
+   * Fetch chat history for a stream.
+   */
+  async getMessages(streamId, params = {}, options = {}) {
+    const rest = { ...options, body: void 0 };
+    const basePath = `/v2/streams/${encodeURIComponent(String(streamId))}/chat`;
+    const query = buildQueryString(params);
+    const path = query ? `${basePath}?${query}` : basePath;
+    return this.http.request(
+      path,
+      {
+        ...rest,
+        method: "GET"
+      }
+    );
+  }
+  /**
+   * Resource-style alias for fetching chat messages by stream id.
+   * @param streamId - Stream identifier.
+   * @param options - Request options.
+   * @returns Chat messages response payload.
+   */
+  async get(streamId, options = {}) {
+    return this.getMessages(streamId, {}, options);
+  }
+  /**
+   * Send a message to a stream chat.
+   */
+  async sendMessage(streamId, message, options = {}) {
+    return this.http.request(
+      `/v2/streams/${encodeURIComponent(String(streamId))}/chat`,
+      {
+        ...options,
+        method: "POST",
+        body: JSON.stringify({ message })
+      }
+    );
+  }
+};
+
+// src/http.ts
+var resolveFetch = (provided) => {
+  if (provided) {
+    return provided.bind(globalThis);
+  }
+  if (typeof fetch === "function") {
+    return fetch.bind(globalThis);
+  }
+  throw createSdkError(
+    "Fetch implementation not found. Provide options.fetch when running outside Node 22+ or the browser."
+  );
+};
+var redactRequestMetadata = (request) => {
+  const redacted = request.clone();
+  redacted.headers.delete("authorization");
+  return redacted;
+};
+var removeContentTypeHeader = (headers) => {
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === "content-type") {
+      delete headers[key];
+    }
+  }
+};
+var normalizeHeaders = (headers) => {
+  if (!headers) {
+    return {};
+  }
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return { ...headers };
+};
+var HttpClient = class {
+  /**
+   * Create a new HTTP client instance.
+   */
+  constructor(options) {
+    __publicField(this, "baseUrl");
+    __publicField(this, "defaultHeaders");
+    __publicField(this, "fetcher");
+    __publicField(this, "beforeRequestHooks", []);
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...options.headers
+    };
+    this.fetcher = resolveFetch(options.fetch);
+  }
+  /**
+   * Register a hook that runs before each request.
+   */
+  onBeforeRequest(hook) {
+    this.beforeRequestHooks = [...this.beforeRequestHooks, hook];
+    return () => {
+      this.beforeRequestHooks = this.beforeRequestHooks.filter(
+        (existing) => existing !== hook
+      );
+    };
+  }
+  /**
+   * Execute an HTTP request and return the parsed response.
+   */
+  async request(path, options = {}) {
+    const { data } = await this.requestWithMetadata(path, options);
+    return data;
+  }
+  /**
+   * Execute an HTTP request and return the response with request metadata.
+   */
+  async requestWithMetadata(path, options = {}) {
+    const url = /^https?:\/\//i.test(path) ? path : `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    const method = (options.method ?? "GET").toUpperCase();
+    const headers = {
+      ...this.defaultHeaders,
+      ...options.headers
+    };
+    const hasExplicitContentType = Object.keys(options.headers ?? {}).some(
+      (key) => key.toLowerCase() === "content-type"
+    );
+    let request = {
+      url,
+      init: {
+        ...options,
+        method,
+        headers
+      }
+    };
+    request = await this.beforeRequestHooks.reduce(
+      async (pendingRequest, hook) => {
+        const currentRequest = await pendingRequest;
+        const result = await hook(currentRequest);
+        return result ?? currentRequest;
+      },
+      Promise.resolve(request)
+    );
+    const normalizedHeaders = normalizeHeaders(request.init.headers);
+    const resolvedMethod = (request.init.method ?? method).toUpperCase();
+    const hasBody = request.init.body !== void 0 && request.init.body !== null;
+    if (!hasBody && !hasExplicitContentType && (resolvedMethod === "GET" || resolvedMethod === "HEAD")) {
+      removeContentTypeHeader(normalizedHeaders);
+    }
+    request = {
+      ...request,
+      init: {
+        ...request.init,
+        method: resolvedMethod,
+        headers: normalizedHeaders
+      }
+    };
+    const requestMetadata = new Request(request.url, request.init);
+    let response = null;
+    try {
+      response = await this.fetcher(request.url, request.init);
+      const contentType = response.headers.get("content-type") ?? "";
+      const isJson = contentType.includes("application/json");
+      if (!response.ok) {
+        const payload = isJson ? await response.json().catch(() => void 0) : await response.text();
+        const payloadObject = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+        const fallbackMessage = typeof payload === "string" ? payload : null;
+        const message = typeof payloadObject?.message === "string" ? payloadObject.message : fallbackMessage || response.statusText || "Request failed";
+        const { code, ...payloadDetails } = payloadObject ?? {};
+        const resolvedCode = typeof code === "string" ? code : void 0;
+        throw createSdkError(message, {
+          ...payloadDetails,
+          code: resolvedCode,
+          request: redactRequestMetadata(requestMetadata),
+          response
+        });
+      }
+      if (response.status === 204) {
+        return { data: void 0, request: requestMetadata, response };
+      }
+      if (contentType.includes("application/json")) {
+        return {
+          data: await response.json(),
+          request: requestMetadata,
+          response
+        };
+      }
+      return {
+        data: await response.text(),
+        request: requestMetadata,
+        response
+      };
+    } catch (error) {
+      if (error instanceof SDKError) {
+        throw error;
+      }
+      const fallbackMessage = error instanceof Error ? error.message : "Request failed";
+      throw createSdkError(fallbackMessage, {
+        request: redactRequestMetadata(requestMetadata),
+        response
+      });
+    }
+  }
+  /**
+   * Determine whether the provided URL is same-origin with the configured base URL.
+   */
+  isSameOrigin(url) {
+    try {
+      return new URL(url).origin === new URL(this.baseUrl).origin;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/realtime.ts
+var resolvePusher = () => {
+  const injected = globalThis.__SDK_Pusher;
+  if (injected) {
+    return injected;
+  }
+  const globalPusher = globalThis.Pusher;
+  if (globalPusher) {
+    return globalPusher;
+  }
+  if (typeof require === "function") {
+    try {
+      const module2 = require("pusher-js");
+      return module2.default ?? module2;
+    } catch {
+    }
+  }
+  const dynamicImport = import("pusher-js");
+  return dynamicImport.then((module2) => {
+    const resolvedModule = module2;
+    return resolvedModule.default ?? module2;
+  }).catch(() => {
+    throw createSdkError(
+      "Pusher constructor not found. Provide globalThis.__SDK_Pusher/globalThis.Pusher, or ensure pusher-js is resolvable from a CJS context (ESM runtimes must inject the global constructor)."
+    );
+  });
+};
+var isPromise = (value) => Boolean(value && typeof value.then === "function");
+var normalizeAuthEndpoint = (baseUrl, authEndpoint) => {
+  if (authEndpoint) {
+    return authEndpoint;
+  }
+  if (!baseUrl) {
+    return "/api/broadcasting/auth";
+  }
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  if (trimmed.endsWith("/api")) {
+    return `${trimmed}/broadcasting/auth`;
+  }
+  return `${trimmed}/api/broadcasting/auth`;
+};
+var normalizePresenceMembers = (members) => {
+  if (!members) {
+    return [];
+  }
+  if (Array.isArray(members)) {
+    return members;
+  }
+  const memberRecord = members.members;
+  if (memberRecord && typeof memberRecord === "object") {
+    return Object.values(memberRecord);
+  }
+  if (typeof members === "object") {
+    return Object.values(members);
+  }
+  return [];
+};
+var createPresenceBindings = () => ({
+  here: /* @__PURE__ */ new Map(),
+  joining: /* @__PURE__ */ new Map(),
+  leaving: /* @__PURE__ */ new Map()
+});
+var NoopRealtimeChannel = class {
+  listen() {
+  }
+  stopListening() {
+  }
+  /**
+   * Register a no-op presence callback.
+   * @returns Unsubscribe function.
+   */
+  here(_callback) {
+    return () => void 0;
+  }
+  /**
+   * Register a no-op presence callback.
+   * @returns Unsubscribe function.
+   */
+  joining(_callback) {
+    return () => void 0;
+  }
+  /**
+   * Register a no-op presence callback.
+   * @returns Unsubscribe function.
+   */
+  leaving(_callback) {
+    return () => void 0;
+  }
+};
+var NoopRealtimeTransport = class {
+  constructor() {
+    /**
+     * Raw realtime provider instance.
+     */
+    __publicField(this, "pusher", null);
+  }
+  /**
+   * Subscribe to a public channel.
+   */
+  channel() {
+    return new NoopRealtimeChannel();
+  }
+  /**
+   * Subscribe to a private channel.
+   */
+  "private"() {
+    return new NoopRealtimeChannel();
+  }
+  /**
+   * Subscribe to a presence channel.
+   */
+  join() {
+    return new NoopRealtimeChannel();
+  }
+  /**
+   * Leave a channel.
+   */
+  leave() {
+  }
+  /**
+   * Disconnect the realtime client.
+   */
+  disconnect() {
+  }
+  /**
+   * Update the auth token for realtime subscriptions.
+   */
+  setToken() {
+  }
+  /**
+   * Listen for connection state changes.
+   */
+  onConnectionStateChange(callback) {
+    callback("disconnected");
+    return () => void 0;
+  }
+};
+var PusherRealtimeTransport = class {
+  /**
+   * Create a new Pusher-backed realtime transport.
+   * @param options - Realtime client configuration.
+   */
+  constructor(options) {
+    __publicField(this, "pusher", null);
+    __publicField(this, "options");
+    /**
+     * Resolved Pusher constructor used during initialization.
+     */
+    __publicField(this, "pusherConstructor", null);
+    /**
+     * Initialization promise when awaiting async token resolution.
+     */
+    __publicField(this, "initializationPromise", null);
+    /**
+     * Track whether disconnect was invoked before initialization finished.
+     */
+    __publicField(this, "isDisconnected", false);
+    __publicField(this, "subscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "connectionListeners", /* @__PURE__ */ new Set());
+    /**
+     * Mutable auth header map shared with the Pusher instance.
+     */
+    __publicField(this, "authHeaders", {});
+    __publicField(this, "token", null);
+    __publicField(this, "currentState", "connecting");
+    /**
+     * Track whether connection listeners are currently being notified.
+     */
+    __publicField(this, "isNotifyingState", false);
+    /**
+     * Queue connection state transitions to preserve delivery order.
+     */
+    __publicField(this, "pendingStates", []);
+    this.options = options;
+    const pendingResolutions = [];
+    const pusherResolution = resolvePusher();
+    if (isPromise(pusherResolution)) {
+      pendingResolutions.push(
+        pusherResolution.then((constructor) => {
+          this.pusherConstructor = constructor;
+        })
+      );
+    } else {
+      this.pusherConstructor = pusherResolution;
+    }
+    const tokenResolution = this.resolveTokenFromOptions();
+    if (isPromise(tokenResolution)) {
+      pendingResolutions.push(tokenResolution);
+    }
+    if (pendingResolutions.length > 0) {
+      this.initializationPromise = Promise.all(pendingResolutions).then(() => {
+        if (this.isDisconnected) {
+          this.initializationPromise = null;
+          return;
+        }
+        this.initialize();
+      }).catch((error) => {
+        this.handleInitializationFailure(error);
+      });
+      return;
+    }
+    this.initialize();
+  }
+  /**
+   * Subscribe to a public channel.
+   */
+  channel(name) {
+    return this.subscribe(name, "public");
+  }
+  /**
+   * Subscribe to a private channel.
+   */
+  "private"(name) {
+    return this.subscribe(name, "private");
+  }
+  /**
+   * Subscribe to a presence channel.
+   */
+  join(name) {
+    return this.subscribe(name, "presence");
+  }
+  /**
+   * Leave a channel.
+   */
+  leave(name) {
+    const subscription = this.subscriptions.get(name) ?? this.subscriptions.get(this.getChannelName(name, "presence")) ?? this.subscriptions.get(this.getChannelName(name, "private"));
+    if (!subscription) {
+      return;
+    }
+    if (!this.pusher) {
+      this.subscriptions.delete(subscription.channelName);
+      return;
+    }
+    this.pusher.unsubscribe(subscription.channelName);
+    this.subscriptions.delete(subscription.channelName);
+  }
+  /**
+   * Disconnect the realtime client.
+   */
+  disconnect() {
+    this.isDisconnected = true;
+    if (!this.pusher) {
+      this.subscriptions.clear();
+      this.handleConnectionState("disconnected");
+      return;
+    }
+    this.pusher.disconnect();
+    this.pusher = null;
+    this.subscriptions.clear();
+    this.handleConnectionState("disconnected");
+  }
+  /**
+   * Update the auth token for realtime subscriptions.
+   */
+  setToken(token) {
+    this.applyToken(token);
+  }
+  /**
+   * Listen for connection state changes.
+   */
+  onConnectionStateChange(callback) {
+    this.connectionListeners.add(callback);
+    callback(this.currentState);
+    return () => {
+      this.connectionListeners.delete(callback);
+    };
+  }
+  /**
+   * Record initialization failures without throwing unhandled rejections.
+   * @param error - Initialization failure.
+   */
+  handleInitializationFailure(error) {
+    void error;
+    this.initializationPromise = null;
+    this.pusher = null;
+    this.handleConnectionState("failed");
+  }
+  initialize() {
+    if (!this.pusherConstructor) {
+      throw createSdkError(
+        "Pusher constructor not found. Provide globalThis.__SDK_Pusher/globalThis.Pusher, or ensure pusher-js is resolvable from a CJS context (ESM runtimes must inject the global constructor)."
+      );
+    }
+    const authEndpoint = normalizeAuthEndpoint(
+      this.options.baseUrl,
+      this.options.authEndpoint
+    );
+    this.pusher = new this.pusherConstructor(this.options.appKey, {
+      wsHost: this.options.wsHost,
+      wsPort: this.options.wsPort ?? 443,
+      wssPort: this.options.wssPort ?? 443,
+      forceTLS: this.options.forceTLS ?? true,
+      enabledTransports: this.options.enabledTransports ?? ["ws", "wss"],
+      cluster: this.options.cluster ?? "",
+      authEndpoint,
+      auth: {
+        headers: this.authHeaders
+      }
+    });
+    this.pusher.connection.bind("state_change", (states) => {
+      this.handleConnectionState(states.current);
+    });
+    this.handleConnectionState(this.pusher.connection.state);
+    this.initializationPromise = null;
+    this.flushPendingSubscriptions(this.pusher);
+  }
+  /**
+   * Subscribe any queued channels after initialization completes.
+   * @param pusher - Initialized Pusher client instance.
+   */
+  flushPendingSubscriptions(pusher) {
+    for (const subscription of this.subscriptions.values()) {
+      if (!subscription.pending) {
+        continue;
+      }
+      const channel = pusher.subscribe(
+        subscription.channelName
+      );
+      subscription.channel = channel;
+      subscription.pending = false;
+      this.bindListeners(subscription);
+      this.rebindPresenceCallbacks(subscription);
+    }
+  }
+  /**
+   * Resolve an initial token from the options provider if available.
+   * @returns A promise when async token resolution is in progress.
+   * @throws {SDKError} When token resolution fails.
+   */
+  resolveTokenFromOptions() {
+    if (!this.options.getToken) {
+      return;
+    }
+    try {
+      const result = this.options.getToken();
+      if (isPromise(result)) {
+        return result.then((token) => {
+          this.applyToken(token);
+        }).catch((error) => {
+          throw this.normalizeTokenError(error, "Failed to resolve auth token.");
+        });
+      }
+      this.applyToken(result ?? null);
+    } catch (error) {
+      throw this.normalizeTokenError(error, "Failed to resolve auth token.");
+    }
+  }
+  /**
+   * Normalize token resolution errors into SDKError instances.
+   * @param error - Error to normalize.
+   * @param fallbackMessage - Fallback error message.
+   * @returns Normalized SDKError instance.
+   */
+  normalizeTokenError(error, fallbackMessage) {
+    if (error instanceof SDKError) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : fallbackMessage;
+    return createSdkError(message);
+  }
+  /**
+   * Apply a new auth token to the client configuration.
+   * Refresh auth subscriptions whenever the token changes.
+   */
+  applyToken(token) {
+    if (token === this.token) {
+      return;
+    }
+    this.token = token;
+    this.syncAuthHeaders();
+    if (!this.pusher) {
+      return;
+    }
+    this.refreshAuthSubscriptions();
+  }
+  /**
+   * Sync the auth header map with the current token.
+   */
+  syncAuthHeaders() {
+    if (this.token) {
+      this.authHeaders.Authorization = `Bearer ${this.token}`;
+      return;
+    }
+    delete this.authHeaders.Authorization;
+  }
+  /**
+   * Normalize and broadcast realtime connection state changes.
+   */
+  handleConnectionState(state) {
+    const mapped = this.mapConnectionState(state);
+    if (mapped === this.currentState) {
+      return;
+    }
+    this.currentState = mapped;
+    this.pendingStates.push(mapped);
+    if (this.isNotifyingState) {
+      return;
+    }
+    this.isNotifyingState = true;
+    let firstError = null;
+    try {
+      while (this.pendingStates.length) {
+        const nextState = this.pendingStates.shift();
+        if (!nextState) {
+          continue;
+        }
+        const listeners = Array.from(this.connectionListeners);
+        for (const listener of listeners) {
+          try {
+            listener(nextState);
+          } catch (error) {
+            if (!firstError) {
+              firstError = error;
+            }
+          }
+        }
+      }
+    } finally {
+      this.isNotifyingState = false;
+    }
+    if (firstError) {
+      throw firstError;
+    }
+  }
+  mapConnectionState(state) {
+    switch (state) {
+      case "initialized":
+      case "connecting":
+        return "connecting";
+      case "connected":
+        return "connected";
+      case "disconnected":
+        return "disconnected";
+      case "unavailable":
+        return "unavailable";
+      case "failed":
+        return "failed";
+      default:
+        return "disconnected";
+    }
+  }
+  subscribe(name, type) {
+    if (this.isDisconnected) {
+      return new NoopRealtimeChannel();
+    }
+    const channelName = this.getChannelName(name, type);
+    const existing = this.subscriptions.get(channelName);
+    if (existing) {
+      return this.createChannelWrapper(existing);
+    }
+    if (!this.pusher) {
+      if (this.initializationPromise) {
+        const subscription2 = this.createPendingSubscription(
+          name,
+          channelName,
+          type
+        );
+        this.subscriptions.set(channelName, subscription2);
+        return this.createChannelWrapper(subscription2);
+      }
+      return new NoopRealtimeChannel();
+    }
+    const channel = this.pusher.subscribe(channelName);
+    const subscription = {
+      name,
+      channelName,
+      type,
+      channel,
+      listeners: /* @__PURE__ */ new Map(),
+      presence: {
+        here: /* @__PURE__ */ new Set(),
+        joining: /* @__PURE__ */ new Set(),
+        leaving: /* @__PURE__ */ new Set()
+      },
+      presenceBindings: createPresenceBindings()
+    };
+    this.subscriptions.set(channelName, subscription);
+    return this.createChannelWrapper(subscription);
+  }
+  /**
+   * Create a placeholder channel while initialization is pending.
+   */
+  createPendingChannel(type) {
+    const channel = {
+      bind: () => void 0,
+      unbind: () => void 0,
+      unbind_all: () => void 0
+    };
+    if (type === "presence") {
+      return {
+        ...channel,
+        members: void 0
+      };
+    }
+    return channel;
+  }
+  /**
+   * Create a subscription record before the Pusher client is ready.
+   */
+  createPendingSubscription(name, channelName, type) {
+    return {
+      name,
+      channelName,
+      type,
+      channel: this.createPendingChannel(type),
+      listeners: /* @__PURE__ */ new Map(),
+      presence: {
+        here: /* @__PURE__ */ new Set(),
+        joining: /* @__PURE__ */ new Set(),
+        leaving: /* @__PURE__ */ new Set()
+      },
+      presenceBindings: createPresenceBindings(),
+      pending: true
+    };
+  }
+  /**
+   * Bind non-presence event listeners to the current channel.
+   * @param subscription - Target subscription record.
+   */
+  bindListeners(subscription) {
+    const channel = subscription.channel;
+    for (const [event, callbacks] of subscription.listeners.entries()) {
+      for (const callback of callbacks) {
+        channel.bind(event, callback);
+      }
+    }
+  }
+  /**
+   * Rebind presence callbacks to the current channel instance.
+   * @param subscription - Target subscription record.
+   * @param options - Optional rebinding configuration.
+   * @param options.emitHere - When true, emit the current member list immediately.
+   */
+  rebindPresenceCallbacks(subscription, options = {}) {
+    if (subscription.type !== "presence") {
+      return;
+    }
+    const emitHere = options.emitHere ?? true;
+    subscription.presenceBindings = createPresenceBindings();
+    for (const callback of subscription.presence.here) {
+      this.bindPresenceListener(subscription, "here", callback);
+    }
+    for (const callback of subscription.presence.joining) {
+      this.bindPresenceListener(subscription, "joining", callback);
+    }
+    for (const callback of subscription.presence.leaving) {
+      this.bindPresenceListener(subscription, "leaving", callback);
+    }
+    const presenceChannel = subscription.channel;
+    const members = normalizePresenceMembers(presenceChannel.members);
+    if (emitHere && members.length) {
+      for (const callback of subscription.presence.here) {
+        callback(members);
+      }
+    }
+  }
+  /**
+   * Bind a presence listener for the current subscription channel.
+   */
+  bindPresenceListener(subscription, type, callback) {
+    const presenceChannel = subscription.channel;
+    if (type === "here") {
+      const bindings2 = subscription.presenceBindings.here;
+      const hereCallback = callback;
+      if (bindings2.has(hereCallback)) {
+        return;
+      }
+      const handler2 = (members) => hereCallback(normalizePresenceMembers(members));
+      presenceChannel.bind("pusher:subscription_succeeded", handler2);
+      bindings2.set(hereCallback, handler2);
+      return;
+    }
+    if (type === "joining") {
+      const bindings2 = subscription.presenceBindings.joining;
+      const joiningCallback = callback;
+      if (bindings2.has(joiningCallback)) {
+        return;
+      }
+      const handler2 = (payload) => joiningCallback(payload);
+      presenceChannel.bind("pusher:member_added", handler2);
+      bindings2.set(joiningCallback, handler2);
+      return;
+    }
+    const bindings = subscription.presenceBindings.leaving;
+    const leavingCallback = callback;
+    if (bindings.has(leavingCallback)) {
+      return;
+    }
+    const handler = (payload) => leavingCallback(payload);
+    presenceChannel.bind("pusher:member_removed", handler);
+    bindings.set(leavingCallback, handler);
+  }
+  /**
+   * Remove a presence listener for the current subscription channel.
+   */
+  removePresenceListener(subscription, type, callback) {
+    if (subscription.type !== "presence") {
+      return;
+    }
+    const presenceChannel = subscription.channel;
+    if (type === "here") {
+      const hereCallback = callback;
+      subscription.presence.here.delete(hereCallback);
+      const bindings2 = subscription.presenceBindings.here;
+      const handler2 = bindings2.get(hereCallback);
+      if (handler2) {
+        presenceChannel.unbind(
+          "pusher:subscription_succeeded",
+          handler2
+        );
+        bindings2.delete(hereCallback);
+      }
+      return;
+    }
+    if (type === "joining") {
+      const joiningCallback = callback;
+      subscription.presence.joining.delete(joiningCallback);
+      const bindings2 = subscription.presenceBindings.joining;
+      const handler2 = bindings2.get(joiningCallback);
+      if (handler2) {
+        presenceChannel.unbind(
+          "pusher:member_added",
+          handler2
+        );
+        bindings2.delete(joiningCallback);
+      }
+      return;
+    }
+    const leavingCallback = callback;
+    subscription.presence.leaving.delete(leavingCallback);
+    const bindings = subscription.presenceBindings.leaving;
+    const handler = bindings.get(leavingCallback);
+    if (handler) {
+      presenceChannel.unbind(
+        "pusher:member_removed",
+        handler
+      );
+      bindings.delete(leavingCallback);
+    }
+  }
+  createChannelWrapper(subscription) {
+    if (subscription.type === "presence") {
+      return this.createPresenceChannelWrapper(subscription);
+    }
+    return this.createBaseChannelWrapper(subscription);
+  }
+  createBaseChannelWrapper(subscription) {
+    return {
+      listen: (event, callback) => {
+        this.addListener(subscription, event, callback);
+      },
+      stopListening: (event, callback) => {
+        this.removeListener(subscription, event, callback);
+      }
+    };
+  }
+  /**
+   * Create a presence channel wrapper with unsubscribe support.
+   */
+  createPresenceChannelWrapper(subscription) {
+    const channel = this.createBaseChannelWrapper(subscription);
+    return {
+      ...channel,
+      here: (callback) => {
+        subscription.presence.here.add(callback);
+        this.bindPresenceListener(subscription, "here", callback);
+        const presenceChannel = subscription.channel;
+        const members = normalizePresenceMembers(presenceChannel.members);
+        if (members.length) {
+          callback(members);
+        }
+        return () => {
+          this.removePresenceListener(subscription, "here", callback);
+        };
+      },
+      joining: (callback) => {
+        subscription.presence.joining.add(callback);
+        this.bindPresenceListener(subscription, "joining", callback);
+        return () => {
+          this.removePresenceListener(subscription, "joining", callback);
+        };
+      },
+      leaving: (callback) => {
+        subscription.presence.leaving.add(callback);
+        this.bindPresenceListener(subscription, "leaving", callback);
+        return () => {
+          this.removePresenceListener(subscription, "leaving", callback);
+        };
+      }
+    };
+  }
+  /**
+   * Refresh private and presence subscriptions after auth changes.
+   */
+  refreshAuthSubscriptions() {
+    if (!this.pusher) {
+      return;
+    }
+    for (const subscription of this.subscriptions.values()) {
+      if (subscription.type === "public") {
+        continue;
+      }
+      this.pusher.unsubscribe(subscription.channelName);
+      if (!this.token) {
+        subscription.channel.unbind_all();
+        subscription.channel = this.createPendingChannel(subscription.type);
+        subscription.presenceBindings = createPresenceBindings();
+        continue;
+      }
+      const channel = this.pusher.subscribe(
+        subscription.channelName
+      );
+      subscription.channel = channel;
+      this.bindListeners(subscription);
+      this.rebindPresenceCallbacks(subscription);
+    }
+  }
+  /**
+   * Register a listener for a realtime event.
+   * @param subscription - Target subscription record.
+   * @param event - Realtime event name (leading dot is optional).
+   * @param callback - Event handler callback.
+   */
+  addListener(subscription, event, callback) {
+    const normalizedEvent = event.startsWith(".") ? event.slice(1) : event;
+    let callbacks = subscription.listeners.get(normalizedEvent);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      subscription.listeners.set(normalizedEvent, callbacks);
+    }
+    if (callbacks.has(callback)) {
+      return;
+    }
+    callbacks.add(callback);
+    subscription.channel.bind(
+      normalizedEvent,
+      callback
+    );
+  }
+  /**
+   * Remove listeners for a realtime event.
+   * @param subscription - Target subscription record.
+   * @param event - Realtime event name to stop listening for.
+   * @param callback - Specific handler to remove if provided.
+   */
+  removeListener(subscription, event, callback) {
+    if (!event) {
+      subscription.listeners.clear();
+      subscription.channel.unbind_all();
+      this.rebindPresenceCallbacks(subscription, { emitHere: false });
+      return;
+    }
+    const normalizedEvent = event.startsWith(".") ? event.slice(1) : event;
+    if (!subscription.listeners.has(normalizedEvent)) {
+      return;
+    }
+    if (callback) {
+      subscription.listeners.get(normalizedEvent)?.delete(callback);
+      subscription.channel.unbind(
+        normalizedEvent,
+        callback
+      );
+      if (subscription.listeners.get(normalizedEvent)?.size === 0) {
+        subscription.listeners.delete(normalizedEvent);
+      }
+      return;
+    }
+    subscription.listeners.delete(normalizedEvent);
+    subscription.channel.unbind(normalizedEvent);
+  }
+  getChannelName(name, type) {
+    switch (type) {
+      case "private":
+        return name.startsWith("private-") ? name : `private-${name}`;
+      case "presence":
+        return name.startsWith("presence-") ? name : `presence-${name}`;
+      default:
+        return name;
+    }
+  }
+};
+var RealtimeNamespace = class {
+  /**
+   * Create a new realtime namespace client.
+   * @param transport - Transport implementation for realtime operations.
+   */
+  constructor(transport) {
+    __publicField(this, "chat");
+    __publicField(this, "transport");
+    this.transport = transport;
+    this.chat = this.createChatNamespace();
+  }
+  /**
+   * Raw Pusher client instance for advanced usage.
+   */
+  get pusher() {
+    return this.transport.pusher;
+  }
+  /**
+   * Subscribe to a public channel.
+   */
+  channel(name) {
+    return this.transport.channel(name);
+  }
+  /**
+   * Subscribe to a private channel.
+   */
+  "private"(name) {
+    return this.transport.private(name);
+  }
+  /**
+   * Subscribe to a presence channel.
+   */
+  join(name) {
+    return this.transport.join(name);
+  }
+  /**
+   * Leave a channel.
+   */
+  leave(name) {
+    this.transport.leave(name);
+  }
+  /**
+   * Disconnect the realtime client.
+   */
+  disconnect() {
+    this.transport.disconnect();
+  }
+  /**
+   * Update the auth token for realtime subscriptions.
+   */
+  setToken(token) {
+    this.transport.setToken(token);
+  }
+  /**
+   * Listen for connection state changes.
+   */
+  onConnectionStateChange(callback) {
+    return this.transport.onConnectionStateChange(callback);
+  }
+  /**
+   * Create the chat realtime helpers.
+   */
+  createChatNamespace() {
+    return {
+      joinRoom: (channelId) => {
+        const channelName = this.toChatRoom(channelId);
+        return this.join(channelName);
+      },
+      leaveRoom: (channelId) => {
+        this.leave(this.toChatRoom(channelId));
+      },
+      onMessage: (channelId, callback) => this.attachChatListener(channelId, ".SendPublicChatMessage", callback),
+      onMessageUpdated: (channelId, callback) => this.attachChatListener(channelId, ".chat.message.updated", callback),
+      onMessageDeleted: (channelId, callback) => this.attachChatListener(channelId, ".chat.message.deleted", callback)
+    };
+  }
+  /**
+   * Attach a chat listener to the channel room.
+   */
+  attachChatListener(channelId, event, callback) {
+    const channel = this.join(this.toChatRoom(channelId));
+    channel.listen(event, callback);
+    return () => {
+      channel.stopListening(event, callback);
+    };
+  }
+  /**
+   * Build the chat room name for a channel id.
+   */
+  toChatRoom(channelId) {
+    return `chat-public.${String(channelId)}`;
+  }
+};
+var createRealtimeClient = (options) => {
+  if (!options) {
+    return new RealtimeNamespace(new NoopRealtimeTransport());
+  }
+  try {
+    return new RealtimeNamespace(new PusherRealtimeTransport(options));
+  } catch (error) {
+    if (error instanceof SDKError) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown realtime error";
+    throw createSdkError(`Failed to initialize realtime client: ${message}`);
+  }
+};
+
+// src/streams.ts
+var StreamsClient = class {
+  /**
+   * Create a new streams client instance.
+   */
+  constructor(http) {
+    __publicField(this, "http");
+    this.http = http;
+  }
+  /**
+   * List active streams.
+   */
+  async listActive(options = {}) {
+    return this.list(void 0, options);
+  }
+  /**
+   * List streams with optional query params.
+   */
+  async list(params, options = {}) {
+    const rest = { ...options, body: void 0 };
+    const query = buildQueryString(params);
+    const path = query ? `/v2/streams?${query}` : "/v2/streams";
+    return this.http.request(path, {
+      ...rest,
+      method: "GET"
+    });
+  }
+  /**
+   * Fetch a stream by id.
+   */
+  async get(streamId, options = {}) {
+    const rest = { ...options, body: void 0 };
+    return this.http.request(
+      `/v2/streams/${encodeURIComponent(String(streamId))}`,
+      {
+        ...rest,
+        method: "GET"
+      }
+    );
+  }
+  /**
+   * Fetch a stream by channel slug.
+   * @param userLogin - Channel slug or login handle.
+   * @param options - Request options.
+   * @returns Stream payload when found, otherwise null.
+   */
+  async getBySlug(userLogin, options = {}) {
+    const rest = { ...options, body: void 0 };
+    try {
+      const channelResponse = await this.http.request(
+        `/v2/channels/${encodeURIComponent(userLogin)}`,
+        {
+          ...rest,
+          method: "GET"
+        }
+      );
+      if (channelResponse?.active_stream) {
+        return channelResponse.active_stream;
+      }
+      return null;
+    } catch (error) {
+      if (error instanceof SDKError) {
+        if (error.statusCode === 404) {
+          return null;
+        }
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw createSdkError(message);
+    }
+  }
+  /**
+   * Fetch the player source payload for the given stream id.
+   */
+  async getPlayerSource(streamId, options = {}) {
+    const response = await this.get(streamId, options);
+    const stream = this.extractStreamPayload(response);
+    return stream?.player_source ?? null;
+  }
+  /**
+   * Normalize stream payloads for get operations.
+   */
+  extractStreamPayload(response) {
+    if (response && typeof response === "object") {
+      if ("data" in response) {
+        return response.data ?? null;
+      }
+    }
+    return response ?? null;
+  }
+};
+
+// src/base-client.ts
+var BaseSdkClient = class {
+  /**
+   * Create a new SDK client base instance.
+   */
+  constructor(baseUrl, options) {
+    /**
+     * Auth client instance.
+     */
+    __publicField(this, "auth");
+    /**
+     * HTTP client instance.
+     */
+    __publicField(this, "http");
+    /**
+     * Realtime client instance.
+     */
+    __publicField(this, "realtime");
+    /**
+     * Streams namespace client.
+     */
+    __publicField(this, "streams");
+    /**
+     * Channels namespace client.
+     */
+    __publicField(this, "channels");
+    /**
+     * Chat namespace client.
+     */
+    __publicField(this, "chat");
+    const authOptions = options.auth ?? {};
+    const serviceKey = options.serviceKey === void 0 ? authOptions.serviceKey ?? null : options.serviceKey;
+    const http = new HttpClient({
+      baseUrl,
+      headers: options.headers,
+      fetch: options.fetch
+    });
+    const auth = new AuthClient(http, {
+      ...authOptions,
+      storage: options.storage,
+      serviceKey
+    });
+    const realtime = createRealtimeClient(
+      options.realtime ? {
+        ...options.realtime,
+        baseUrl,
+        getToken: async () => auth.getSession()
+      } : void 0
+    );
+    auth.onAuthStateChange((event, token) => {
+      if (event === "SIGNED_OUT") {
+        realtime.setToken(null);
+        return;
+      }
+      realtime.setToken(token);
+    });
+    this.http = http;
+    this.auth = auth;
+    this.realtime = realtime;
+    this.streams = new StreamsClient(http);
+    this.channels = new ChannelsClient(http);
+    this.chat = new ChatClient(http);
+  }
+};
+
+// src/browser-client.ts
+var BrowserClient = class extends BaseSdkClient {
+  /**
+   * Create a browser client instance.
+   */
+  constructor(baseUrl, keyOverride, options = {}) {
+    const authOptions = options.auth ?? {};
+    const serviceKey = keyOverride === void 0 ? authOptions.serviceKey ?? null : keyOverride;
+    const storage = authOptions.storage ?? createDefaultStorageAdapter({
+      cookiePrefix: authOptions.cookiePrefix,
+      cookieOptions: authOptions.cookieOptions,
+      cookies: authOptions.cookies
+    });
+    super(baseUrl, {
+      auth: authOptions,
+      headers: options.headers,
+      fetch: options.fetch,
+      realtime: options.realtime,
+      storage,
+      serviceKey
+    });
+  }
+};
+var createBrowserClient = (baseUrl, keyOverride, options = {}) => new BrowserClient(baseUrl, keyOverride, options);
+var createClient = (baseUrl, keyOverride, options = {}) => createBrowserClient(baseUrl, keyOverride, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserClient,
+  createBrowserClient,
+  createClient
+});
+//# sourceMappingURL=browser-client.js.map