@edge-base/react-native 0.1.1

package/dist/index.js

@@ -0,0 +1,3118 @@
+import { EdgeBaseError, ApiPaths, ContextManager, HttpClient, DefaultDbApi, HttpClientAdapter, PublicHttpClientAdapter, StorageClient, FunctionsClient, DbRef } from '@edge-base/core';
+import React, { useCallback, useState, useEffect } from 'react';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) throw new EdgeBaseError(0, "Invalid JWT format");
+  const payload = parts[1];
+  const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "==".slice(0, (4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+function isTokenExpired(token, bufferSeconds = 30) {
+  try {
+    const payload = decodeJwtPayload(token);
+    const exp = payload.exp;
+    if (!exp) return true;
+    return Date.now() / 1e3 >= exp - bufferSeconds;
+  } catch {
+    return true;
+  }
+}
+function extractUser(token) {
+  try {
+    const payload = decodeJwtPayload(token);
+    return {
+      id: payload.sub,
+      email: payload.email,
+      displayName: payload.displayName,
+      avatarUrl: payload.avatarUrl,
+      role: payload.role,
+      isAnonymous: payload.isAnonymous,
+      emailVisibility: payload.emailVisibility,
+      custom: payload.custom
+    };
+  } catch {
+    return null;
+  }
+}
+var REFRESH_TOKEN_KEY = "edgebase:refresh-token";
+var PUSH_TOKEN_CACHE_KEY = "edgebase:push-token-cache";
+var PUSH_DEVICE_ID_KEY = "edgebase:push-device-id";
+var TokenManager = class {
+  constructor(baseUrl, storage) {
+    this.baseUrl = baseUrl;
+    this.storage = storage;
+    this.initPromise = this.restore();
+  }
+  accessToken = null;
+  refreshToken = null;
+  refreshPromise = null;
+  authStateListeners = [];
+  cachedUser = null;
+  storage;
+  initialized = false;
+  initPromise;
+  /** Wait for storage restore to complete */
+  async ready() {
+    return this.initPromise;
+  }
+  async restore() {
+    try {
+      const stored = await this.storage.getItem(REFRESH_TOKEN_KEY);
+      if (stored && !isTokenExpired(stored, 0)) {
+        this.refreshToken = stored;
+        this.cachedUser = extractUser(stored);
+      }
+    } catch {
+    }
+    this.initialized = true;
+  }
+  /** Get valid access token, refreshing if needed */
+  async getAccessToken(doRefresh) {
+    await this.initPromise;
+    if (this.accessToken && !isTokenExpired(this.accessToken)) {
+      return this.accessToken;
+    }
+    const refreshToken = this.refreshToken;
+    if (!refreshToken) return null;
+    if (this.refreshPromise) {
+      const result2 = await this.refreshPromise;
+      return result2.accessToken;
+    }
+    this.refreshPromise = doRefresh(refreshToken).then((tokens) => {
+      this.setTokens(tokens);
+      return tokens;
+    }).catch((err) => {
+      if (err instanceof EdgeBaseError && err.code === 401) {
+        this.clearTokens();
+      }
+      throw err;
+    }).finally(() => {
+      this.refreshPromise = null;
+    });
+    const result = await this.refreshPromise;
+    return result.accessToken;
+  }
+  /** Set tokens after successful auth (sync in-memory + async persist) */
+  setTokens(tokens) {
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken;
+    void this.storage.setItem(REFRESH_TOKEN_KEY, tokens.refreshToken);
+    this.updateUser(tokens.accessToken);
+  }
+  /** Get stored refresh token (sync from memory cache) */
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  /** Drop the current access token so the next request must refresh or fail fast. */
+  invalidateAccessToken() {
+    this.accessToken = null;
+    if (!this.refreshToken) {
+      this.cachedUser = null;
+      this.emitAuthStateChange(null);
+    }
+  }
+  /** Read-only access to current access token (for websocket re-auth). */
+  get currentAccessToken() {
+    return this.accessToken;
+  }
+  /** Clear all tokens on sign-out */
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
+    void this.storage.removeItem(REFRESH_TOKEN_KEY);
+    this.cachedUser = null;
+    this.emitAuthStateChange(null);
+  }
+  /** Get current user (from cached JWT payload) */
+  getCurrentUser() {
+    return this.cachedUser;
+  }
+  /** Subscribe to auth state changes. Fires immediately with current state. */
+  onAuthStateChange(handler) {
+    this.authStateListeners.push(handler);
+    handler(this.cachedUser);
+    return () => {
+      this.authStateListeners = this.authStateListeners.filter((h) => h !== handler);
+    };
+  }
+  updateUser(accessToken) {
+    const user = extractUser(accessToken);
+    this.cachedUser = user;
+    this.emitAuthStateChange(user);
+  }
+  emitAuthStateChange(user) {
+    for (const listener of this.authStateListeners) {
+      listener(user);
+    }
+  }
+  /** Clean up (no-op in RN, kept for API parity with web SDK) */
+  destroy() {
+    this.authStateListeners = [];
+  }
+};
+
+// src/auth.ts
+var AuthClient = class {
+  constructor(client, tokenManager, core, corePublic, linking) {
+    this.client = client;
+    this.tokenManager = tokenManager;
+    this.core = core;
+    this.corePublic = corePublic;
+    this.linking = linking;
+    this.baseUrl = client.getBaseUrl();
+  }
+  baseUrl;
+  /** Register a new user. Optionally include user metadata. */
+  async signUp(options) {
+    const body = {
+      email: options.email,
+      password: options.password
+    };
+    if (options.data) body.data = options.data;
+    if (options.captchaToken) body.captchaToken = options.captchaToken;
+    const result = await this.corePublic.authSignup(body);
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  /** Sign in with email and password. Returns MfaRequiredResult if MFA is enabled. */
+  async signIn(options) {
+    const body = {
+      email: options.email,
+      password: options.password
+    };
+    if (options.captchaToken) body.captchaToken = options.captchaToken;
+    const result = await this.corePublic.authSignin(body);
+    if ("mfaRequired" in result && result.mfaRequired) {
+      return result;
+    }
+    const authResult = result;
+    this.tokenManager.setTokens({
+      accessToken: authResult.accessToken,
+      refreshToken: authResult.refreshToken
+    });
+    return authResult;
+  }
+  /** Sign out — revokes current session on server and clears local tokens. */
+  async signOut() {
+    try {
+      const refreshToken = await this.tokenManager.getRefreshToken();
+      if (refreshToken) {
+        await this.core.authSignout({ refreshToken });
+      }
+    } catch {
+    }
+    this.tokenManager.clearTokens();
+  }
+  /** Refresh the current session using the stored refresh token. */
+  async refreshSession() {
+    const refreshToken = await this.tokenManager.getRefreshToken();
+    if (!refreshToken) {
+      throw new Error("No refresh token available.");
+    }
+    const result = await this.corePublic.authRefresh({ refreshToken });
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  /**
+   * Start OAuth sign-in flow.
+   * Opens the OAuth URL via Linking.openURL() and listens for the deep link callback.
+   * The app must be configured with a deep link scheme (e.g. myapp://auth/callback).
+   *
+   * @param provider - OAuth provider name (e.g. 'google', 'github')
+   * @param options.redirectUrl - Deep link URL to redirect back to after OAuth (required for RN)
+   * @param options.captchaToken - Optional captcha token
+   * @returns Promise that resolves with AuthResult when OAuth completes
+   *
+   * NOTE: Not delegated to Generated Core — this is URL construction + redirect, not a standard HTTP call.
+   */
+  signInWithOAuth(providerOrOptions, options) {
+    const provider = typeof providerOrOptions === "string" ? providerOrOptions : providerOrOptions.provider;
+    const resolvedOptions = typeof providerOrOptions === "string" ? options : providerOrOptions;
+    let url = `${this.baseUrl}/api/auth/oauth/${encodeURIComponent(provider)}`;
+    if (resolvedOptions?.captchaToken) {
+      url += `?captcha_token=${encodeURIComponent(resolvedOptions.captchaToken)}`;
+    }
+    if (resolvedOptions?.redirectUrl) {
+      const sep = url.includes("?") ? "&" : "?";
+      url += `${sep}redirect_url=${encodeURIComponent(resolvedOptions.redirectUrl)}`;
+    }
+    if (this.linking) {
+      void this.linking.openURL(url);
+    }
+    return { url };
+  }
+  /**
+   * Handle OAuth deep link callback.
+   * Call this when your app receives a deep link URL with auth tokens.
+   * Extract tokens from query params and store them.
+   *
+   * @example
+   * // In your navigation/linking config:
+   * Linking.addEventListener('url', ({ url }) => client.auth.handleOAuthCallback(url));
+   */
+  async handleOAuthCallback(url) {
+    try {
+      const parsed = new URL(url);
+      const accessToken = parsed.searchParams.get("access_token");
+      const refreshToken = parsed.searchParams.get("refresh_token");
+      if (!accessToken || !refreshToken) return null;
+      this.tokenManager.setTokens({ accessToken, refreshToken });
+      return {
+        user: this.tokenManager.getCurrentUser(),
+        accessToken,
+        refreshToken
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Sign in anonymously. */
+  async signInAnonymously(options) {
+    const body = options?.captchaToken ? { captchaToken: options.captchaToken } : void 0;
+    const result = await this.corePublic.authSigninAnonymous(body);
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  /**
+   * Send a magic link (passwordless login) email.
+   * If the email is not registered and autoCreate is enabled (server config), a new account is created.
+   */
+  async signInWithMagicLink(options) {
+    const body = { email: options.email };
+    if (options.captchaToken) {
+      body.captchaToken = options.captchaToken;
+    }
+    await this.corePublic.authSigninMagicLink(body);
+  }
+  /**
+   * Verify a magic link token and sign in.
+   * Called after user clicks the link from their email.
+   */
+  async verifyMagicLink(token) {
+    const result = await this.corePublic.authVerifyMagicLink({ token });
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  // ─── Phone / SMS Auth ───
+  /**
+   * Send an SMS verification code to the given phone number.
+   * If the phone is not registered and autoCreate is enabled (server config), a new account is created on verify.
+   */
+  async signInWithPhone(options) {
+    const body = { phone: options.phone };
+    if (options.captchaToken) {
+      body.captchaToken = options.captchaToken;
+    }
+    await this.corePublic.authSigninPhone(body);
+  }
+  /**
+   * Verify the SMS code and sign in.
+   * Called after user receives the code from signInWithPhone.
+   */
+  async verifyPhone(options) {
+    const result = await this.corePublic.authVerifyPhone({
+      phone: options.phone,
+      code: options.code
+    });
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  /** Link current account with a phone number. Sends an SMS code. */
+  async linkWithPhone(options) {
+    await this.core.authLinkPhone({ phone: options.phone });
+  }
+  /** Verify phone link code. Completes phone linking for the current account. */
+  async verifyLinkPhone(options) {
+    await this.core.authVerifyLinkPhone({
+      phone: options.phone,
+      code: options.code
+    });
+  }
+  /** Link anonymous account to email/password. */
+  async linkWithEmail(options) {
+    const result = await this.core.authLinkEmail({
+      email: options.email,
+      password: options.password
+    });
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  /**
+   * Link anonymous account to OAuth provider. Returns URL to open in browser.
+   *
+   * NOTE: Not delegated — Generated Core's oauthLinkStart(provider) takes no body,
+   * but we need to pass { redirectUrl }.
+   */
+  async linkWithOAuth(providerOrOptions, options) {
+    const provider = typeof providerOrOptions === "string" ? providerOrOptions : providerOrOptions.provider;
+    const resolvedOptions = typeof providerOrOptions === "string" ? options : providerOrOptions;
+    const redirectUrl = resolvedOptions?.redirectUrl ?? "";
+    const result = await this.client.post(
+      `/api/auth/oauth/link/${encodeURIComponent(provider)}`,
+      { redirectUrl }
+    );
+    if (this.linking) {
+      void this.linking.openURL(result.redirectUrl);
+    }
+    return result;
+  }
+  /** Subscribe to authentication state changes. */
+  onAuthStateChange(callback) {
+    return this.tokenManager.onAuthStateChange(callback);
+  }
+  /** Get current authenticated user (from cached JWT). */
+  get currentUser() {
+    return this.tokenManager.getCurrentUser();
+  }
+  /** List active sessions. */
+  async listSessions() {
+    const result = await this.core.authGetSessions();
+    return result.sessions;
+  }
+  /** Revoke a specific session. */
+  async revokeSession(sessionId) {
+    await this.core.authDeleteSession(sessionId);
+  }
+  /** Update current user's profile. */
+  async updateProfile(data) {
+    const result = await this.core.authUpdateProfile(data);
+    if (result.accessToken && result.refreshToken) {
+      this.tokenManager.setTokens({
+        accessToken: result.accessToken,
+        refreshToken: result.refreshToken
+      });
+    }
+    return this.tokenManager.getCurrentUser();
+  }
+  /** Verify email address with token. */
+  async verifyEmail(token) {
+    await this.corePublic.authVerifyEmail({ token });
+  }
+  /** Request a verification email for the current user. */
+  async requestEmailVerification(options) {
+    const body = {};
+    if (options?.redirectUrl) body.redirectUrl = options.redirectUrl;
+    await this.core.authRequestEmailVerification(body);
+  }
+  /** Verify a pending email change using the emailed token. */
+  async verifyEmailChange(token) {
+    await this.corePublic.authVerifyEmailChange({ token });
+  }
+  /** Request password reset email. */
+  async requestPasswordReset(email, options) {
+    const body = { email };
+    if (options?.captchaToken) body.captchaToken = options.captchaToken;
+    await this.corePublic.authRequestPasswordReset(body);
+  }
+  /** Reset password with token. */
+  async resetPassword(token, newPassword) {
+    await this.corePublic.authResetPassword({ token, newPassword });
+  }
+  /** Change password for authenticated user. */
+  async changePassword(options) {
+    const result = await this.core.authChangePassword({
+      currentPassword: options.currentPassword,
+      newPassword: options.newPassword
+    });
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  /** Request an email change for the authenticated user. */
+  async changeEmail(options) {
+    const body = {
+      newEmail: options.newEmail,
+      password: options.password
+    };
+    if (options.redirectUrl) body.redirectUrl = options.redirectUrl;
+    await this.client.post("/api/auth/change-email", body);
+  }
+  /** List linked sign-in identities for the current user. */
+  async listIdentities() {
+    return this.client.get("/api/auth/identities");
+  }
+  /** Unlink a linked OAuth identity by its identity ID. */
+  async unlinkIdentity(identityId) {
+    return this.client.delete(`/api/auth/identities/${encodeURIComponent(identityId)}`);
+  }
+  /** Send an email OTP code for sign-in. */
+  async signInWithEmailOtp(options) {
+    await this.corePublic.authSigninEmailOtp({ email: options.email });
+  }
+  /** Verify an email OTP code and sign in. */
+  async verifyEmailOtp(options) {
+    const result = await this.corePublic.authVerifyEmailOtp({
+      email: options.email,
+      code: options.code
+    });
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  // ─── Passkeys / WebAuthn REST layer ───
+  /** Generate WebAuthn registration options for the current authenticated user. */
+  async passkeysRegisterOptions() {
+    return this.core.authPasskeysRegisterOptions();
+  }
+  /** Verify and store a passkey registration response from the platform credential API. */
+  async passkeysRegister(response) {
+    return this.core.authPasskeysRegister({ response });
+  }
+  /** Generate WebAuthn authentication options. */
+  async passkeysAuthOptions(options) {
+    return this.corePublic.authPasskeysAuthOptions(options ?? {});
+  }
+  /** Verify a WebAuthn assertion and establish a session. */
+  async passkeysAuthenticate(response) {
+    const result = await this.corePublic.authPasskeysAuthenticate({ response });
+    this.tokenManager.setTokens({
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    });
+    return result;
+  }
+  /** List registered passkeys for the current authenticated user. */
+  async passkeysList() {
+    return this.core.authPasskeysList();
+  }
+  /** Delete a registered passkey by credential ID. */
+  async passkeysDelete(credentialId) {
+    return this.core.authPasskeysDelete(credentialId);
+  }
+  // ─── MFA / TOTP ───
+  /** MFA sub-namespace for TOTP enrollment, verification, and management. */
+  get mfa() {
+    this.client;
+    const core = this.core;
+    const corePublic = this.corePublic;
+    const tokenManager = this.tokenManager;
+    return {
+      /** Enroll TOTP — returns secret, QR code URI, and recovery codes. */
+      async enrollTotp() {
+        return core.authMfaTotpEnroll();
+      },
+      /** Verify TOTP enrollment with factorId and a TOTP code. */
+      async verifyTotpEnrollment(factorId, code) {
+        return core.authMfaTotpVerify({ factorId, code });
+      },
+      /** Verify TOTP code during MFA challenge (after signIn returns mfaRequired). */
+      async verifyTotp(mfaTicket, code) {
+        const result = await corePublic.authMfaVerify({
+          mfaTicket,
+          code
+        });
+        tokenManager.setTokens({
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken
+        });
+        return result;
+      },
+      /** Use a recovery code during MFA challenge. */
+      async useRecoveryCode(mfaTicket, recoveryCode) {
+        const result = await corePublic.authMfaRecovery({
+          mfaTicket,
+          recoveryCode
+        });
+        tokenManager.setTokens({
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken
+        });
+        return result;
+      },
+      /**
+       * Disable TOTP for the current user. Requires password or TOTP code.
+       */
+      async disableTotp(options) {
+        return core.authMfaTotpDelete(options ?? {});
+      },
+      /** List enrolled MFA factors for the current user. */
+      async listFactors() {
+        return core.authMfaFactors();
+      }
+    };
+  }
+};
+async function refreshAccessToken(baseUrl, refreshToken) {
+  let response;
+  try {
+    response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken })
+    });
+  } catch (error) {
+    throw new EdgeBaseError(
+      0,
+      `Network error: ${error instanceof Error ? error.message : "Failed to refresh access token."}`
+    );
+  }
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new EdgeBaseError(
+      response.status,
+      typeof body?.message === "string" ? body.message : "Failed to refresh access token."
+    );
+  }
+  if (!body?.accessToken || !body?.refreshToken) {
+    throw new EdgeBaseError(500, "Invalid auth refresh response.");
+  }
+  return {
+    accessToken: body.accessToken,
+    refreshToken: body.refreshToken
+  };
+}
+
+// src/database-live.ts
+var DatabaseLiveClient = class {
+  constructor(baseUrl, tokenManager, options, contextManager) {
+    this.baseUrl = baseUrl;
+    this.tokenManager = tokenManager;
+    this.options = {
+      autoReconnect: options?.autoReconnect ?? true,
+      maxReconnectAttempts: options?.maxReconnectAttempts ?? 10,
+      reconnectBaseDelay: options?.reconnectBaseDelay ?? 1e3
+    };
+    if (contextManager) {
+      contextManager.onContextChange(() => this.handleContextChange());
+    }
+    this.unsubAuthState = this.tokenManager.onAuthStateChange((user) => {
+      this.handleAuthStateChange(user);
+    });
+  }
+  ws = null;
+  connectingPromise = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  connectedChannels = /* @__PURE__ */ new Set();
+  channelFilters = /* @__PURE__ */ new Map();
+  channelOrFilters = /* @__PURE__ */ new Map();
+  errorHandlers = [];
+  reconnectAttempts = 0;
+  connected = false;
+  authenticated = false;
+  waitingForAuth = false;
+  authRecoveryPromise = null;
+  heartbeatTimer = null;
+  unsubAuthState = null;
+  options;
+  onSnapshot(channel, callback, clientFilters, serverFilters, serverOrFilters) {
+    const sub = {
+      channel,
+      handler: callback,
+      filters: clientFilters,
+      serverFilters,
+      serverOrFilters
+    };
+    if (!this.subscriptions.has(channel)) {
+      this.subscriptions.set(channel, []);
+    }
+    this.subscriptions.get(channel).push(sub);
+    if (sub.serverFilters && sub.serverFilters.length > 0) {
+      this.channelFilters.set(channel, sub.serverFilters);
+    }
+    if (sub.serverOrFilters && sub.serverOrFilters.length > 0) {
+      this.channelOrFilters.set(channel, sub.serverOrFilters);
+    }
+    this.connect(channel).catch(() => {
+    });
+    return () => {
+      const subs = this.subscriptions.get(channel);
+      if (!subs) return;
+      const idx = subs.indexOf(sub);
+      if (idx >= 0) subs.splice(idx, 1);
+      if (subs.length === 0) {
+        this.subscriptions.delete(channel);
+        this.channelFilters.delete(channel);
+        this.channelOrFilters.delete(channel);
+        this.sendUnsubscribe(channel);
+      }
+    };
+  }
+  onError(handler) {
+    this.errorHandlers.push(handler);
+    return () => {
+      const idx = this.errorHandlers.indexOf(handler);
+      if (idx >= 0) this.errorHandlers.splice(idx, 1);
+    };
+  }
+  async connect(channel) {
+    this.connectedChannels.add(channel);
+    if (this.ws && this.connected) {
+      this.sendSubscribe(channel);
+      return;
+    }
+    if (!this.hasAuthContext()) {
+      this.waitingForAuth = true;
+      return;
+    }
+    if (this.connectingPromise) {
+      return this.connectingPromise;
+    }
+    const connection = this.establishConnection(channel).finally(() => {
+      if (this.connectingPromise === connection) {
+        this.connectingPromise = null;
+      }
+    });
+    this.connectingPromise = connection;
+    return connection;
+  }
+  reconnect() {
+    if (this.connected || this.connectedChannels.size === 0) return;
+    const firstChannel = this.connectedChannels.values().next().value;
+    if (!firstChannel) return;
+    this.reconnectAttempts = 0;
+    this.options.autoReconnect = true;
+    this.connect(firstChannel).catch(() => {
+    });
+  }
+  disconnect() {
+    this.options.autoReconnect = false;
+    this.stopHeartbeat();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.connected = false;
+    this.authenticated = false;
+    this.connectingPromise = null;
+    this.connectedChannels.clear();
+    this.subscriptions.clear();
+    this.channelFilters.clear();
+    this.channelOrFilters.clear();
+    this.errorHandlers = [];
+    this.unsubAuthState?.();
+    this.unsubAuthState = null;
+  }
+  async establishConnection(channel) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.buildWsUrl(channel));
+      this.ws = ws;
+      ws.onopen = () => {
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        this.authenticate().then(() => {
+          this.waitingForAuth = false;
+          resolve();
+        }).catch((error) => {
+          this.handleAuthenticationFailure(error);
+          reject(error);
+        });
+      };
+      ws.onmessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      ws.onclose = () => {
+        this.connected = false;
+        this.authenticated = false;
+        this.ws = null;
+        this.stopHeartbeat();
+        if (this.options.autoReconnect && !this.waitingForAuth && this.reconnectAttempts < this.options.maxReconnectAttempts) {
+          this.scheduleReconnect(channel);
+        }
+      };
+      ws.onerror = () => {
+        reject(new EdgeBaseError(500, "Database live WebSocket connection error"));
+      };
+    });
+  }
+  async authenticate() {
+    const token = await this.tokenManager.getAccessToken(
+      (refreshToken) => refreshAccessToken(this.baseUrl, refreshToken)
+    );
+    if (!token) throw new EdgeBaseError(401, "No access token available. Sign in first.");
+    this.sendRaw({ type: "auth", token, sdkVersion: "0.1.0" });
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new EdgeBaseError(401, "Auth timeout")), 1e4);
+      const original = this.ws?.onmessage;
+      if (!this.ws) return;
+      this.ws.onmessage = (event) => {
+        const msg = JSON.parse(event.data);
+        if (msg.type === "auth_success" || msg.type === "auth_refreshed") {
+          clearTimeout(timeout);
+          this.authenticated = true;
+          if (this.ws) this.ws.onmessage = original ?? null;
+          if (msg.type === "auth_refreshed") {
+            const revoked = msg.revokedChannels ?? [];
+            for (const channel of revoked) {
+              this.subscriptions.delete(channel);
+              this.channelFilters.delete(channel);
+              this.channelOrFilters.delete(channel);
+              this.connectedChannels.delete(channel);
+            }
+          }
+          this.resubscribeAll();
+          resolve();
+        } else if (msg.type === "error") {
+          clearTimeout(timeout);
+          reject(new EdgeBaseError(401, msg.message));
+        }
+      };
+    });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const type = msg.type;
+    if (type === "db_change") {
+      const change = {
+        changeType: msg.changeType,
+        table: msg.table,
+        docId: msg.docId,
+        data: msg.data,
+        timestamp: msg.timestamp
+      };
+      const messageChannel = typeof msg.channel === "string" ? msg.channel : void 0;
+      for (const [channel, subs] of this.subscriptions.entries()) {
+        if (!matchesDatabaseLiveChannel(channel, change, messageChannel)) continue;
+        for (const sub of subs) {
+          if (sub.filters && change.data && !matchesClientFilter(change.data, sub.filters)) continue;
+          sub.handler(change);
+        }
+      }
+      return;
+    }
+    if (type === "batch_changes") {
+      const changes = msg.changes;
+      if (!Array.isArray(changes)) return;
+      for (const entry of changes) {
+        const change = {
+          changeType: entry.event,
+          table: msg.table ?? "",
+          docId: entry.docId,
+          data: entry.data,
+          timestamp: entry.timestamp
+        };
+        const messageChannel = typeof msg.channel === "string" ? msg.channel : void 0;
+        for (const [channel, subs] of this.subscriptions.entries()) {
+          if (!matchesDatabaseLiveChannel(channel, change, messageChannel)) continue;
+          for (const sub of subs) {
+            if (sub.filters && change.data && !matchesClientFilter(change.data, sub.filters)) continue;
+            sub.handler(change);
+          }
+        }
+      }
+      return;
+    }
+    if (type === "FILTER_RESYNC") {
+      this.resyncFilters();
+      return;
+    }
+    if (type === "auth_refreshed") {
+      const revoked = msg.revokedChannels ?? [];
+      for (const channel of revoked) {
+        this.subscriptions.delete(channel);
+        this.channelFilters.delete(channel);
+        this.channelOrFilters.delete(channel);
+        this.connectedChannels.delete(channel);
+      }
+      return;
+    }
+    if (type === "error") {
+      if (msg.code === "NOT_AUTHENTICATED" && this.hasAuthContext()) {
+        this.recoverAuthentication();
+        return;
+      }
+      for (const handler of this.errorHandlers) {
+        handler({ code: msg.code, message: msg.message });
+      }
+    }
+  }
+  sendSubscribe(channel) {
+    if (!this.authenticated) return;
+    const filters = this.channelFilters.get(channel);
+    const orFilters = this.channelOrFilters.get(channel);
+    const msg = { type: "subscribe", channel };
+    if (filters && filters.length > 0) msg.filters = filters;
+    if (orFilters && orFilters.length > 0) msg.orFilters = orFilters;
+    this.sendRaw(msg);
+  }
+  sendUnsubscribe(channel) {
+    this.connectedChannels.delete(channel);
+    if (this.authenticated) this.sendRaw({ type: "unsubscribe", channel });
+  }
+  resubscribeAll() {
+    for (const channel of this.connectedChannels) this.sendSubscribe(channel);
+  }
+  refreshAuth() {
+    const token = this.tokenManager.currentAccessToken;
+    if (!token || !this.ws || !this.connected) return;
+    this.sendRaw({ type: "auth", token, sdkVersion: "0.1.0" });
+  }
+  handleAuthStateChange(user) {
+    if (user) {
+      if (this.ws && this.connected && this.authenticated) {
+        this.refreshAuth();
+        return;
+      }
+      this.waitingForAuth = false;
+      if (this.connectedChannels.size > 0 && (!this.ws || !this.connected)) {
+        const firstChannel = this.connectedChannels.values().next().value;
+        if (firstChannel) {
+          this.reconnectAttempts = 0;
+          this.connect(firstChannel).catch(() => {
+          });
+        }
+      }
+      return;
+    }
+    this.waitingForAuth = this.connectedChannels.size > 0;
+    if (this.ws) {
+      const socket = this.ws;
+      this.stopHeartbeat();
+      this.ws = null;
+      this.connected = false;
+      this.authenticated = false;
+      try {
+        socket.close(1e3, "Signed out");
+      } catch {
+      }
+      return;
+    }
+    this.connected = false;
+    this.authenticated = false;
+  }
+  handleAuthenticationFailure(error) {
+    const authError = error instanceof EdgeBaseError ? error : new EdgeBaseError(500, "Database live authentication failed.");
+    this.waitingForAuth = authError.code === 401 && this.connectedChannels.size > 0;
+    this.stopHeartbeat();
+    this.connected = false;
+    this.authenticated = false;
+    if (this.ws) {
+      const socket = this.ws;
+      this.ws = null;
+      try {
+        socket.close(4001, authError.message);
+      } catch {
+      }
+    }
+  }
+  resyncFilters() {
+    for (const [channel] of this.channelFilters) {
+      const filters = this.channelFilters.get(channel) ?? [];
+      const orFilters = this.channelOrFilters.get(channel) ?? [];
+      if (filters.length > 0 || orFilters.length > 0) {
+        const msg = { type: "subscribe", channel };
+        if (filters.length > 0) msg.filters = filters;
+        if (orFilters.length > 0) msg.orFilters = orFilters;
+        this.sendRaw(msg);
+      }
+    }
+  }
+  scheduleReconnect(channel) {
+    const delay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    setTimeout(() => {
+      this.connect(channel).catch(() => {
+      });
+    }, Math.min(delay, 3e4));
+  }
+  buildWsUrl(channel) {
+    const wsUrl = this.baseUrl.replace(/\/$/, "").replace(/^http/, "ws");
+    return `${wsUrl}/api/db/subscribe?channel=${encodeURIComponent(channel)}`;
+  }
+  sendRaw(msg) {
+    if (this.ws && this.connected) this.ws.send(JSON.stringify(msg));
+  }
+  hasAuthContext() {
+    return Boolean(this.tokenManager.getCurrentUser() || this.tokenManager.getRefreshToken());
+  }
+  recoverAuthentication() {
+    if (this.authRecoveryPromise || !this.ws || !this.connected || !this.hasAuthContext()) {
+      return;
+    }
+    this.authenticated = false;
+    this.waitingForAuth = true;
+    this.authRecoveryPromise = this.authenticate().then(() => {
+      this.waitingForAuth = false;
+    }).catch((error) => {
+      this.handleAuthenticationFailure(error);
+      for (const handler of this.errorHandlers) {
+        handler({
+          code: "NOT_AUTHENTICATED",
+          message: "Database live authentication was lost and recovery failed."
+        });
+      }
+    }).finally(() => {
+      this.authRecoveryPromise = null;
+    });
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.connected) this.sendRaw({ type: "ping" });
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  handleContextChange() {
+    if (!this.ws || !this.connected) return;
+    if (this.connectedChannels.size === 0) return;
+    this.stopHeartbeat();
+    this.ws.close(1e3, "Context change");
+    this.ws = null;
+    this.connected = false;
+    this.authenticated = false;
+    this.reconnectAttempts = 0;
+    const firstChannel = this.connectedChannels.values().next().value;
+    if (firstChannel) this.connect(firstChannel).catch(() => {
+    });
+  }
+};
+function matchesClientFilter(data, filters) {
+  for (const [key, expected] of Object.entries(filters)) {
+    if (data[key] !== expected) return false;
+  }
+  return true;
+}
+function matchesDatabaseLiveChannel(channel, change, messageChannel) {
+  if (messageChannel) return channel === messageChannel;
+  const parts = channel.split(":");
+  if (parts[0] !== "dblive") return false;
+  if (parts.length === 2) return parts[1] === change.table;
+  if (parts.length === 3) return parts[2] === change.table;
+  if (parts.length === 4) {
+    if (parts[2] === change.table) return change.docId === parts[3];
+    return parts[3] === change.table;
+  }
+  return parts[3] === change.table && change.docId === parts[4];
+}
+function deepSet(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (value === null) {
+    delete current[lastKey];
+  } else {
+    current[lastKey] = value;
+  }
+}
+function generateRequestId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value ?? null));
+}
+function cloneRecord(value) {
+  return cloneValue(value);
+}
+var WS_CONNECTING = 0;
+var WS_OPEN = 1;
+var ROOM_EXPLICIT_LEAVE_CLOSE_CODE = 4005;
+var ROOM_EXPLICIT_LEAVE_REASON = "Client left room";
+var ROOM_EXPLICIT_LEAVE_CLOSE_DELAY_MS = 40;
+function isSocketOpenOrConnecting(socket) {
+  return !!socket && (socket.readyState === WS_OPEN || socket.readyState === WS_CONNECTING);
+}
+function closeSocketAfterLeave(socket, reason) {
+  globalThis.setTimeout(() => {
+    try {
+      socket.close(ROOM_EXPLICIT_LEAVE_CLOSE_CODE, reason);
+    } catch {
+    }
+  }, ROOM_EXPLICIT_LEAVE_CLOSE_DELAY_MS);
+}
+var RoomClient = class _RoomClient {
+  baseUrl;
+  tokenManager;
+  options;
+  /** Room namespace (e.g. 'game', 'chat') */
+  namespace;
+  /** Room instance ID within the namespace */
+  roomId;
+  // ─── State ───
+  _sharedState = {};
+  _sharedVersion = 0;
+  _playerState = {};
+  _playerVersion = 0;
+  _members = [];
+  _mediaMembers = [];
+  // ─── Connection ───
+  ws = null;
+  reconnectAttempts = 0;
+  connected = false;
+  authenticated = false;
+  joined = false;
+  currentUserId = null;
+  currentConnectionId = null;
+  connectionState = "idle";
+  reconnectInfo = null;
+  connectingPromise = null;
+  heartbeatTimer = null;
+  intentionallyLeft = false;
+  waitingForAuth = false;
+  joinRequested = false;
+  unsubAuthState = null;
+  // ─── Pending send() requests (requestId → { resolve, reject, timeout }) ───
+  pendingRequests = /* @__PURE__ */ new Map();
+  pendingSignalRequests = /* @__PURE__ */ new Map();
+  pendingAdminRequests = /* @__PURE__ */ new Map();
+  pendingMemberStateRequests = /* @__PURE__ */ new Map();
+  pendingMediaRequests = /* @__PURE__ */ new Map();
+  // ─── Subscriptions ───
+  sharedStateHandlers = [];
+  playerStateHandlers = [];
+  messageHandlers = /* @__PURE__ */ new Map();
+  // messageType → handlers
+  allMessageHandlers = [];
+  errorHandlers = [];
+  kickedHandlers = [];
+  memberSyncHandlers = [];
+  memberJoinHandlers = [];
+  memberLeaveHandlers = [];
+  memberStateHandlers = [];
+  signalHandlers = /* @__PURE__ */ new Map();
+  anySignalHandlers = [];
+  mediaTrackHandlers = [];
+  mediaTrackRemovedHandlers = [];
+  mediaStateHandlers = [];
+  mediaDeviceHandlers = [];
+  reconnectHandlers = [];
+  connectionStateHandlers = [];
+  state = {
+    getShared: () => this.getSharedState(),
+    getMine: () => this.getPlayerState(),
+    onSharedChange: (handler) => this.onSharedState(handler),
+    onMineChange: (handler) => this.onPlayerState(handler),
+    send: (actionType, payload) => this.send(actionType, payload)
+  };
+  meta = {
+    get: () => this.getMetadata()
+  };
+  signals = {
+    send: (event, payload, options) => this.sendSignal(event, payload, options),
+    sendTo: (memberId, event, payload) => this.sendSignal(event, payload, { memberId }),
+    on: (event, handler) => this.onSignal(event, handler),
+    onAny: (handler) => this.onAnySignal(handler)
+  };
+  members = {
+    list: () => cloneValue(this._members),
+    onSync: (handler) => this.onMembersSync(handler),
+    onJoin: (handler) => this.onMemberJoin(handler),
+    onLeave: (handler) => this.onMemberLeave(handler),
+    setState: (state) => this.sendMemberState(state),
+    clearState: () => this.clearMemberState(),
+    onStateChange: (handler) => this.onMemberStateChange(handler)
+  };
+  admin = {
+    kick: (memberId) => this.sendAdmin("kick", memberId),
+    mute: (memberId) => this.sendAdmin("mute", memberId),
+    block: (memberId) => this.sendAdmin("block", memberId),
+    setRole: (memberId, role) => this.sendAdmin("setRole", memberId, { role }),
+    disableVideo: (memberId) => this.sendAdmin("disableVideo", memberId),
+    stopScreenShare: (memberId) => this.sendAdmin("stopScreenShare", memberId)
+  };
+  media = {
+    list: () => cloneValue(this._mediaMembers),
+    audio: {
+      enable: (payload) => this.sendMedia("publish", "audio", payload),
+      disable: () => this.sendMedia("unpublish", "audio"),
+      setMuted: (muted) => this.sendMedia("mute", "audio", { muted })
+    },
+    video: {
+      enable: (payload) => this.sendMedia("publish", "video", payload),
+      disable: () => this.sendMedia("unpublish", "video"),
+      setMuted: (muted) => this.sendMedia("mute", "video", { muted })
+    },
+    screen: {
+      start: (payload) => this.sendMedia("publish", "screen", payload),
+      stop: () => this.sendMedia("unpublish", "screen")
+    },
+    devices: {
+      switch: (payload) => this.switchMediaDevices(payload)
+    },
+    onTrack: (handler) => this.onMediaTrack(handler),
+    onTrackRemoved: (handler) => this.onMediaTrackRemoved(handler),
+    onStateChange: (handler) => this.onMediaStateChange(handler),
+    onDeviceChange: (handler) => this.onMediaDeviceChange(handler)
+  };
+  session = {
+    onError: (handler) => this.onError(handler),
+    onKicked: (handler) => this.onKicked(handler),
+    onReconnect: (handler) => this.onReconnect(handler),
+    onConnectionStateChange: (handler) => this.onConnectionStateChange(handler)
+  };
+  constructor(baseUrl, namespace, roomId, tokenManager, options) {
+    this.baseUrl = baseUrl;
+    this.namespace = namespace;
+    this.roomId = roomId;
+    this.tokenManager = tokenManager;
+    this.options = {
+      autoReconnect: options?.autoReconnect ?? true,
+      maxReconnectAttempts: options?.maxReconnectAttempts ?? 10,
+      reconnectBaseDelay: options?.reconnectBaseDelay ?? 1e3,
+      sendTimeout: options?.sendTimeout ?? 1e4
+    };
+    this.unsubAuthState = this.tokenManager.onAuthStateChange((user) => {
+      this.handleAuthStateChange(user);
+    });
+  }
+  // ─── State Accessors ───
+  /** Get current shared state (read-only snapshot) */
+  getSharedState() {
+    return cloneRecord(this._sharedState);
+  }
+  /** Get current player state (read-only snapshot) */
+  getPlayerState() {
+    return cloneRecord(this._playerState);
+  }
+  // ─── Metadata (HTTP, no WebSocket needed) ───
+  /**
+   * Get room metadata without joining (HTTP GET).
+   * Returns developer-defined metadata set by room.setMetadata() on the server.
+   */
+  async getMetadata() {
+    return _RoomClient.getMetadata(this.baseUrl, this.namespace, this.roomId);
+  }
+  /**
+   * Static: Get room metadata without creating a RoomClient instance.
+   * Useful for lobby screens where you need room info before joining.
+   */
+  static async getMetadata(baseUrl, namespace, roomId) {
+    const url = `${baseUrl.replace(/\/$/, "")}/api/room/metadata?namespace=${encodeURIComponent(namespace)}&id=${encodeURIComponent(roomId)}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new EdgeBaseError(res.status, `Failed to get room metadata: ${res.statusText}`);
+    }
+    return res.json();
+  }
+  // ─── Connection Lifecycle ───
+  /** Connect to the room, authenticate, and join */
+  async join() {
+    this.intentionallyLeft = false;
+    this.joinRequested = true;
+    if (isSocketOpenOrConnecting(this.ws)) {
+      return this.connectingPromise ?? Promise.resolve();
+    }
+    this.setConnectionState(this.reconnectInfo ? "reconnecting" : "connecting");
+    return this.ensureConnection();
+  }
+  /** Leave the room and disconnect. Cleans up all pending requests. */
+  leave() {
+    this.intentionallyLeft = true;
+    this.joinRequested = false;
+    this.waitingForAuth = false;
+    this.stopHeartbeat();
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new EdgeBaseError(499, "Room left"));
+    }
+    this.pendingRequests.clear();
+    this.rejectPendingVoidRequests(this.pendingSignalRequests, new EdgeBaseError(499, "Room left"));
+    this.rejectPendingVoidRequests(this.pendingAdminRequests, new EdgeBaseError(499, "Room left"));
+    this.rejectPendingVoidRequests(this.pendingMemberStateRequests, new EdgeBaseError(499, "Room left"));
+    this.rejectPendingVoidRequests(this.pendingMediaRequests, new EdgeBaseError(499, "Room left"));
+    if (this.ws) {
+      const socket = this.ws;
+      this.sendRaw({ type: "leave" });
+      closeSocketAfterLeave(socket, ROOM_EXPLICIT_LEAVE_REASON);
+      this.ws = null;
+    }
+    this.connected = false;
+    this.authenticated = false;
+    this.joined = false;
+    this.connectingPromise = null;
+    this._sharedState = {};
+    this._sharedVersion = 0;
+    this._playerState = {};
+    this._playerVersion = 0;
+    this._members = [];
+    this._mediaMembers = [];
+    this.currentUserId = null;
+    this.currentConnectionId = null;
+    this.reconnectInfo = null;
+    this.setConnectionState("disconnected");
+  }
+  // ─── Actions ───
+  /**
+   * Send an action to the server.
+   * Returns a Promise that resolves with the action result from the server.
+   *
+   * @example
+   * const result = await room.send('SET_SCORE', { score: 42 });
+   */
+  async send(actionType, payload) {
+    if (!this.ws || !this.connected || !this.authenticated) {
+      throw new EdgeBaseError(400, "Not connected to room");
+    }
+    const requestId = generateRequestId();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new EdgeBaseError(408, `Action '${actionType}' timed out`));
+      }, this.options.sendTimeout);
+      this.pendingRequests.set(requestId, { resolve, reject, timeout });
+      this.sendRaw({
+        type: "send",
+        actionType,
+        payload: payload ?? {},
+        requestId
+      });
+    });
+  }
+  // ─── Subscriptions (v2 API) ───
+  /**
+   * Subscribe to shared state changes.
+   * Called on full sync and on each shared_delta.
+   *
+   * @returns Subscription with unsubscribe()
+   */
+  onSharedState(handler) {
+    this.sharedStateHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const idx = this.sharedStateHandlers.indexOf(handler);
+        if (idx >= 0) this.sharedStateHandlers.splice(idx, 1);
+      }
+    };
+  }
+  /**
+   * Subscribe to player state changes.
+   * Called on full sync and on each player_delta.
+   *
+   * @returns Subscription with unsubscribe()
+   */
+  onPlayerState(handler) {
+    this.playerStateHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const idx = this.playerStateHandlers.indexOf(handler);
+        if (idx >= 0) this.playerStateHandlers.splice(idx, 1);
+      }
+    };
+  }
+  /**
+   * Subscribe to messages of a specific type sent by room.sendMessage().
+   *
+   * @example
+   * room.onMessage('game_over', (data) => { console.log(data.winner); });
+   *
+   * @returns Subscription with unsubscribe()
+   */
+  onMessage(messageType, handler) {
+    if (!this.messageHandlers.has(messageType)) {
+      this.messageHandlers.set(messageType, []);
+    }
+    this.messageHandlers.get(messageType).push(handler);
+    return {
+      unsubscribe: () => {
+        const handlers = this.messageHandlers.get(messageType);
+        if (handlers) {
+          const idx = handlers.indexOf(handler);
+          if (idx >= 0) handlers.splice(idx, 1);
+        }
+      }
+    };
+  }
+  /**
+   * Subscribe to ALL messages regardless of type.
+   *
+   * @returns Subscription with unsubscribe()
+   */
+  onAnyMessage(handler) {
+    this.allMessageHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const idx = this.allMessageHandlers.indexOf(handler);
+        if (idx >= 0) this.allMessageHandlers.splice(idx, 1);
+      }
+    };
+  }
+  /** Subscribe to errors */
+  onError(handler) {
+    this.errorHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const idx = this.errorHandlers.indexOf(handler);
+        if (idx >= 0) this.errorHandlers.splice(idx, 1);
+      }
+    };
+  }
+  /** Subscribe to kick events */
+  onKicked(handler) {
+    this.kickedHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const idx = this.kickedHandlers.indexOf(handler);
+        if (idx >= 0) this.kickedHandlers.splice(idx, 1);
+      }
+    };
+  }
+  onSignal(event, handler) {
+    if (!this.signalHandlers.has(event)) {
+      this.signalHandlers.set(event, []);
+    }
+    this.signalHandlers.get(event).push(handler);
+    return {
+      unsubscribe: () => {
+        const handlers = this.signalHandlers.get(event);
+        if (!handlers) return;
+        const index = handlers.indexOf(handler);
+        if (index >= 0) handlers.splice(index, 1);
+      }
+    };
+  }
+  onAnySignal(handler) {
+    this.anySignalHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.anySignalHandlers.indexOf(handler);
+        if (index >= 0) this.anySignalHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMembersSync(handler) {
+    this.memberSyncHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.memberSyncHandlers.indexOf(handler);
+        if (index >= 0) this.memberSyncHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMemberJoin(handler) {
+    this.memberJoinHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.memberJoinHandlers.indexOf(handler);
+        if (index >= 0) this.memberJoinHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMemberLeave(handler) {
+    this.memberLeaveHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.memberLeaveHandlers.indexOf(handler);
+        if (index >= 0) this.memberLeaveHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMemberStateChange(handler) {
+    this.memberStateHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.memberStateHandlers.indexOf(handler);
+        if (index >= 0) this.memberStateHandlers.splice(index, 1);
+      }
+    };
+  }
+  onReconnect(handler) {
+    this.reconnectHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.reconnectHandlers.indexOf(handler);
+        if (index >= 0) this.reconnectHandlers.splice(index, 1);
+      }
+    };
+  }
+  onConnectionStateChange(handler) {
+    this.connectionStateHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.connectionStateHandlers.indexOf(handler);
+        if (index >= 0) this.connectionStateHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMediaTrack(handler) {
+    this.mediaTrackHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.mediaTrackHandlers.indexOf(handler);
+        if (index >= 0) this.mediaTrackHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMediaTrackRemoved(handler) {
+    this.mediaTrackRemovedHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.mediaTrackRemovedHandlers.indexOf(handler);
+        if (index >= 0) this.mediaTrackRemovedHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMediaStateChange(handler) {
+    this.mediaStateHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.mediaStateHandlers.indexOf(handler);
+        if (index >= 0) this.mediaStateHandlers.splice(index, 1);
+      }
+    };
+  }
+  onMediaDeviceChange(handler) {
+    this.mediaDeviceHandlers.push(handler);
+    return {
+      unsubscribe: () => {
+        const index = this.mediaDeviceHandlers.indexOf(handler);
+        if (index >= 0) this.mediaDeviceHandlers.splice(index, 1);
+      }
+    };
+  }
+  async sendSignal(event, payload, options) {
+    if (!this.ws || !this.connected || !this.authenticated) {
+      throw new EdgeBaseError(400, "Not connected to room");
+    }
+    const requestId = generateRequestId();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingSignalRequests.delete(requestId);
+        reject(new EdgeBaseError(408, `Signal '${event}' timed out`));
+      }, this.options.sendTimeout);
+      this.pendingSignalRequests.set(requestId, { resolve, reject, timeout });
+      this.sendRaw({
+        type: "signal",
+        event,
+        payload: payload ?? {},
+        includeSelf: options?.includeSelf === true,
+        memberId: options?.memberId,
+        requestId
+      });
+    });
+  }
+  async sendMemberState(state) {
+    return this.sendMemberStateRequest({
+      type: "member_state",
+      state
+    });
+  }
+  async clearMemberState() {
+    return this.sendMemberStateRequest({
+      type: "member_state_clear"
+    });
+  }
+  async sendMemberStateRequest(payload) {
+    if (!this.ws || !this.connected || !this.authenticated) {
+      throw new EdgeBaseError(400, "Not connected to room");
+    }
+    const requestId = generateRequestId();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingMemberStateRequests.delete(requestId);
+        reject(new EdgeBaseError(408, "Member state update timed out"));
+      }, this.options.sendTimeout);
+      this.pendingMemberStateRequests.set(requestId, { resolve, reject, timeout });
+      this.sendRaw({ ...payload, requestId });
+    });
+  }
+  async sendAdmin(operation, memberId, payload) {
+    if (!this.ws || !this.connected || !this.authenticated) {
+      throw new EdgeBaseError(400, "Not connected to room");
+    }
+    const requestId = generateRequestId();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingAdminRequests.delete(requestId);
+        reject(new EdgeBaseError(408, `Admin operation '${operation}' timed out`));
+      }, this.options.sendTimeout);
+      this.pendingAdminRequests.set(requestId, { resolve, reject, timeout });
+      this.sendRaw({
+        type: "admin",
+        operation,
+        memberId,
+        payload: payload ?? {},
+        requestId
+      });
+    });
+  }
+  async sendMedia(operation, kind, payload) {
+    if (!this.ws || !this.connected || !this.authenticated) {
+      throw new EdgeBaseError(400, "Not connected to room");
+    }
+    const requestId = generateRequestId();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingMediaRequests.delete(requestId);
+        reject(new EdgeBaseError(408, `Media operation '${operation}' timed out`));
+      }, this.options.sendTimeout);
+      this.pendingMediaRequests.set(requestId, { resolve, reject, timeout });
+      this.sendRaw({
+        type: "media",
+        operation,
+        kind,
+        payload: payload ?? {},
+        requestId
+      });
+    });
+  }
+  async switchMediaDevices(payload) {
+    const operations = [];
+    if (payload.audioInputId) {
+      operations.push(this.sendMedia("device", "audio", { deviceId: payload.audioInputId }));
+    }
+    if (payload.videoInputId) {
+      operations.push(this.sendMedia("device", "video", { deviceId: payload.videoInputId }));
+    }
+    if (payload.screenInputId) {
+      operations.push(this.sendMedia("device", "screen", { deviceId: payload.screenInputId }));
+    }
+    await Promise.all(operations);
+  }
+  // ─── Private: Connection ───
+  async establishConnection() {
+    return new Promise((resolve, reject) => {
+      const wsUrl = this.buildWsUrl();
+      const ws = new WebSocket(wsUrl);
+      this.ws = ws;
+      ws.onopen = () => {
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        this.authenticate().then(() => {
+          this.waitingForAuth = false;
+          resolve();
+        }).catch((error) => {
+          this.handleAuthenticationFailure(error);
+          reject(error);
+        });
+      };
+      ws.onmessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      ws.onclose = (event) => {
+        this.connected = false;
+        this.authenticated = false;
+        this.joined = false;
+        this.ws = null;
+        this.stopHeartbeat();
+        if (event.code === 4004 && this.connectionState !== "kicked") {
+          this.handleKicked();
+        }
+        if (!this.intentionallyLeft && !this.waitingForAuth && this.options.autoReconnect && this.reconnectAttempts < this.options.maxReconnectAttempts) {
+          this.scheduleReconnect();
+        } else if (!this.intentionallyLeft && this.connectionState !== "kicked" && this.connectionState !== "auth_lost") {
+          this.setConnectionState("disconnected");
+        }
+      };
+      ws.onerror = () => {
+        reject(new EdgeBaseError(500, "Room WebSocket connection error"));
+      };
+    });
+  }
+  ensureConnection() {
+    if (this.connectingPromise) {
+      return this.connectingPromise;
+    }
+    const nextPromise = this.establishConnection().finally(() => {
+      if (this.connectingPromise === nextPromise) {
+        this.connectingPromise = null;
+      }
+    });
+    this.connectingPromise = nextPromise;
+    return nextPromise;
+  }
+  async authenticate() {
+    const token = await this.tokenManager.getAccessToken(
+      (refreshToken) => refreshAccessToken(this.baseUrl, refreshToken)
+    );
+    if (!token) {
+      throw new EdgeBaseError(401, "No access token available. Sign in first.");
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new EdgeBaseError(401, "Room auth timeout"));
+      }, 1e4);
+      const originalOnMessage = this.ws?.onmessage;
+      if (this.ws) {
+        this.ws.onmessage = (event) => {
+          const msg = JSON.parse(event.data);
+          if (msg.type === "auth_success" || msg.type === "auth_refreshed") {
+            clearTimeout(timeout);
+            this.authenticated = true;
+            this.currentUserId = typeof msg.userId === "string" ? msg.userId : this.currentUserId;
+            this.currentConnectionId = typeof msg.connectionId === "string" ? msg.connectionId : this.currentConnectionId;
+            if (this.ws) this.ws.onmessage = originalOnMessage ?? null;
+            this.sendRaw({
+              type: "join",
+              lastSharedState: this._sharedState,
+              lastSharedVersion: this._sharedVersion,
+              lastPlayerState: this._playerState,
+              lastPlayerVersion: this._playerVersion
+            });
+            this.joined = true;
+            resolve();
+          } else if (msg.type === "error") {
+            clearTimeout(timeout);
+            reject(new EdgeBaseError(401, msg.message));
+          }
+        };
+      }
+      this.sendRaw({ type: "auth", token });
+    });
+  }
+  // ─── Private: Message Handling ───
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const type = msg.type;
+    switch (type) {
+      case "auth_success":
+      case "auth_refreshed":
+        this.handleAuthAck(msg);
+        break;
+      case "sync":
+        this.handleSync(msg);
+        break;
+      case "shared_delta":
+        this.handleSharedDelta(msg);
+        break;
+      case "player_delta":
+        this.handlePlayerDelta(msg);
+        break;
+      case "action_result":
+        this.handleActionResult(msg);
+        break;
+      case "action_error":
+        this.handleActionError(msg);
+        break;
+      case "message":
+        this.handleServerMessage(msg);
+        break;
+      case "signal":
+        this.handleSignalFrame(msg);
+        break;
+      case "signal_sent":
+        this.handleSignalSent(msg);
+        break;
+      case "signal_error":
+        this.handleSignalError(msg);
+        break;
+      case "members_sync":
+        this.handleMembersSync(msg);
+        break;
+      case "media_sync":
+        this.handleMediaSync(msg);
+        break;
+      case "member_join":
+        this.handleMemberJoinFrame(msg);
+        break;
+      case "member_leave":
+        this.handleMemberLeaveFrame(msg);
+        break;
+      case "member_state":
+        this.handleMemberStateFrame(msg);
+        break;
+      case "member_state_error":
+        this.handleMemberStateError(msg);
+        break;
+      case "media_track":
+        this.handleMediaTrackFrame(msg);
+        break;
+      case "media_track_removed":
+        this.handleMediaTrackRemovedFrame(msg);
+        break;
+      case "media_state":
+        this.handleMediaStateFrame(msg);
+        break;
+      case "media_device":
+        this.handleMediaDeviceFrame(msg);
+        break;
+      case "media_result":
+        this.handleMediaResult(msg);
+        break;
+      case "media_error":
+        this.handleMediaError(msg);
+        break;
+      case "admin_result":
+        this.handleAdminResult(msg);
+        break;
+      case "admin_error":
+        this.handleAdminError(msg);
+        break;
+      case "kicked":
+        this.handleKicked();
+        break;
+      case "error":
+        this.handleError(msg);
+        break;
+    }
+  }
+  handleSync(msg) {
+    this._sharedState = msg.sharedState;
+    this._sharedVersion = msg.sharedVersion;
+    this._playerState = msg.playerState;
+    this._playerVersion = msg.playerVersion;
+    const reconnectInfo = this.reconnectInfo;
+    this.reconnectInfo = null;
+    this.setConnectionState("connected");
+    const sharedSnapshot = cloneRecord(this._sharedState);
+    const playerSnapshot = cloneRecord(this._playerState);
+    for (const handler of this.sharedStateHandlers) {
+      handler(sharedSnapshot, cloneRecord(sharedSnapshot));
+    }
+    for (const handler of this.playerStateHandlers) {
+      handler(playerSnapshot, cloneRecord(playerSnapshot));
+    }
+    if (reconnectInfo) {
+      for (const handler of this.reconnectHandlers) {
+        handler(reconnectInfo);
+      }
+    }
+  }
+  handleSharedDelta(msg) {
+    const delta = msg.delta;
+    this._sharedVersion = msg.version;
+    for (const [path, value] of Object.entries(delta)) {
+      deepSet(this._sharedState, path, value);
+    }
+    const sharedSnapshot = cloneRecord(this._sharedState);
+    const deltaSnapshot = cloneRecord(delta);
+    for (const handler of this.sharedStateHandlers) {
+      handler(sharedSnapshot, deltaSnapshot);
+    }
+  }
+  handlePlayerDelta(msg) {
+    const delta = msg.delta;
+    this._playerVersion = msg.version;
+    for (const [path, value] of Object.entries(delta)) {
+      deepSet(this._playerState, path, value);
+    }
+    const playerSnapshot = cloneRecord(this._playerState);
+    const deltaSnapshot = cloneRecord(delta);
+    for (const handler of this.playerStateHandlers) {
+      handler(playerSnapshot, deltaSnapshot);
+    }
+  }
+  handleActionResult(msg) {
+    const requestId = msg.requestId;
+    const pending = this.pendingRequests.get(requestId);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(requestId);
+      pending.resolve(msg.result);
+    }
+  }
+  handleActionError(msg) {
+    const requestId = msg.requestId;
+    const pending = this.pendingRequests.get(requestId);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(requestId);
+      pending.reject(new EdgeBaseError(400, msg.message));
+    }
+  }
+  handleAuthAck(msg) {
+    this.currentUserId = typeof msg.userId === "string" ? msg.userId : this.currentUserId;
+    this.currentConnectionId = typeof msg.connectionId === "string" ? msg.connectionId : this.currentConnectionId;
+  }
+  handleServerMessage(msg) {
+    const messageType = msg.messageType;
+    const data = msg.data;
+    const handlers = this.messageHandlers.get(messageType);
+    if (handlers) {
+      for (const handler of handlers) handler(data);
+    }
+    for (const handler of this.allMessageHandlers) {
+      handler(messageType, data);
+    }
+  }
+  handleSignalFrame(msg) {
+    const event = typeof msg.event === "string" ? msg.event : "";
+    if (!event) return;
+    const meta = this.normalizeSignalMeta(msg.meta);
+    const payload = msg.payload;
+    const handlers = this.signalHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) handler(payload, meta);
+    }
+    for (const handler of this.anySignalHandlers) {
+      handler(event, payload, meta);
+    }
+  }
+  handleSignalSent(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingSignalRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingSignalRequests.delete(requestId);
+    pending.resolve();
+  }
+  handleSignalError(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingSignalRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingSignalRequests.delete(requestId);
+    pending.reject(new EdgeBaseError(400, msg.message || "Signal failed"));
+  }
+  handleMembersSync(msg) {
+    const members = this.normalizeMembers(msg.members);
+    this._members = members;
+    for (const member of members) {
+      this.syncMediaMemberInfo(member);
+    }
+    const snapshot = cloneValue(this._members);
+    for (const handler of this.memberSyncHandlers) {
+      handler(snapshot);
+    }
+  }
+  handleMediaSync(msg) {
+    this._mediaMembers = this.normalizeMediaMembers(msg.members);
+  }
+  handleMemberJoinFrame(msg) {
+    const member = this.normalizeMember(msg.member);
+    if (!member) return;
+    this.upsertMember(member);
+    this.syncMediaMemberInfo(member);
+    const snapshot = cloneValue(member);
+    for (const handler of this.memberJoinHandlers) {
+      handler(snapshot);
+    }
+  }
+  handleMemberLeaveFrame(msg) {
+    const member = this.normalizeMember(msg.member);
+    if (!member) return;
+    this.removeMember(member.memberId);
+    this.removeMediaMember(member.memberId);
+    const reason = this.normalizeLeaveReason(msg.reason);
+    const snapshot = cloneValue(member);
+    for (const handler of this.memberLeaveHandlers) {
+      handler(snapshot, reason);
+    }
+  }
+  handleMemberStateFrame(msg) {
+    const member = this.normalizeMember(msg.member);
+    const state = this.normalizeState(msg.state);
+    if (!member) return;
+    member.state = state;
+    this.upsertMember(member);
+    this.syncMediaMemberInfo(member);
+    const requestId = msg.requestId;
+    if (requestId && member.memberId === this.currentUserId) {
+      const pending = this.pendingMemberStateRequests.get(requestId);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingMemberStateRequests.delete(requestId);
+        pending.resolve();
+      }
+    }
+    const memberSnapshot = cloneValue(member);
+    const stateSnapshot = cloneRecord(state);
+    for (const handler of this.memberStateHandlers) {
+      handler(memberSnapshot, stateSnapshot);
+    }
+  }
+  handleMemberStateError(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingMemberStateRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingMemberStateRequests.delete(requestId);
+    pending.reject(new EdgeBaseError(400, msg.message || "Member state update failed"));
+  }
+  handleMediaTrackFrame(msg) {
+    const member = this.normalizeMember(msg.member);
+    const track = this.normalizeMediaTrack(msg.track);
+    if (!member || !track) return;
+    const mediaMember = this.ensureMediaMember(member);
+    this.upsertMediaTrack(mediaMember, track);
+    this.mergeMediaState(mediaMember, track.kind, {
+      published: true,
+      muted: track.muted,
+      trackId: track.trackId,
+      deviceId: track.deviceId,
+      publishedAt: track.publishedAt,
+      adminDisabled: track.adminDisabled
+    });
+    const memberSnapshot = cloneValue(mediaMember.member);
+    const trackSnapshot = cloneValue(track);
+    for (const handler of this.mediaTrackHandlers) {
+      handler(trackSnapshot, memberSnapshot);
+    }
+  }
+  handleMediaTrackRemovedFrame(msg) {
+    const member = this.normalizeMember(msg.member);
+    const track = this.normalizeMediaTrack(msg.track);
+    if (!member || !track) return;
+    const mediaMember = this.ensureMediaMember(member);
+    this.removeMediaTrack(mediaMember, track);
+    mediaMember.state = {
+      ...mediaMember.state,
+      [track.kind]: {
+        published: false,
+        muted: false,
+        adminDisabled: false
+      }
+    };
+    const memberSnapshot = cloneValue(mediaMember.member);
+    const trackSnapshot = cloneValue(track);
+    for (const handler of this.mediaTrackRemovedHandlers) {
+      handler(trackSnapshot, memberSnapshot);
+    }
+  }
+  handleMediaStateFrame(msg) {
+    const member = this.normalizeMember(msg.member);
+    if (!member) return;
+    const mediaMember = this.ensureMediaMember(member);
+    mediaMember.state = this.normalizeMediaState(msg.state);
+    const memberSnapshot = cloneValue(mediaMember.member);
+    const stateSnapshot = cloneValue(mediaMember.state);
+    for (const handler of this.mediaStateHandlers) {
+      handler(memberSnapshot, stateSnapshot);
+    }
+  }
+  handleMediaDeviceFrame(msg) {
+    const member = this.normalizeMember(msg.member);
+    const kind = this.normalizeMediaKind(msg.kind);
+    const deviceId = typeof msg.deviceId === "string" ? msg.deviceId : "";
+    if (!member || !kind || !deviceId) return;
+    const mediaMember = this.ensureMediaMember(member);
+    this.mergeMediaState(mediaMember, kind, { deviceId });
+    for (const track of mediaMember.tracks) {
+      if (track.kind === kind) {
+        track.deviceId = deviceId;
+      }
+    }
+    const memberSnapshot = cloneValue(mediaMember.member);
+    const change = { kind, deviceId };
+    for (const handler of this.mediaDeviceHandlers) {
+      handler(memberSnapshot, change);
+    }
+  }
+  handleMediaResult(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingMediaRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingMediaRequests.delete(requestId);
+    pending.resolve();
+  }
+  handleMediaError(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingMediaRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingMediaRequests.delete(requestId);
+    pending.reject(new EdgeBaseError(400, msg.message || "Media operation failed"));
+  }
+  handleAdminResult(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingAdminRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingAdminRequests.delete(requestId);
+    pending.resolve();
+  }
+  handleAdminError(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingAdminRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pendingAdminRequests.delete(requestId);
+    pending.reject(new EdgeBaseError(400, msg.message || "Admin operation failed"));
+  }
+  handleKicked() {
+    for (const handler of this.kickedHandlers) handler();
+    this.intentionallyLeft = true;
+    this.reconnectInfo = null;
+    this.setConnectionState("kicked");
+  }
+  handleError(msg) {
+    for (const handler of this.errorHandlers) {
+      handler({ code: msg.code, message: msg.message });
+    }
+  }
+  refreshAuth() {
+    const token = this.tokenManager.currentAccessToken;
+    if (!token || !this.ws || !this.connected) return;
+    this.sendRaw({ type: "auth", token });
+  }
+  handleAuthStateChange(user) {
+    if (user) {
+      if (this.ws && this.connected && this.authenticated) {
+        this.refreshAuth();
+        return;
+      }
+      this.waitingForAuth = false;
+      if (this.joinRequested && !this.connectingPromise && !isSocketOpenOrConnecting(this.ws)) {
+        this.reconnectAttempts = 0;
+        this.ensureConnection().catch(() => {
+        });
+      }
+      return;
+    }
+    this.waitingForAuth = this.joinRequested;
+    this.reconnectInfo = null;
+    this.setConnectionState("auth_lost");
+    if (this.ws) {
+      const socket = this.ws;
+      this.sendRaw({ type: "leave" });
+      this.stopHeartbeat();
+      this.ws = null;
+      this.connected = false;
+      this.authenticated = false;
+      this.joined = false;
+      this._mediaMembers = [];
+      this.currentUserId = null;
+      this.currentConnectionId = null;
+      try {
+        closeSocketAfterLeave(socket, "Signed out");
+      } catch {
+      }
+      return;
+    }
+    this.connected = false;
+    this.authenticated = false;
+    this.joined = false;
+    this._mediaMembers = [];
+  }
+  handleAuthenticationFailure(error) {
+    const authError = error instanceof EdgeBaseError ? error : new EdgeBaseError(500, "Room authentication failed.");
+    this.waitingForAuth = authError.code === 401 && this.joinRequested;
+    this.stopHeartbeat();
+    this.connected = false;
+    this.authenticated = false;
+    this.joined = false;
+    this.connectingPromise = null;
+    if (this.ws) {
+      const socket = this.ws;
+      this.ws = null;
+      try {
+        socket.close(4001, authError.message);
+      } catch {
+      }
+    }
+  }
+  normalizeMembers(value) {
+    if (!Array.isArray(value)) {
+      return [];
+    }
+    return value.map((member) => this.normalizeMember(member)).filter((member) => !!member);
+  }
+  normalizeMediaMembers(value) {
+    if (!Array.isArray(value)) {
+      return [];
+    }
+    return value.map((member) => this.normalizeMediaMember(member)).filter((member) => !!member);
+  }
+  normalizeMember(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return null;
+    }
+    const member = value;
+    if (typeof member.memberId !== "string" || typeof member.userId !== "string") {
+      return null;
+    }
+    return {
+      memberId: member.memberId,
+      userId: member.userId,
+      connectionId: typeof member.connectionId === "string" ? member.connectionId : void 0,
+      connectionCount: typeof member.connectionCount === "number" ? member.connectionCount : void 0,
+      role: typeof member.role === "string" ? member.role : void 0,
+      state: this.normalizeState(member.state)
+    };
+  }
+  normalizeState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return {};
+    }
+    return cloneRecord(value);
+  }
+  normalizeMediaMember(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return null;
+    }
+    const entry = value;
+    const member = this.normalizeMember(entry.member);
+    if (!member) {
+      return null;
+    }
+    return {
+      member,
+      state: this.normalizeMediaState(entry.state),
+      tracks: this.normalizeMediaTracks(entry.tracks)
+    };
+  }
+  normalizeMediaState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return {};
+    }
+    const state = value;
+    return {
+      audio: this.normalizeMediaKindState(state.audio),
+      video: this.normalizeMediaKindState(state.video),
+      screen: this.normalizeMediaKindState(state.screen)
+    };
+  }
+  normalizeMediaKindState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return void 0;
+    }
+    const state = value;
+    return {
+      published: state.published === true,
+      muted: state.muted === true,
+      trackId: typeof state.trackId === "string" ? state.trackId : void 0,
+      deviceId: typeof state.deviceId === "string" ? state.deviceId : void 0,
+      publishedAt: typeof state.publishedAt === "number" ? state.publishedAt : void 0,
+      adminDisabled: state.adminDisabled === true
+    };
+  }
+  normalizeMediaTracks(value) {
+    if (!Array.isArray(value)) {
+      return [];
+    }
+    return value.map((track) => this.normalizeMediaTrack(track)).filter((track) => !!track);
+  }
+  normalizeMediaTrack(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return null;
+    }
+    const track = value;
+    const kind = this.normalizeMediaKind(track.kind);
+    if (!kind) {
+      return null;
+    }
+    return {
+      kind,
+      trackId: typeof track.trackId === "string" ? track.trackId : void 0,
+      deviceId: typeof track.deviceId === "string" ? track.deviceId : void 0,
+      muted: track.muted === true,
+      publishedAt: typeof track.publishedAt === "number" ? track.publishedAt : void 0,
+      adminDisabled: track.adminDisabled === true
+    };
+  }
+  normalizeMediaKind(value) {
+    switch (value) {
+      case "audio":
+      case "video":
+      case "screen":
+        return value;
+      default:
+        return null;
+    }
+  }
+  normalizeSignalMeta(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return {};
+    }
+    const meta = value;
+    return {
+      memberId: typeof meta.memberId === "string" || meta.memberId === null ? meta.memberId : void 0,
+      userId: typeof meta.userId === "string" || meta.userId === null ? meta.userId : void 0,
+      connectionId: typeof meta.connectionId === "string" || meta.connectionId === null ? meta.connectionId : void 0,
+      sentAt: typeof meta.sentAt === "number" ? meta.sentAt : void 0,
+      serverSent: meta.serverSent === true
+    };
+  }
+  normalizeLeaveReason(value) {
+    switch (value) {
+      case "leave":
+      case "timeout":
+      case "kicked":
+        return value;
+      default:
+        return "leave";
+    }
+  }
+  upsertMember(member) {
+    const index = this._members.findIndex((entry) => entry.memberId === member.memberId);
+    if (index >= 0) {
+      this._members[index] = cloneValue(member);
+      return;
+    }
+    this._members.push(cloneValue(member));
+  }
+  removeMember(memberId) {
+    this._members = this._members.filter((member) => member.memberId !== memberId);
+  }
+  syncMediaMemberInfo(member) {
+    const mediaMember = this._mediaMembers.find((entry) => entry.member.memberId === member.memberId);
+    if (!mediaMember) {
+      return;
+    }
+    mediaMember.member = cloneValue(member);
+  }
+  ensureMediaMember(member) {
+    const existing = this._mediaMembers.find((entry) => entry.member.memberId === member.memberId);
+    if (existing) {
+      existing.member = cloneValue(member);
+      return existing;
+    }
+    const created = {
+      member: cloneValue(member),
+      state: {},
+      tracks: []
+    };
+    this._mediaMembers.push(created);
+    return created;
+  }
+  removeMediaMember(memberId) {
+    this._mediaMembers = this._mediaMembers.filter((member) => member.member.memberId !== memberId);
+  }
+  upsertMediaTrack(mediaMember, track) {
+    const index = mediaMember.tracks.findIndex(
+      (entry) => entry.kind === track.kind && entry.trackId === track.trackId
+    );
+    if (index >= 0) {
+      mediaMember.tracks[index] = cloneValue(track);
+      return;
+    }
+    mediaMember.tracks = mediaMember.tracks.filter((entry) => !(entry.kind === track.kind && !track.trackId)).concat(cloneValue(track));
+  }
+  removeMediaTrack(mediaMember, track) {
+    mediaMember.tracks = mediaMember.tracks.filter((entry) => {
+      if (track.trackId) {
+        return !(entry.kind === track.kind && entry.trackId === track.trackId);
+      }
+      return entry.kind !== track.kind;
+    });
+  }
+  mergeMediaState(mediaMember, kind, partial) {
+    const next = {
+      published: partial.published ?? mediaMember.state[kind]?.published ?? false,
+      muted: partial.muted ?? mediaMember.state[kind]?.muted ?? false,
+      trackId: partial.trackId ?? mediaMember.state[kind]?.trackId,
+      deviceId: partial.deviceId ?? mediaMember.state[kind]?.deviceId,
+      publishedAt: partial.publishedAt ?? mediaMember.state[kind]?.publishedAt,
+      adminDisabled: partial.adminDisabled ?? mediaMember.state[kind]?.adminDisabled
+    };
+    mediaMember.state = {
+      ...mediaMember.state,
+      [kind]: next
+    };
+  }
+  rejectPendingVoidRequests(pendingRequests, error) {
+    for (const [, pending] of pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    pendingRequests.clear();
+  }
+  setConnectionState(next) {
+    if (this.connectionState === next) {
+      return;
+    }
+    this.connectionState = next;
+    for (const handler of this.connectionStateHandlers) {
+      handler(next);
+    }
+  }
+  // ─── Private: Helpers ───
+  sendRaw(data) {
+    if (this.ws && this.connected) {
+      this.ws.send(JSON.stringify(data));
+      return;
+    }
+  }
+  buildWsUrl() {
+    const httpUrl = this.baseUrl.replace(/\/$/, "");
+    const wsUrl = httpUrl.replace(/^http/, "ws");
+    return `${wsUrl}/api/room?namespace=${encodeURIComponent(this.namespace)}&id=${encodeURIComponent(this.roomId)}`;
+  }
+  scheduleReconnect() {
+    const attempt = this.reconnectAttempts + 1;
+    const delay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    this.reconnectInfo = { attempt };
+    this.setConnectionState("reconnecting");
+    setTimeout(() => {
+      if (this.connectingPromise || !this.joinRequested || this.waitingForAuth || isSocketOpenOrConnecting(this.ws)) {
+        return;
+      }
+      this.ensureConnection().catch(() => {
+      });
+    }, Math.min(delay, 3e4));
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.connected) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+};
+var PushClient = class {
+  constructor(http, storage, core) {
+    this.http = http;
+    this.storage = storage;
+    this.core = core;
+  }
+  tokenProvider = null;
+  permissionProvider = null;
+  topicProvider = null;
+  messageListeners = [];
+  openedAppListeners = [];
+  /**
+   * Set the native token provider.
+   * Must be called before register() — typically in App.tsx or native bootstrapping.
+   *
+   * @example (Firebase Messaging)
+   * client.push.setTokenProvider(async () => ({
+   *   token: await messaging().getToken(),
+   *   platform: 'android',
+   * }));
+   *
+   * @example (APNs via native bridge)
+   * client.push.setTokenProvider(async () => ({
+   *   token: nativeBridge.getAPNsToken(),
+   *   platform: 'ios',
+   * }));
+   */
+  setTokenProvider(provider) {
+    this.tokenProvider = provider;
+  }
+  /**
+   * Set the native permission provider.
+   * Call this with your FCM / @notifee/react-native permission handler.
+   *
+   * @example (Firebase Messaging)
+   * client.push.setPermissionProvider({
+   *   getPermissionStatus: async () => {
+   *     const status = await messaging().hasPermission();
+   *     if (status === messaging.AuthorizationStatus.AUTHORIZED) return 'granted';
+   *     if (status === messaging.AuthorizationStatus.PROVISIONAL) return 'provisional';
+   *     if (status === messaging.AuthorizationStatus.DENIED) return 'denied';
+   *     return 'not-determined';
+   *   },
+   *   requestPermission: async () => {
+   *     const status = await messaging().requestPermission();
+   *     if (status === messaging.AuthorizationStatus.AUTHORIZED) return 'granted';
+   *     if (status === messaging.AuthorizationStatus.PROVISIONAL) return 'provisional';
+   *     return 'denied';
+   *   },
+   * });
+   */
+  setPermissionProvider(provider) {
+    this.permissionProvider = provider;
+  }
+  /**
+   * Get current push notification permission status.
+   * Uses custom provider if set via setPermissionProvider(), otherwise uses
+   * built-in platform defaults (PermissionsAndroid on Android, auto-grant on iOS).
+   */
+  async getPermissionStatus() {
+    if (this.permissionProvider) {
+      return this.permissionProvider.getPermissionStatus();
+    }
+    return this._defaultGetPermissionStatus();
+  }
+  /**
+   * Request push notification permission from the user.
+   * Uses custom provider if set via setPermissionProvider(), otherwise uses
+   * built-in platform defaults (PermissionsAndroid on Android, auto-grant on iOS).
+   */
+  async requestPermission() {
+    if (this.permissionProvider) {
+      return this.permissionProvider.requestPermission();
+    }
+    return this._defaultRequestPermission();
+  }
+  /**
+   * Register for push notifications.
+   * Zero-parameter — token is acquired via setTokenProvider().
+   * Token is cached; network request only fires if token changes.
+   */
+  async register(options) {
+    if (!this.tokenProvider) {
+      throw new Error(
+        "[EdgeBase] push.register(): No token provider set. Call client.push.setTokenProvider(async () => ({ token, platform })) first."
+      );
+    }
+    const permStatus = await this.requestPermission();
+    if (permStatus === "denied") return;
+    const { token, platform } = await this.tokenProvider();
+    const cachedToken = await this.storage.getItem(PUSH_TOKEN_CACHE_KEY);
+    if (cachedToken === token && !options?.metadata) return;
+    const deviceId = await this.getOrCreateDeviceId();
+    if (this.core) {
+      await this.core.pushRegister({
+        deviceId,
+        token,
+        platform,
+        metadata: options?.metadata
+      });
+    } else {
+      await this.http.post(ApiPaths.PUSH_REGISTER, {
+        deviceId,
+        token,
+        platform,
+        metadata: options?.metadata
+      });
+    }
+    await this.storage.setItem(PUSH_TOKEN_CACHE_KEY, token);
+  }
+  /**
+   * Unregister the current device from push notifications.
+   * Called automatically on signOut.
+   */
+  async unregister(deviceId) {
+    const id = deviceId ?? await this.getOrCreateDeviceId();
+    if (this.core) {
+      await this.core.pushUnregister({ deviceId: id });
+    } else {
+      await this.http.post(ApiPaths.PUSH_UNREGISTER, { deviceId: id });
+    }
+    await this.storage.removeItem(PUSH_TOKEN_CACHE_KEY);
+  }
+  /** Listen for push messages while app is in foreground. */
+  onMessage(callback) {
+    this.messageListeners.push(callback);
+    return () => {
+      this.messageListeners = this.messageListeners.filter((h) => h !== callback);
+    };
+  }
+  /** Listen for notification taps that opened the app. */
+  onMessageOpenedApp(callback) {
+    this.openedAppListeners.push(callback);
+    return () => {
+      this.openedAppListeners = this.openedAppListeners.filter((h) => h !== callback);
+    };
+  }
+  /**
+   * Dispatch a foreground message to all onMessage listeners.
+   * Call this from your native FCM/APNs foreground handler.
+   *
+   * @example (Firebase Messaging)
+   * messaging().onMessage(async (remoteMessage) => {
+   *   client.push._dispatchForegroundMessage({
+   *     title: remoteMessage.notification?.title,
+   *     body: remoteMessage.notification?.body,
+   *     data: remoteMessage.data,
+   *   });
+   * });
+   */
+  _dispatchForegroundMessage(message) {
+    for (const handler of this.messageListeners) {
+      handler(message);
+    }
+  }
+  /**
+   * Dispatch an opened-app notification to all onMessageOpenedApp listeners.
+   * Call this from your notification tap handler.
+   */
+  _dispatchOpenedAppMessage(message) {
+    for (const handler of this.openedAppListeners) {
+      handler(message);
+    }
+  }
+  /**
+   * Set topic subscription provider.
+   * Inject your Firebase RN SDK's topic subscription handlers.
+   *
+   * @example
+   * client.push.setTopicProvider({
+   *   subscribeTopic: (topic) => messaging().subscribeToTopic(topic),
+   *   unsubscribeTopic: (topic) => messaging().unsubscribeFromTopic(topic),
+   * });
+   */
+  setTopicProvider(provider) {
+    this.topicProvider = provider;
+  }
+  /**
+   * Subscribe to a push notification topic.
+   * Delegates to the topic provider set via setTopicProvider().
+   */
+  async subscribeTopic(topic) {
+    if (!this.topicProvider) {
+      throw new Error(
+        "[EdgeBase] push.subscribeTopic(): No topic provider set. Call client.push.setTopicProvider({ subscribeTopic, unsubscribeTopic }) first."
+      );
+    }
+    return this.topicProvider.subscribeTopic(topic);
+  }
+  /**
+   * Unsubscribe from a push notification topic.
+   * Delegates to the topic provider set via setTopicProvider().
+   */
+  async unsubscribeTopic(topic) {
+    if (!this.topicProvider) {
+      throw new Error(
+        "[EdgeBase] push.unsubscribeTopic(): No topic provider set. Call client.push.setTopicProvider({ subscribeTopic, unsubscribeTopic }) first."
+      );
+    }
+    return this.topicProvider.unsubscribeTopic(topic);
+  }
+  // ─── Built-in permission defaults ───
+  //
+  // Used when no custom permissionProvider is set.
+  // Android: uses react-native PermissionsAndroid for POST_NOTIFICATIONS (API 33+).
+  // iOS: returns 'granted' — Firebase messaging handles iOS permission internally
+  //       when getToken() is called. Use setPermissionProvider() for explicit control.
+  async _defaultGetPermissionStatus() {
+    try {
+      const { Platform, PermissionsAndroid } = __require("react-native");
+      if (Platform.OS === "android") {
+        if (Platform.Version < 33) return "granted";
+        const granted = await PermissionsAndroid.check(
+          "android.permission.POST_NOTIFICATIONS"
+        );
+        return granted ? "granted" : "not-determined";
+      }
+      return "granted";
+    } catch {
+      return "not-determined";
+    }
+  }
+  async _defaultRequestPermission() {
+    try {
+      const { Platform, PermissionsAndroid } = __require("react-native");
+      if (Platform.OS === "android") {
+        if (Platform.Version < 33) return "granted";
+        const result = await PermissionsAndroid.request(
+          "android.permission.POST_NOTIFICATIONS"
+        );
+        return result === PermissionsAndroid.RESULTS.GRANTED ? "granted" : "denied";
+      }
+      return "granted";
+    } catch {
+      return "not-determined";
+    }
+  }
+  // ─── Private helpers ───
+  async getOrCreateDeviceId() {
+    const existing = await this.storage.getItem(PUSH_DEVICE_ID_KEY);
+    if (existing) return existing;
+    const id = `rn-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    await this.storage.setItem(PUSH_DEVICE_ID_KEY, id);
+    return id;
+  }
+};
+
+// src/lifecycle.ts
+var LifecycleManager = class {
+  constructor(tokenManager, databaseLive, appState, doRefresh) {
+    this.tokenManager = tokenManager;
+    this.databaseLive = databaseLive;
+    this.appState = appState;
+    this.doRefresh = doRefresh;
+    this.previousState = appState.currentState;
+  }
+  subscription = null;
+  previousState;
+  /** Start listening to AppState changes. */
+  start() {
+    if (this.subscription) return;
+    this.subscription = this.appState.addEventListener("change", this.handleStateChange);
+  }
+  /** Stop listening to AppState changes and clean up. */
+  stop() {
+    this.subscription?.remove();
+    this.subscription = null;
+  }
+  handleStateChange = (nextState) => {
+    const prev = this.previousState;
+    this.previousState = nextState;
+    if (prev === nextState) return;
+    if (nextState === "active") {
+      this.onForeground();
+    } else if (nextState === "background" || nextState === "inactive") {
+      this.onBackground();
+    }
+  };
+  onForeground() {
+    if (this.doRefresh) {
+      void this.tokenManager.getAccessToken(this.doRefresh).catch(() => {
+      });
+    }
+    if (this.databaseLive?.reconnect) {
+      this.databaseLive.reconnect();
+    }
+  }
+  onBackground() {
+    this.databaseLive?.disconnect();
+  }
+};
+function useLifecycle({
+  tokenManager,
+  databaseLive,
+  appState,
+  doRefresh
+}) {
+  const { useEffect: useEffect2 } = __require("react");
+  useEffect2(() => {
+    const manager = new LifecycleManager(tokenManager, databaseLive, appState, doRefresh);
+    manager.start();
+    return () => manager.stop();
+  }, [tokenManager, databaseLive, appState, doRefresh]);
+}
+
+// src/analytics.ts
+var ClientAnalytics = class {
+  constructor(core) {
+    this.core = core;
+  }
+  async track(name, properties) {
+    await this.trackBatch([{ name, properties }]);
+  }
+  async trackBatch(events) {
+    if (events.length === 0) return;
+    await this.core.trackEvents({
+      events: events.map((event) => ({
+        name: event.name,
+        properties: event.properties,
+        timestamp: event.timestamp ?? Date.now()
+      }))
+    });
+  }
+  async flush() {
+  }
+  destroy() {
+  }
+};
+
+// src/match-filter.ts
+function matchesFilter(data, filters) {
+  const entries = Array.isArray(filters) && filters.length > 0 && Array.isArray(filters[0]) ? parseTupleFilters(filters) : parseFilters(filters);
+  return entries.every(
+    ({ field, operator, value }) => evaluateCondition(data[field], operator, value)
+  );
+}
+function parseFilters(filters) {
+  const entries = [];
+  for (const [key, value] of Object.entries(filters)) {
+    const dotIdx = key.lastIndexOf(".");
+    if (dotIdx > 0) {
+      const possibleOp = key.slice(dotIdx + 1);
+      if (isValidOperator(possibleOp)) {
+        entries.push({
+          field: key.slice(0, dotIdx),
+          operator: possibleOp,
+          value
+        });
+        continue;
+      }
+    }
+    entries.push({ field: key, operator: "==", value });
+  }
+  return entries;
+}
+function parseTupleFilters(tuples) {
+  return tuples.map(([field, operator, value]) => ({ field, operator, value }));
+}
+function isValidOperator(op) {
+  return ["==", "!=", "<", ">", "<=", ">=", "contains", "contains-any", "in", "not in"].includes(op);
+}
+function evaluateCondition(fieldValue, operator, expected) {
+  switch (operator) {
+    case "==":
+      return fieldValue === expected;
+    case "!=":
+      return fieldValue !== expected;
+    case "<":
+      return fieldValue < expected;
+    case ">":
+      return fieldValue > expected;
+    case "<=":
+      return fieldValue <= expected;
+    case ">=":
+      return fieldValue >= expected;
+    case "contains":
+      if (typeof fieldValue === "string") return fieldValue.includes(expected);
+      if (Array.isArray(fieldValue)) return fieldValue.includes(expected);
+      return false;
+    case "contains-any":
+      if (!Array.isArray(fieldValue) || !Array.isArray(expected)) return false;
+      return expected.some((value) => fieldValue.includes(value));
+    case "in":
+      if (Array.isArray(expected)) return expected.includes(fieldValue);
+      return false;
+    case "not in":
+      if (Array.isArray(expected)) return !expected.includes(fieldValue);
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/client.ts
+var ClientEdgeBase = class {
+  auth;
+  storage;
+  push;
+  functions;
+  analytics;
+  databaseLive;
+  /** @internal exposed for advanced use (e.g. setDatabaseLive, testing) */
+  _tokenManager;
+  /** @internal */
+  _httpClient;
+  lifecycleManager = null;
+  contextManager;
+  baseUrl;
+  core;
+  constructor(url, options) {
+    this.baseUrl = url.replace(/\/$/, "");
+    this._tokenManager = new TokenManager(this.baseUrl, options.storage);
+    this.contextManager = new ContextManager();
+    this._httpClient = new HttpClient({
+      baseUrl: this.baseUrl,
+      tokenManager: this._tokenManager,
+      contextManager: this.contextManager
+    });
+    this.core = new DefaultDbApi(new HttpClientAdapter(this._httpClient));
+    const corePublic = new DefaultDbApi(new PublicHttpClientAdapter(this._httpClient));
+    this.auth = new AuthClient(this._httpClient, this._tokenManager, this.core, corePublic, options.linking);
+    this.databaseLive = new DatabaseLiveClient(
+      this.baseUrl,
+      this._tokenManager,
+      options.databaseLive,
+      this.contextManager
+    );
+    this.storage = new StorageClient(this._httpClient, this.core);
+    this.push = new PushClient(this._httpClient, options.storage, this.core);
+    this.functions = new FunctionsClient(this._httpClient);
+    this.analytics = new ClientAnalytics(this.core);
+    const originalSignOut = this.auth.signOut.bind(this.auth);
+    const pushRef = this.push;
+    const storageRef = options.storage;
+    this.auth.signOut = async function() {
+      try {
+        const cached = await storageRef.getItem("edgebase:push-token-cache");
+        if (cached) await pushRef.unregister();
+      } catch {
+      }
+      return originalSignOut();
+    };
+    if (options.appState) {
+      const doRefresh = async (refreshToken) => {
+        return this._httpClient.postPublic(
+          ApiPaths.AUTH_REFRESH,
+          { refreshToken }
+        );
+      };
+      this.lifecycleManager = new LifecycleManager(
+        this._tokenManager,
+        {
+          disconnect: () => {
+            this.databaseLive.disconnect();
+          },
+          reconnect: () => {
+            this.databaseLive.reconnect?.();
+          }
+        },
+        options.appState,
+        doRefresh
+      );
+      this.lifecycleManager.start();
+    }
+  }
+  /**
+   * Select a DB block by namespace and optional instance ID (#133 §2).
+   *
+   * @example
+   * const posts = await client.db('shared').table('posts').where('status', '==', 'published').get();
+   * client.db('shared').table('posts').onSnapshot((change) => { ... });
+   */
+  db(namespace, instanceId) {
+    return new DbRef(this.core, namespace, instanceId, this.databaseLive, matchesFilter);
+  }
+  /**
+   * Get a Room client for ephemeral stateful real-time sessions.
+   *
+   * @param namespace - The room namespace (e.g. 'game', 'chat')
+   * @param roomId - The room instance ID within the namespace
+   * @param options - Connection options
+   *
+   * @example
+   * const room = client.room('game', 'room-123');
+   * await room.join();
+   * const result = await room.send('SET_SCORE', { score: 42 });
+   */
+  room(namespace, roomId, options) {
+    return new RoomClient(this.baseUrl, namespace, roomId, this._tokenManager, options);
+  }
+  /** Set legacy isolateBy context state. HTTP DB routing uses db(namespace, id). */
+  setContext(context) {
+    this.contextManager.setContext(context);
+  }
+  /** Set locale for auth email i18n and Accept-Language headers. */
+  setLocale(locale) {
+    this._httpClient.setLocale(locale);
+  }
+  /** Get the currently configured locale override. */
+  getLocale() {
+    return this._httpClient.getLocale();
+  }
+  /** Get the currently configured legacy isolateBy context state. */
+  getContext() {
+    return this.contextManager.getContext();
+  }
+  /** Clean up all connections and listeners. */
+  destroy() {
+    this.analytics.destroy();
+    this._tokenManager.destroy();
+    this.lifecycleManager?.stop();
+    this.databaseLive.disconnect();
+  }
+};
+function createClient(url, options) {
+  return new ClientEdgeBase(url, options);
+}
+function buildTurnstileHtml(siteKey, action, appearance, size) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<meta http-equiv="Content-Security-Policy" content="script-src 'unsafe-inline' https://challenges.cloudflare.com; style-src 'unsafe-inline';">
+<style>
+  html, body { margin: 0; padding: 0; background: transparent; overflow: hidden; }
+  #container { display: flex; align-items: center; justify-content: center; min-height: 65px; }
+</style>
+<script src="https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit" async defer></script>
+<script>
+  function sendToNative(data) {
+    try {
+      // Android/iOS via react-native-webview
+      if (window.ReactNativeWebView && window.ReactNativeWebView.postMessage) {
+        window.ReactNativeWebView.postMessage(JSON.stringify(data));
+        return;
+      }
+      // React Native Web / fallback
+      window.postMessage(JSON.stringify(data), '*');
+    } catch(e) {}
+  }
+
+  function onTurnstileLoad() {
+    turnstile.render('#container', {
+      sitekey: ${JSON.stringify(siteKey)},
+      action: ${JSON.stringify(action)},
+      appearance: ${JSON.stringify(appearance)},
+      size: ${JSON.stringify(size)},
+      callback: function(token) {
+        sendToNative({ type: 'captcha-token', token: token });
+      },
+      'error-callback': function(error) {
+        sendToNative({ type: 'captcha-error', error: String(error) });
+      },
+      'before-interactive-callback': function() {
+        sendToNative({ type: 'captcha-interactive' });
+      },
+      'after-interactive-callback': function() {
+        sendToNative({ type: 'captcha-done' });
+      },
+      'timeout-callback': function() {
+        sendToNative({ type: 'captcha-error', error: 'timeout' });
+      }
+    });
+  }
+
+  // Wait for Turnstile script to load
+  var checkInterval = setInterval(function() {
+    if (window.turnstile) {
+      clearInterval(checkInterval);
+      onTurnstileLoad();
+    }
+  }, 100);
+
+  // Safety timeout \u2014 give up after 15 seconds
+  setTimeout(function() {
+    clearInterval(checkInterval);
+    if (!window.turnstile) {
+      sendToNative({ type: 'captcha-error', error: 'script_load_failed' });
+    }
+  }, 15000);
+</script>
+</head>
+<body><div id="container"></div></body>
+</html>`;
+}
+function TurnstileWebView({
+  siteKey,
+  action = "auth",
+  onToken,
+  onError,
+  onInteractive,
+  appearance = "interaction-only",
+  size = "normal",
+  testID,
+  style,
+  WebViewComponent
+}) {
+  const html = buildTurnstileHtml(siteKey, action, appearance, size);
+  const handleMessage = useCallback(
+    (event) => {
+      try {
+        let raw = event.nativeEvent.data;
+        if (typeof raw !== "string") raw = JSON.stringify(raw);
+        const msg = JSON.parse(raw);
+        switch (msg.type) {
+          case "captcha-token":
+            if (msg.token) onToken(msg.token);
+            break;
+          case "captcha-error":
+            onError?.(msg.error ?? "unknown");
+            break;
+          case "captcha-interactive":
+            onInteractive?.();
+            break;
+          default:
+            break;
+        }
+      } catch {
+      }
+    },
+    [onToken, onError, onInteractive]
+  );
+  return React.createElement(WebViewComponent, {
+    source: { html },
+    style: style ?? { width: 300, height: 65, backgroundColor: "transparent" },
+    onMessage: handleMessage,
+    testID,
+    javaScriptEnabled: true,
+    originWhitelist: ["*"],
+    scrollEnabled: false,
+    showsHorizontalScrollIndicator: false,
+    showsVerticalScrollIndicator: false
+  });
+}
+var cachedSiteKeys = /* @__PURE__ */ new Map();
+var siteKeyFetchPromises = /* @__PURE__ */ new Map();
+async function fetchSiteKey(baseUrl) {
+  if (cachedSiteKeys.has(baseUrl)) return cachedSiteKeys.get(baseUrl) ?? null;
+  const inflight = siteKeyFetchPromises.get(baseUrl);
+  if (inflight) return inflight;
+  const nextPromise = (async () => {
+    try {
+      const res = await fetch(`${baseUrl}/api/config`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      const nextKey = data.captcha?.siteKey ?? null;
+      cachedSiteKeys.set(baseUrl, nextKey);
+      return nextKey;
+    } catch {
+      return null;
+    } finally {
+      siteKeyFetchPromises.delete(baseUrl);
+    }
+  })();
+  siteKeyFetchPromises.set(baseUrl, nextPromise);
+  return nextPromise;
+}
+function useTurnstile({
+  baseUrl,
+  action = "auth"
+}) {
+  const [token, setTokenState] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [needsInteraction, setNeedsInteraction] = useState(false);
+  const [siteKey, setSiteKey] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    setIsLoading(true);
+    fetchSiteKey(baseUrl).then((key) => {
+      if (!cancelled) {
+        setSiteKey(key);
+        if (!key) setIsLoading(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [baseUrl]);
+  const reset = useCallback(() => {
+    setTokenState(null);
+    setError(null);
+    setNeedsInteraction(false);
+    setIsLoading(true);
+  }, []);
+  const handleToken = useCallback((t) => {
+    setTokenState(t);
+    setIsLoading(false);
+    setError(null);
+    setNeedsInteraction(false);
+  }, []);
+  const handleError = useCallback((e) => {
+    setError(e);
+    setIsLoading(false);
+  }, []);
+  const handleInteractive = useCallback(() => {
+    setNeedsInteraction(true);
+  }, []);
+  const setToken = useCallback((t) => {
+    setTokenState(t);
+    setIsLoading(false);
+  }, []);
+  return {
+    token,
+    isLoading,
+    error,
+    needsInteraction,
+    siteKey,
+    reset,
+    setToken,
+    onToken: handleToken,
+    onError: handleError,
+    onInteractive: handleInteractive
+  };
+}
+function isPlatformWeb() {
+  return typeof document !== "undefined" && typeof navigator !== "undefined" && !("ReactNativeWebView" in window);
+}
+
+export { AuthClient, ClientAnalytics, ClientEdgeBase, DatabaseLiveClient, LifecycleManager, PushClient, RoomClient, TokenManager, TurnstileWebView, createClient, isPlatformWeb, matchesFilter, useLifecycle, useTurnstile };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map