@rebasepro/client 0.4.0 → 0.6.0

package/dist/index.umd.js

@@ -1,2428 +1,2162 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rebasepro/types"), require("@rebasepro/common"), require("@rebasepro/utils")) : typeof define === "function" && define.amd ? define(["exports", "@rebasepro/types", "@rebasepro/common", "@rebasepro/utils"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase Client"] = {}, global.types, global.common, global.utils));
-})(this, function(exports2, types, common, utils) {
-  "use strict";
-  function rebaseReviver(_key, value) {
-    if (value && typeof value === "object" && "__type" in value) {
-      const record = value;
-      switch (record.__type) {
-        case "date":
-        case "Date": {
-          if (typeof record.value !== "string") {
-            return value;
-          }
-          const date = new Date(record.value);
-          return isNaN(date.getTime()) ? null : date;
-        }
-        case "reference":
-        case "EntityReference":
-          return new types.EntityReference({
-            id: String(record.id),
-            path: record.path,
-            driver: record.driver,
-            databaseId: record.databaseId
-          });
-        case "relation":
-        case "EntityRelation":
-          return new types.EntityRelation(
-            record.id,
-            record.path,
-            record.data
-          );
-        case "GeoPoint":
-          return new types.GeoPoint(record.latitude, record.longitude);
-        case "Vector":
-          return new types.Vector(record.value);
-        default:
-          return value;
-      }
-    }
-    return value;
-  }
-  class RebaseApiError extends Error {
-    status;
-    code;
-    details;
-    constructor(status, message, code, details) {
-      super(message);
-      this.name = "RebaseApiError";
-      this.status = status;
-      this.code = code;
-      this.details = details;
-    }
-  }
-  const OP_MAP = {
-    "==": "eq",
-    "!=": "neq",
-    ">": "gt",
-    ">=": "gte",
-    "<": "lt",
-    "<=": "lte",
-    "not-in": "nin",
-    "array-contains": "cs",
-    "array-contains-any": "csa"
-  };
-  function normalizeWhereValue(value) {
-    if (value === null) return "eq.null";
-    if (typeof value === "boolean") return `eq.${value}`;
-    if (typeof value === "number") return String(value);
-    if (Array.isArray(value)) {
-      const conditions = Array.isArray(value[0]) ? value : [value];
-      const [rawOp, val] = conditions[0] || [];
-      if (rawOp) {
-        const op = OP_MAP[rawOp] ?? rawOp;
-        if (val === null) return `${op}.null`;
-        if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
-        return `${op}.${val}`;
-      }
-    }
-    return String(value);
-  }
-  function serializeLogicalCondition(cond) {
-    if ("type" in cond) {
-      const sub = cond.conditions.map(serializeLogicalCondition).join(",");
-      return `${cond.type}(${sub})`;
-    } else {
-      const op = OP_MAP[cond.operator] ?? cond.operator;
-      let formattedValue = cond.value;
-      if (Array.isArray(cond.value)) {
-        formattedValue = `(${cond.value.join(",")})`;
-      } else if (cond.value === null) {
-        formattedValue = "null";
-      }
-      return `${cond.column}.${op}.${formattedValue}`;
-    }
-  }
-  function buildQueryString(params) {
-    if (!params) return "";
-    const parts = [];
-    if (params.limit != null) parts.push(`limit=${params.limit}`);
-    if (params.offset != null) parts.push(`offset=${params.offset}`);
-    if (params.page != null) parts.push(`page=${params.page}`);
-    if (params.orderBy) {
-      parts.push(`orderBy=${encodeURIComponent(params.orderBy)}`);
-    }
-    if (params.searchString) {
-      parts.push(`searchString=${encodeURIComponent(params.searchString)}`);
-    }
-    if (params.include && params.include.length > 0) {
-      parts.push(`include=${encodeURIComponent(params.include.join(","))}`);
-    }
-    if (params.logical) {
-      const root = params.logical;
-      const serialized = root.conditions.map(serializeLogicalCondition).join(",");
-      parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
-    }
-    if (params.where) {
-      for (const [field, value] of Object.entries(params.where)) {
-        if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
-          for (const subVal of value) {
-            const normalized = normalizeWhereValue(subVal);
-            parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
-          }
-        } else {
-          const normalized = normalizeWhereValue(value);
-          parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
-        }
-      }
-    }
-    return parts.length > 0 ? "?" + parts.join("&") : "";
-  }
-  function createTransport(config) {
-    const fetchFn = config.fetch || globalThis.fetch;
-    const apiPath = config.apiPath || "/api";
-    let token = config.token;
-    let tokenGetter;
-    let onUnauthorizedHandler = config.onUnauthorized;
-    function getHeaders(activeToken, init) {
-      return {
-        "Content-Type": "application/json",
-        ...activeToken ? { Authorization: `Bearer ${activeToken}` } : {},
-        ...init?.headers || {}
-      };
-    }
-    async function request(path, init) {
-      const base = config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "";
-      const url = base + apiPath + path;
-      let activeToken = token;
-      if (tokenGetter) {
-        try {
-          const fetched = await tokenGetter();
-          if (fetched !== null && fetched !== void 0) {
-            activeToken = fetched;
-          }
-        } catch (e) {
-        }
-      }
-      const headers = getHeaders(activeToken, init);
-      if (init?.body instanceof FormData) {
-        delete headers["Content-Type"];
-      }
-      const res = await fetchFn(url, {
-        ...init,
-        headers
-      });
-      if (res.status === 204) return void 0;
-      const text = await res.text().catch(() => "");
-      let body = {};
-      if (text) {
-        try {
-          body = JSON.parse(text, rebaseReviver);
-        } catch (e) {
-        }
-      }
-      const getErrorField = (obj, field) => {
-        const err = obj?.error;
-        if (err && typeof err === "object" && err !== null && field in err) {
-          return err[field];
-        }
-        return obj?.[field];
-      };
-      if (res.status === 401 && onUnauthorizedHandler) {
-        const retried = await onUnauthorizedHandler();
-        if (retried) {
-          let retryToken = token;
-          if (tokenGetter) {
-            try {
-              const fetched = await tokenGetter();
-              if (fetched !== null && fetched !== void 0) {
-                retryToken = fetched;
-              }
-            } catch (e) {
-            }
-          }
-          const retryHeaders = getHeaders(retryToken, init);
-          const retryRes = await fetchFn(url, {
-            ...init,
-            headers: retryHeaders
-          });
-          if (retryRes.status === 204) return void 0;
-          const retryText = await retryRes.text().catch(() => "");
-          let retryBody = {};
-          if (retryText) {
-            try {
-              retryBody = JSON.parse(retryText, rebaseReviver);
-            } catch (e) {
-            }
-          }
-          if (!retryRes.ok) {
-            let fallbackMessage = retryRes.statusText;
-            if (retryRes.status === 404 && !fallbackMessage) {
-              const method = init?.method || "GET";
-              fallbackMessage = `Endpoint not found (${method} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
-            }
-            throw new RebaseApiError(
-              retryRes.status,
-              String(getErrorField(retryBody, "message") || fallbackMessage || `Request failed with status ${retryRes.status}`),
-              getErrorField(retryBody, "code"),
-              getErrorField(retryBody, "details")
-            );
-          }
-          return retryBody;
-        }
-      }
-      if (!res.ok) {
-        let fallbackMessage = res.statusText;
-        if (res.status === 404 && !fallbackMessage) {
-          const method = init?.method || "GET";
-          fallbackMessage = `Endpoint not found (${method} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
-        }
-        throw new RebaseApiError(
-          res.status,
-          String(getErrorField(body, "message") || fallbackMessage || `Request failed with status ${res.status}`),
-          getErrorField(body, "code"),
-          getErrorField(body, "details")
-        );
-      }
-      return body;
-    }
-    return {
-      request,
-      setToken(newToken) {
-        token = newToken || void 0;
-      },
-      setAuthTokenGetter(getter) {
-        tokenGetter = getter;
-      },
-      setOnUnauthorized(handler) {
-        onUnauthorizedHandler = handler;
-      },
-      get baseUrl() {
-        return config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "";
-      },
-      get apiPath() {
-        return apiPath;
-      },
-      get fetchFn() {
-        return fetchFn;
-      },
-      getHeaders: (init) => getHeaders(token, init),
-      resolveToken: async () => {
-        if (tokenGetter) {
-          try {
-            const fetched = await tokenGetter();
-            if (fetched !== null && fetched !== void 0) {
-              return fetched;
-            }
-          } catch (e) {
-          }
-        }
-        return token || null;
-      }
-    };
-  }
-  function createMemoryStorage() {
-    const store = {};
-    return {
-      getItem(key) {
-        return store[key] ?? null;
-      },
-      setItem(key, value) {
-        store[key] = value;
-      },
-      removeItem(key) {
-        delete store[key];
-      }
-    };
-  }
-  function detectStorage() {
-    try {
-      if (typeof localStorage !== "undefined") {
-        localStorage.setItem("__rebase_test__", "1");
-        localStorage.removeItem("__rebase_test__");
-        return localStorage;
-      }
-    } catch (e) {
-    }
-    return createMemoryStorage();
-  }
-  function createAuth(transport, options) {
-    const opts = options || {};
-    const storage = opts.storage || detectStorage();
-    const authPath = opts.authPath || "/auth";
-    const autoRefresh = opts.autoRefresh !== false;
-    const persistSession = opts.persistSession !== false;
-    const STORAGE_KEY = "rebase_auth";
-    const REFRESH_BUFFER_MS = 12e4;
-    let currentSession = null;
-    const listeners = /* @__PURE__ */ new Set();
-    let refreshTimeout = null;
-    function authUrl(endpoint) {
-      return transport.baseUrl + transport.apiPath + authPath + endpoint;
-    }
-    function getFetch() {
-      return transport.fetchFn || globalThis.fetch;
-    }
-    function throwApiError(status, body, statusText) {
-      throw new RebaseApiError(
-        status,
-        body?.error?.message || body?.message || statusText,
-        body?.error?.code || body?.code,
-        body?.error?.details || body?.details
-      );
-    }
-    function emit(event, session) {
-      for (const fn of listeners) {
-        try {
-          fn(event, session);
-        } catch (e) {
-        }
-      }
-    }
-    function saveSession(session) {
-      if (!persistSession) return;
-      try {
-        storage.setItem(STORAGE_KEY, JSON.stringify(session));
-      } catch (e) {
-      }
-    }
-    function clearStoredSession() {
-      try {
-        storage.removeItem(STORAGE_KEY);
-      } catch (e) {
-      }
-    }
-    function loadStoredSession() {
-      try {
-        const raw = storage.getItem(STORAGE_KEY);
-        if (raw) return JSON.parse(raw);
-      } catch (e) {
-      }
-      return null;
-    }
-    function scheduleRefresh(expiresAt) {
-      if (refreshTimeout) clearTimeout(refreshTimeout);
-      if (!autoRefresh) return;
-      const delay = expiresAt - REFRESH_BUFFER_MS - Date.now();
-      if (delay <= 0) {
-        refreshSession().catch(() => signOut());
-        return;
-      }
-      refreshTimeout = setTimeout(async () => {
-        try {
-          await refreshSession();
-        } catch (e) {
-          signOut();
-        }
-      }, delay);
-    }
-    function handleAuthResponse(data, event) {
-      const session = {
-        accessToken: data.tokens.accessToken,
-        refreshToken: data.tokens.refreshToken,
-        expiresAt: data.tokens.accessTokenExpiresAt,
-        user: data.user
-      };
-      currentSession = session;
-      saveSession(session);
-      transport.setToken(session.accessToken);
-      scheduleRefresh(session.expiresAt);
-      emit(event, session);
-      return session;
-    }
-    async function signInWithEmail(email, password) {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/login"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          email,
-          password
-        })
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      const session = handleAuthResponse(body, "SIGNED_IN");
-      return {
-        user: session.user,
-        accessToken: session.accessToken,
-        refreshToken: session.refreshToken
-      };
-    }
-    async function signUp(email, password, displayName) {
-      const fetchFn = getFetch();
-      const payload = {
-        email,
-        password
-      };
-      if (displayName !== void 0) payload.displayName = displayName;
-      const res = await fetchFn(authUrl("/register"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(payload)
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      const session = handleAuthResponse(body, "SIGNED_IN");
-      return {
-        user: session.user,
-        accessToken: session.accessToken,
-        refreshToken: session.refreshToken
-      };
-    }
-    async function signInWithGoogle(payload) {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/google"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(payload)
-      });
-      const responseBody = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, responseBody, res.statusText);
-      const session = handleAuthResponse(responseBody, "SIGNED_IN");
-      return { user: session.user, accessToken: session.accessToken, refreshToken: session.refreshToken };
-    }
-    async function signInWithLinkedin(code, redirectUri) {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/linkedin"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          code,
-          redirectUri
-        })
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      const session = handleAuthResponse(body, "SIGNED_IN");
-      return {
-        user: session.user,
-        accessToken: session.accessToken,
-        refreshToken: session.refreshToken
-      };
-    }
-    async function signInWithOAuth(providerId, payload) {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl(`/${providerId}`), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(payload)
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      const session = handleAuthResponse(body, "SIGNED_IN");
-      return {
-        user: session.user,
-        accessToken: session.accessToken,
-        refreshToken: session.refreshToken
-      };
-    }
-    async function signInWithGitHub(code, redirectUri) {
-      return signInWithOAuth("github", {
-        code,
-        redirectUri
-      });
-    }
-    async function signInWithMicrosoft(code, redirectUri) {
-      return signInWithOAuth("microsoft", {
-        code,
-        redirectUri
-      });
-    }
-    async function signInWithApple(code, redirectUri, user) {
-      return signInWithOAuth("apple", {
-        code,
-        redirectUri,
-        user
-      });
-    }
-    async function signInWithFacebook(code, redirectUri) {
-      return signInWithOAuth("facebook", {
-        code,
-        redirectUri
-      });
-    }
-    async function signInWithTwitter(code, redirectUri, codeVerifier) {
-      return signInWithOAuth("twitter", {
-        code,
-        redirectUri,
-        codeVerifier
-      });
-    }
-    async function signInWithDiscord(code, redirectUri) {
-      return signInWithOAuth("discord", {
-        code,
-        redirectUri
-      });
-    }
-    async function signInWithGitLab(code, redirectUri) {
-      return signInWithOAuth("gitlab", {
-        code,
-        redirectUri
-      });
-    }
-    async function signInWithBitbucket(code, redirectUri) {
-      return signInWithOAuth("bitbucket", {
-        code,
-        redirectUri
-      });
-    }
-    async function signInWithSlack(code, redirectUri) {
-      return signInWithOAuth("slack", {
-        code,
-        redirectUri
-      });
-    }
-    async function signInWithSpotify(code, redirectUri) {
-      return signInWithOAuth("spotify", {
-        code,
-        redirectUri
-      });
-    }
-    async function signOut() {
-      const fetchFn = getFetch();
-      try {
-        if (currentSession?.refreshToken) {
-          await fetchFn(authUrl("/logout"), {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ refreshToken: currentSession.refreshToken })
-          });
-        }
-      } catch (e) {
-      }
-      currentSession = null;
-      clearStoredSession();
-      if (refreshTimeout) {
-        clearTimeout(refreshTimeout);
-        refreshTimeout = null;
-      }
-      transport.setToken(null);
-      emit("SIGNED_OUT", null);
-    }
-    async function refreshSession() {
-      if (!currentSession?.refreshToken) {
-        throw new Error("No active session to refresh");
-      }
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/refresh"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ refreshToken: currentSession.refreshToken })
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      const session = {
-        accessToken: body.tokens.accessToken,
-        refreshToken: body.tokens.refreshToken,
-        expiresAt: body.tokens.accessTokenExpiresAt,
-        user: currentSession.user
-      };
-      currentSession = session;
-      saveSession(session);
-      transport.setToken(session.accessToken);
-      scheduleRefresh(session.expiresAt);
-      emit("TOKEN_REFRESHED", session);
-      return session;
-    }
-    async function getUser() {
-      const data = await transport.request(authPath + "/me", { method: "GET" });
-      return data.user;
-    }
-    async function updateUser(updates) {
-      const data = await transport.request(authPath + "/me", {
-        method: "PATCH",
-        body: JSON.stringify(updates)
-      });
-      if (currentSession) {
-        currentSession = {
-          ...currentSession,
-          user: data.user
-        };
-        saveSession(currentSession);
-        emit("USER_UPDATED", currentSession);
-      }
-      return data.user;
-    }
-    async function resetPasswordForEmail(email) {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/forgot-password"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ email })
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      return body;
-    }
-    async function resetPassword(token, password) {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/reset-password"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          token,
-          password
-        })
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      return body;
-    }
-    async function changePassword(oldPassword, newPassword) {
-      return transport.request(authPath + "/change-password", {
-        method: "POST",
-        body: JSON.stringify({
-          oldPassword,
-          newPassword
-        })
-      });
-    }
-    async function sendVerificationEmail() {
-      return transport.request(authPath + "/send-verification", {
-        method: "POST"
-      });
-    }
-    async function verifyEmail(token) {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/verify-email?token=" + encodeURIComponent(token)), {
-        method: "GET",
-        headers: { "Content-Type": "application/json" }
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      return body;
-    }
-    async function getSessions() {
-      const data = await transport.request(authPath + "/sessions", { method: "GET" });
-      return data.sessions;
-    }
-    async function revokeSession(sessionId) {
-      return transport.request(authPath + "/sessions/" + encodeURIComponent(sessionId), {
-        method: "DELETE"
-      });
-    }
-    async function revokeAllSessions() {
-      const result = await transport.request(authPath + "/sessions", {
-        method: "DELETE"
-      });
-      currentSession = null;
-      clearStoredSession();
-      if (refreshTimeout) {
-        clearTimeout(refreshTimeout);
-        refreshTimeout = null;
-      }
-      transport.setToken(null);
-      emit("SIGNED_OUT", null);
-      return result;
-    }
-    async function getAuthConfig() {
-      const fetchFn = getFetch();
-      const res = await fetchFn(authUrl("/config"), {
-        method: "GET",
-        headers: { "Content-Type": "application/json" }
-      });
-      const body = await res.json().catch(() => ({}));
-      if (!res.ok) throwApiError(res.status, body, res.statusText);
-      return body;
-    }
-    function getSession() {
-      return currentSession;
-    }
-    function onAuthStateChange(callback) {
-      listeners.add(callback);
-      return () => listeners.delete(callback);
-    }
-    if (persistSession) {
-      const stored = loadStoredSession();
-      if (stored && stored.accessToken && stored.refreshToken) {
-        if (stored.expiresAt > Date.now()) {
-          currentSession = stored;
-          transport.setToken(stored.accessToken);
-          scheduleRefresh(stored.expiresAt);
-        } else if (stored.refreshToken) {
-          currentSession = stored;
-          refreshSession().catch(() => {
-            currentSession = null;
-            clearStoredSession();
-            transport.setToken(null);
-          });
-        }
-      }
-    }
-    return {
-      signInWithEmail,
-      signUp,
-      signInWithGoogle,
-      signInWithLinkedin,
-      signInWithOAuth,
-      signInWithGitHub,
-      signInWithMicrosoft,
-      signInWithApple,
-      signInWithFacebook,
-      signInWithTwitter,
-      signInWithDiscord,
-      signInWithGitLab,
-      signInWithBitbucket,
-      signInWithSlack,
-      signInWithSpotify,
-      signOut,
-      refreshSession,
-      getUser,
-      updateUser,
-      resetPasswordForEmail,
-      resetPassword,
-      changePassword,
-      sendVerificationEmail,
-      verifyEmail,
-      getSessions,
-      revokeSession,
-      revokeAllSessions,
-      getAuthConfig,
-      getSession,
-      onAuthStateChange
-    };
-  }
-  function createCookieStorage(options = {}) {
-    const defaultOptions = {
-      path: "/",
-      sameSite: "Lax",
-      ...options
-    };
-    return {
-      getItem(key) {
-        if (typeof document === "undefined") return null;
-        const nameEQ = encodeURIComponent(key) + "=";
-        const ca = document.cookie.split(";");
-        for (let i = 0; i < ca.length; i++) {
-          let c = ca[i];
-          while (c.charAt(0) === " ") c = c.substring(1, c.length);
-          if (c.indexOf(nameEQ) === 0) {
-            return decodeURIComponent(c.substring(nameEQ.length, c.length));
-          }
-        }
-        return null;
-      },
-      setItem(key, value) {
-        if (typeof document === "undefined") return;
-        let cookieStr = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-        if (defaultOptions.path) {
-          cookieStr += `; path=${defaultOptions.path}`;
-        }
-        if (defaultOptions.domain) {
-          cookieStr += `; domain=${defaultOptions.domain}`;
-        }
-        if (defaultOptions.maxAge !== void 0) {
-          cookieStr += `; max-age=${defaultOptions.maxAge}`;
-        } else {
-          cookieStr += `; max-age=${365 * 24 * 60 * 60}`;
-        }
-        if (defaultOptions.secure) {
-          cookieStr += "; secure";
-        }
-        if (defaultOptions.sameSite) {
-          cookieStr += `; samesite=${defaultOptions.sameSite}`;
-        }
-        document.cookie = cookieStr;
-      },
-      removeItem(key) {
-        if (typeof document === "undefined") return;
-        let cookieStr = `${encodeURIComponent(key)}=; path=${defaultOptions.path || "/"}; max-age=-1`;
-        if (defaultOptions.domain) {
-          cookieStr += `; domain=${defaultOptions.domain}`;
-        }
-        document.cookie = cookieStr;
-      }
-    };
-  }
-  function createAdmin(transport, options) {
-    const opts = options || {};
-    const adminPath = opts.adminPath || "/admin";
-    async function listUsers() {
-      return transport.request(adminPath + "/users", { method: "GET" });
-    }
-    async function listUsersPaginated(options2) {
-      const params = new URLSearchParams();
-      if (options2?.limit !== void 0) params.set("limit", String(options2.limit));
-      if (options2?.offset !== void 0) params.set("offset", String(options2.offset));
-      if (options2?.search) params.set("search", options2.search);
-      if (options2?.orderBy) params.set("orderBy", options2.orderBy);
-      if (options2?.orderDir) params.set("orderDir", options2.orderDir);
-      const qs = params.toString();
-      return transport.request(
-        adminPath + "/users" + (qs ? "?" + qs : ""),
-        { method: "GET" }
-      );
-    }
-    async function getUser(userId) {
-      return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "GET" });
-    }
-    async function createUser(data) {
-      return transport.request(adminPath + "/users", {
-        method: "POST",
-        body: JSON.stringify(data)
-      });
-    }
-    async function updateUser(userId, data) {
-      return transport.request(adminPath + "/users/" + encodeURIComponent(userId), {
-        method: "PUT",
-        body: JSON.stringify(data)
-      });
-    }
-    async function deleteUser(userId) {
-      return transport.request(adminPath + "/users/" + encodeURIComponent(userId), {
-        method: "DELETE"
-      });
-    }
-    async function bootstrap() {
-      return transport.request(adminPath + "/bootstrap", {
-        method: "POST"
-      });
-    }
-    return {
-      listUsers,
-      listUsersPaginated,
-      getUser,
-      createUser,
-      updateUser,
-      deleteUser,
-      bootstrap
-    };
-  }
-  function createCron(transport, options) {
-    const cronPath = options?.cronPath || "/cron";
-    async function listJobs() {
-      return transport.request(cronPath, { method: "GET" });
-    }
-    async function getJob(jobId) {
-      return transport.request(
-        cronPath + "/" + encodeURIComponent(jobId),
-        { method: "GET" }
-      );
-    }
-    async function triggerJob(jobId) {
-      return transport.request(
-        cronPath + "/" + encodeURIComponent(jobId) + "/trigger",
-        { method: "POST" }
-      );
-    }
-    async function getJobLogs(jobId, options2) {
-      const params = new URLSearchParams();
-      if (options2?.limit !== void 0) params.set("limit", String(options2.limit));
-      const qs = params.toString();
-      return transport.request(
-        cronPath + "/" + encodeURIComponent(jobId) + "/logs" + (qs ? "?" + qs : ""),
-        { method: "GET" }
-      );
-    }
-    async function toggleJob(jobId, enabled) {
-      return transport.request(
-        cronPath + "/" + encodeURIComponent(jobId),
-        {
-          method: "PUT",
-          body: JSON.stringify({ enabled })
-        }
-      );
-    }
-    return {
-      listJobs,
-      getJob,
-      triggerJob,
-      getJobLogs,
-      toggleJob
-    };
-  }
-  function parseWhereFilter(where) {
-    if (!where) return void 0;
-    const filters = {};
-    const OP_TO_FILTER = {
-      "eq": "==",
-      "neq": "!=",
-      "gt": ">",
-      "gte": ">=",
-      "lt": "<",
-      "lte": "<=",
-      "==": "==",
-      "!=": "!=",
-      ">": ">",
-      ">=": ">=",
-      "<": "<",
-      "<=": "<=",
-      "in": "in",
-      "nin": "not-in",
-      "not-in": "not-in",
-      "cs": "array-contains",
-      "csa": "array-contains-any",
-      "array-contains": "array-contains",
-      "array-contains-any": "array-contains-any"
-    };
-    const parseSingle = (rawValue, fieldKey) => {
-      if (rawValue === null) return ["==", null];
-      if (typeof rawValue === "boolean") return ["==", rawValue];
-      if (typeof rawValue === "number") return ["==", rawValue];
-      if (Array.isArray(rawValue) && rawValue.length === 2 && typeof rawValue[0] === "string") {
-        const [rawOp, val] = rawValue;
-        return [OP_TO_FILTER[rawOp] ?? "==", val];
-      }
-      const value = String(rawValue);
-      const dotIndex = value.indexOf(".");
-      if (dotIndex > 0) {
-        const opStr = value.substring(0, dotIndex);
-        const valStr = value.substring(dotIndex + 1);
-        let op = "==";
-        let val = valStr;
-        switch (opStr) {
-          case "eq":
-            op = "==";
-            break;
-          case "neq":
-            op = "!=";
-            break;
-          case "gt":
-            op = ">";
-            break;
-          case "gte":
-            op = ">=";
-            break;
-          case "lt":
-            op = "<";
-            break;
-          case "lte":
-            op = "<=";
-            break;
-          case "in":
-            op = "in";
-            val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
-            break;
-          case "nin":
-            op = "not-in";
-            val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
-            break;
-          case "cs":
-            op = "array-contains";
-            break;
-          case "csa":
-            op = "array-contains-any";
-            val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
-            break;
-          default:
-            op = "==";
-            val = value;
-        }
-        if (val === "true") val = true;
-        else if (val === "false") val = false;
-        else if (val === "null") val = null;
-        else if (typeof val === "string" && /^[0-9]+(\.[0-9]+)?$/.test(val) && fieldKey !== "id" && !fieldKey.endsWith("_id")) val = Number(val);
-        return [op, val];
-      } else {
-        return ["==", value];
-      }
-    };
-    for (const [key, rawValue] of Object.entries(where)) {
-      if (Array.isArray(rawValue) && rawValue.length > 0 && Array.isArray(rawValue[0])) {
-        filters[key] = rawValue.map((r) => parseSingle(r, key));
-      } else {
-        filters[key] = parseSingle(rawValue, key);
-      }
-    }
-    return filters;
-  }
-  function rowToEntity(row, slug) {
-    return {
-      id: row.id,
-      path: slug,
-      values: row
-    };
-  }
-  function createCollectionClient(transport, slug, ws) {
-    const basePath = `/data/${slug}`;
-    const client = {
-      async find(params) {
-        const qs = buildQueryString(params);
-        const raw = await transport.request(basePath + qs, { method: "GET" });
-        return {
-          data: (raw.data || []).map((row) => rowToEntity(row, slug)),
-          meta: raw.meta
-        };
-      },
-      async findById(id) {
-        try {
-          const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
-          if (!raw) return void 0;
-          return rowToEntity(raw, slug);
-        } catch (err) {
-          if (err instanceof RebaseApiError && err.status === 404) {
-            return void 0;
-          }
-          throw err;
-        }
-      },
-      async create(data, id) {
-        const body = { ...data };
-        if (id !== void 0) {
-          body.id = id;
-        }
-        const raw = await transport.request(basePath, {
-          method: "POST",
-          body: JSON.stringify(body)
-        });
-        return rowToEntity(raw, slug);
-      },
-      async update(id, data) {
-        const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
-          method: "PUT",
-          body: JSON.stringify(data)
-        });
-        return rowToEntity(raw, slug);
-      },
-      async delete(id) {
-        return transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
-          method: "DELETE"
-        });
-      },
-      async count(params) {
-        const countParams = {
-          ...params,
-          limit: void 0,
-          offset: void 0
-        };
-        const qs = buildQueryString(countParams);
-        const raw = await transport.request(basePath + "/count" + qs, { method: "GET" });
-        return raw.count ?? 0;
-      },
-      // Fluent builder instantiation
-      where(columnOrCondition, operator, value) {
-        const builder = new common.QueryBuilder(client);
-        if (typeof columnOrCondition === "object") {
-          return builder.where(columnOrCondition);
-        }
-        return builder.where(columnOrCondition, operator, value);
-      },
-      orderBy(column, ascending) {
-        return new common.QueryBuilder(client).orderBy(column, ascending);
-      },
-      limit(count) {
-        return new common.QueryBuilder(client).limit(count);
-      },
-      offset(count) {
-        return new common.QueryBuilder(client).offset(count);
-      },
-      search(searchString) {
-        return new common.QueryBuilder(client).search(searchString);
-      },
-      include(...relations) {
-        return new common.QueryBuilder(client).include(...relations);
-      }
-    };
-    if (ws) {
-      client.listen = (params, onUpdate, onError) => {
-        return ws.listenCollection(
-          {
-            path: slug,
-            filter: parseWhereFilter(params?.where),
-            limit: params?.limit,
-            startAfter: params?.offset ? String(params.offset) : void 0,
-            orderBy: params?.orderBy?.split(":")[0],
-            order: params?.orderBy?.split(":")[1],
-            searchString: params?.searchString
-          },
-          (entities) => {
-            const requestedLimit = params?.limit || 20;
-            onUpdate({
-              data: entities,
-              meta: {
-                total: entities.length,
-                limit: requestedLimit,
-                offset: params?.offset || 0,
-                hasMore: entities.length >= requestedLimit
-              }
-            });
-          },
-          onError
-        );
-      };
-      client.listenById = (id, onUpdate, onError) => {
-        return ws.listenEntity(
-          {
-            path: slug,
-            entityId: String(id)
-          },
-          (entity) => {
-            if (entity) {
-              onUpdate(entity);
-            } else {
-              onUpdate(void 0);
-            }
-          },
-          onError
-        );
-      };
-    }
-    return client;
-  }
-  function createFunctionsClient(transport) {
-    return {
-      async invoke(name, payload, options) {
-        const method = options?.method ?? "POST";
-        const subPath = options?.path ? `/${options.path.replace(/^\//, "")}` : "";
-        const routePath = `/functions/${encodeURIComponent(name)}${subPath}`;
-        const init = { method };
-        if (payload !== void 0 && method !== "GET") {
-          init.body = JSON.stringify(payload);
-        }
-        if (options?.headers) {
-          init.headers = options.headers;
-        }
-        return transport.request(routePath, init);
-      }
-    };
-  }
-  function rehydrateEntity(entity) {
-    return entity;
-  }
-  function extractMessageError(message) {
-    const payload = message.payload;
-    const errPayload = payload?.error;
-    const errorMessage = typeof errPayload === "object" ? errPayload.message : payload?.message || (typeof errPayload === "string" ? errPayload : void 0) || message.error || "Unknown error";
-    const errorCode = typeof errPayload === "object" ? errPayload.code : payload?.code;
-    return {
-      errorMessage,
-      errorCode
-    };
-  }
-  class ApiError extends Error {
-    code;
-    error;
-    constructor(message, error, code) {
-      super(message);
-      this.name = "ApiError";
-      this.code = code;
-      this.error = error;
-    }
-  }
-  class RebaseWebSocketClient {
-    websocketUrl;
-    ws = null;
-    getAuthToken;
-    subscriptions = /* @__PURE__ */ new Map();
-    listeners = /* @__PURE__ */ new Map();
-    on(event, cb) {
-      if (!this.listeners.has(event)) {
-        this.listeners.set(event, /* @__PURE__ */ new Set());
-      }
-      this.listeners.get(event).add(cb);
-      return () => this.listeners.get(event).delete(cb);
-    }
-    emit(event, ...args) {
-      if (this.listeners.has(event)) {
-        this.listeners.get(event).forEach((cb) => cb(...args));
-      }
-    }
-    // New: Subscription deduplication management with optimizations
-    collectionSubscriptions = /* @__PURE__ */ new Map();
-    entitySubscriptions = /* @__PURE__ */ new Map();
-    // Maps to quickly find subscription by backend subscription ID
-    backendToCollectionKey = /* @__PURE__ */ new Map();
-    backendToEntityKey = /* @__PURE__ */ new Map();
-    pendingRequests = /* @__PURE__ */ new Map();
-    reconnectAttempts = 0;
-    maxReconnectAttempts = 5;
-    isConnected = false;
-    messageQueue = [];
-    reconnectTimeout = null;
-    isAuthenticated = false;
-    authPromise = null;
-    WebSocketConstructor;
-    onUnauthorized;
-    refreshInProgress = null;
-    constructor(config) {
-      this.websocketUrl = config.websocketUrl;
-      this.getAuthToken = config.getAuthToken;
-      this.onUnauthorized = config.onUnauthorized;
-      this.WebSocketConstructor = config.WebSocket || (typeof WebSocket !== "undefined" ? WebSocket : void 0);
-      if (!this.WebSocketConstructor) {
-        console.warn("WebSocket is not defined in this environment. Realtime subscriptions will not work unless you provide a WebSocket implementation in the config.");
-      } else {
-        this.initWebSocket();
-      }
-    }
-    /**
-     * Authenticate the WebSocket connection
-     */
-    async authenticate(token) {
-      return new Promise((resolve, reject) => {
-        const requestId = `auth_${Date.now()}`;
-        const timeout = setTimeout(() => {
-          this.pendingRequests.delete(requestId);
-          this.authPromise = null;
-          reject(new Error("Authentication timeout"));
-        }, 3e4);
-        this.pendingRequests.set(requestId, {
-          resolve: () => {
-            clearTimeout(timeout);
-            this.isAuthenticated = true;
-            resolve();
-          },
-          reject: (error) => {
-            clearTimeout(timeout);
-            reject(error);
-          }
-        });
-        const message = {
-          type: "AUTHENTICATE",
-          requestId,
-          payload: { token }
-        };
-        if (!this.isConnected || !this.ws) {
-          this.messageQueue.unshift(message);
-        } else {
-          this.ws.send(JSON.stringify(message));
-        }
-      });
-    }
-    /**
-     * Set the auth token getter function
-     */
-    setAuthTokenGetter(getAuthToken) {
-      this.getAuthToken = getAuthToken;
-      if (this.isConnected && !this.isAuthenticated && !this.authPromise) {
-        console.debug("WebSocket auto-authenticating after token getter set");
-        this.getAuthToken().then((token) => {
-          if (!this.ws) return;
-          if (token) {
-            this.authenticate(token).catch((e) => {
-              if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
-            });
-          }
-        }).catch((e) => {
-          if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
-        });
-      }
-    }
-    disconnect() {
-      this.isAuthenticated = false;
-      this.authPromise = null;
-      if (this.reconnectTimeout) {
-        clearTimeout(this.reconnectTimeout);
-        this.reconnectTimeout = null;
-      }
-      if (this.ws) {
-        this.ws.onclose = null;
-        this.ws.onerror = null;
-        this.ws.onopen = null;
-        this.ws.onmessage = null;
-        this.ws.close();
-        this.ws = null;
-      }
-    }
-    // Initialize WebSocket connection
-    initWebSocket() {
-      if (!this.WebSocketConstructor) return;
-      if (this.ws?.readyState === this.WebSocketConstructor.OPEN) return;
-      try {
-        this.ws = new this.WebSocketConstructor(this.websocketUrl);
-        this.ws.onopen = async () => {
-          console.debug("Connected to PostgreSQL backend");
-          const wasReconnect = this.reconnectAttempts > 0;
-          this.isConnected = true;
-          this.reconnectAttempts = 0;
-          if (this.getAuthToken && !this.isAuthenticated) {
-            try {
-              const token = await this.getAuthToken();
-              if (token) {
-                await this.authenticate(token);
-                console.debug("WebSocket auto-authenticated");
-              }
-            } catch (error) {
-              console.debug("WebSocket connected without auth:", error?.message || error);
-            }
-          }
-          this.emit(wasReconnect ? "reconnect" : "connect");
-          this.processMessageQueue();
-          if (wasReconnect) {
-            this.resubscribeAll();
-          }
-        };
-        this.ws.onmessage = (event) => {
-          try {
-            const message = JSON.parse(event.data, rebaseReviver);
-            this.handleWebSocketMessage(message);
-          } catch (error) {
-            console.error("Error parsing WebSocket message:", error);
-          }
-        };
-        this.ws.onclose = () => {
-          console.debug("Disconnected from PostgreSQL backend");
-          this.isConnected = false;
-          this.isAuthenticated = false;
-          this.authPromise = null;
-          this.emit("disconnect");
-          for (const [reqId, request] of this.pendingRequests.entries()) {
-            if (reqId.startsWith("auth_")) {
-              request.reject(new Error("Connection closed during authentication"));
-            } else if (request.message) {
-              request.message._queuedResolve = request.resolve;
-              request.message._queuedReject = request.reject;
-              this.messageQueue.push(request.message);
-            } else {
-              request.reject(new ApiError("Connection closed", "Connection closed"));
-            }
-            this.pendingRequests.delete(reqId);
-          }
-          this.attemptReconnect();
-        };
-        this.ws.onerror = (error) => {
-          console.error("WebSocket error:", error);
-          this.isConnected = false;
-          this.emit("error", error);
-        };
-      } catch (error) {
-        console.error("Failed to initialize WebSocket:", error);
-        this.attemptReconnect();
-      }
-    }
-    processMessageQueue() {
-      while (this.messageQueue.length > 0 && this.isConnected) {
-        const message = this.messageQueue.shift();
-        if (message) this.sendMessage(message);
-      }
-    }
-    attemptReconnect() {
-      if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-        console.error("Max reconnection attempts reached");
-        return;
-      }
-      this.reconnectAttempts++;
-      const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
-      console.debug(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
-      if (this.reconnectTimeout) {
-        clearTimeout(this.reconnectTimeout);
-      }
-      this.reconnectTimeout = setTimeout(() => {
-        this.reconnectTimeout = null;
-        this.initWebSocket();
-      }, delay);
-    }
-    isAuthError(message) {
-      if (message.type === "AUTH_ERROR") return true;
-      const { errorMessage, errorCode } = extractMessageError(message);
-      if (errorCode === "UNAUTHORIZED" || errorCode === "JWT_EXPIRED" || errorCode === "AUTH_ERROR") return true;
-      const lowerMessage = errorMessage.toLowerCase();
-      return lowerMessage.includes("unauthorized") || lowerMessage.includes("token expired") || lowerMessage.includes("token is expired") || lowerMessage.includes("invalid token") || lowerMessage.includes("session expired") || lowerMessage.includes("auth error");
-    }
-    async handleAuthFailure() {
-      if (this.refreshInProgress) {
-        return this.refreshInProgress;
-      }
-      this.refreshInProgress = (async () => {
-        this.isAuthenticated = false;
-        this.authPromise = null;
-        if (this.onUnauthorized) {
-          try {
-            const refreshed = await this.onUnauthorized();
-            if (refreshed && this.getAuthToken) {
-              const token = await this.getAuthToken();
-              if (token) {
-                await this.authenticate(token);
-                return true;
-              }
-            }
-          } catch (error) {
-            console.error("WebSocket auth refresh failed:", error);
-          }
-        }
-        return false;
-      })();
-      try {
-        return await this.refreshInProgress;
-      } finally {
-        this.refreshInProgress = null;
-      }
-    }
-    handleWebSocketMessage(message) {
-      const {
-        type,
-        requestId,
-        subscriptionId
-      } = message;
-      if (requestId && this.pendingRequests.has(requestId)) {
-        const pendingReq = this.pendingRequests.get(requestId);
-        if (type === "ERROR" || type === "AUTH_ERROR" || message.error) {
-          if (this.isAuthError(message)) {
-            this.pendingRequests.delete(requestId);
-            this.handleAuthFailure().then((refreshed) => {
-              if (refreshed && pendingReq.message) {
-                this.doSendMessage(pendingReq.message, pendingReq.resolve, pendingReq.reject).catch(pendingReq.reject);
-              } else {
-                const { errorMessage, errorCode } = extractMessageError(message);
-                pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
-              }
-            }).catch((err) => {
-              pendingReq.reject(err);
-            });
-          } else {
-            this.pendingRequests.delete(requestId);
-            const { errorMessage, errorCode } = extractMessageError(message);
-            pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
-          }
-        } else {
-          this.pendingRequests.delete(requestId);
-          pendingReq.resolve(message.payload || message);
-        }
-        return;
-      }
-      if (subscriptionId && type === "collection_update") {
-        const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
-        if (subscriptionKey) {
-          const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
-          if (collectionSub) {
-            const incomingEntities = (message.entities || []).map((e) => rehydrateEntity(e));
-            const entities = this.mergeEntities(collectionSub.latestData, incomingEntities);
-            collectionSub.latestData = entities;
-            collectionSub.lastUpdated = Date.now();
-            collectionSub.isInitialDataReceived = true;
-            collectionSub.callbacks.forEach((callback) => {
-              try {
-                callback.onUpdate(entities);
-              } catch (error) {
-                console.error("Error in collection subscription callback:", error);
-                if (callback.onError) {
-                  callback.onError(error instanceof Error ? error : new Error(String(error)));
-                }
-              }
-            });
-            return;
-          }
-        }
-      }
-      if (subscriptionId && type === "collection_entity_patch") {
-        const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
-        if (subscriptionKey) {
-          const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
-          if (collectionSub && collectionSub.isInitialDataReceived && collectionSub.latestData) {
-            const patchEntity = message.entity ? rehydrateEntity(message.entity) : message.entity;
-            const patchEntityId = message.entityId;
-            let updated;
-            if (patchEntity === null || patchEntity === void 0) {
-              updated = collectionSub.latestData.filter((e) => String(e.id) !== String(patchEntityId));
-            } else {
-              const idx = collectionSub.latestData.findIndex((e) => String(e.id) === String(patchEntity.id));
-              if (idx >= 0) {
-                updated = [...collectionSub.latestData];
-                updated[idx] = patchEntity;
-              } else {
-                updated = [patchEntity, ...collectionSub.latestData];
-              }
-            }
-            collectionSub.latestData = updated;
-            collectionSub.lastUpdated = Date.now();
-            collectionSub.callbacks.forEach((callback) => {
-              try {
-                callback.onUpdate(updated);
-              } catch (error) {
-                console.error("Error in collection patch callback:", error);
-                if (callback.onError) {
-                  callback.onError(error instanceof Error ? error : new Error(String(error)));
-                }
-              }
-            });
-            return;
-          }
-        }
-      }
-      if (subscriptionId && type === "entity_update") {
-        const subscriptionKey = this.backendToEntityKey.get(subscriptionId);
-        if (subscriptionKey) {
-          const entitySub = this.entitySubscriptions.get(subscriptionKey);
-          if (entitySub) {
-            const entity = message.entity ? rehydrateEntity(message.entity) : null;
-            entitySub.latestData = entity;
-            entitySub.lastUpdated = Date.now();
-            entitySub.isInitialDataReceived = true;
-            entitySub.callbacks.forEach((callback) => {
-              try {
-                callback.onUpdate(entity);
-              } catch (error) {
-                console.error("Error in entity subscription callback:", error);
-                if (callback.onError) {
-                  callback.onError(error instanceof Error ? error : new Error(String(error)));
-                }
-              }
-            });
-            return;
-          }
-        }
-      }
-      if (subscriptionId && (type === "ERROR" || message.error)) {
-        const collectionKey = this.backendToCollectionKey.get(subscriptionId);
-        if (collectionKey) {
-          const collectionSub = this.collectionSubscriptions.get(collectionKey);
-          if (collectionSub) {
-            if (this.isAuthError(message)) {
-              this.handleAuthFailure().then((refreshed) => {
-                if (refreshed) {
-                  const oldBackendId = collectionSub.backendSubscriptionId;
-                  const newBackendId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-                  collectionSub.backendSubscriptionId = newBackendId;
-                  this.backendToCollectionKey.delete(oldBackendId);
-                  this.backendToCollectionKey.set(newBackendId, collectionKey);
-                  this.sendMessage({
-                    type: "subscribe_collection",
-                    payload: {
-                      ...collectionSub.props,
-                      subscriptionId: newBackendId
-                    }
-                  }).catch((error2) => {
-                    console.error("[WS] Failed to re-subscribe collection after auth refresh:", collectionKey, error2);
-                    collectionSub.callbacks.forEach((callback) => {
-                      if (callback.onError) callback.onError(error2);
-                    });
-                  });
-                } else {
-                  const { errorMessage: errorMessage2, errorCode: errorCode2 } = extractMessageError(message);
-                  const error2 = new ApiError(errorMessage2, errorMessage2, errorCode2);
-                  collectionSub.callbacks.forEach((callback) => {
-                    if (callback.onError) callback.onError(error2);
-                  });
-                }
-              }).catch((err) => {
-                collectionSub.callbacks.forEach((callback) => {
-                  if (callback.onError) callback.onError(err);
-                });
-              });
-              return;
-            }
-            const { errorMessage, errorCode } = extractMessageError(message);
-            const error = new ApiError(errorMessage, errorMessage, errorCode);
-            collectionSub.callbacks.forEach((callback) => {
-              if (callback.onError) {
-                callback.onError(error);
-              }
-            });
-            return;
-          }
-        }
-        const entityKey = this.backendToEntityKey.get(subscriptionId);
-        if (entityKey) {
-          const entitySub = this.entitySubscriptions.get(entityKey);
-          if (entitySub) {
-            if (this.isAuthError(message)) {
-              this.handleAuthFailure().then((refreshed) => {
-                if (refreshed) {
-                  const oldBackendId = entitySub.backendSubscriptionId;
-                  const newBackendId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-                  entitySub.backendSubscriptionId = newBackendId;
-                  this.backendToEntityKey.delete(oldBackendId);
-                  this.backendToEntityKey.set(newBackendId, entityKey);
-                  this.sendMessage({
-                    type: "subscribe_entity",
-                    payload: {
-                      ...entitySub.props,
-                      subscriptionId: newBackendId
-                    }
-                  }).catch((error2) => {
-                    console.error("[WS] Failed to re-subscribe entity after auth refresh:", entityKey, error2);
-                    entitySub.callbacks.forEach((callback) => {
-                      if (callback.onError) callback.onError(error2);
-                    });
-                  });
-                } else {
-                  const { errorMessage: errorMessage2, errorCode: errorCode2 } = extractMessageError(message);
-                  const error2 = new ApiError(errorMessage2, errorMessage2, errorCode2);
-                  entitySub.callbacks.forEach((callback) => {
-                    if (callback.onError) callback.onError(error2);
-                  });
-                }
-              }).catch((err) => {
-                entitySub.callbacks.forEach((callback) => {
-                  if (callback.onError) callback.onError(err);
-                });
-              });
-              return;
-            }
-            const { errorMessage, errorCode } = extractMessageError(message);
-            const error = new ApiError(errorMessage, errorMessage, errorCode);
-            entitySub.callbacks.forEach((callback) => {
-              if (callback.onError) {
-                callback.onError(error);
-              }
-            });
-            return;
-          }
-        }
-      }
-      if (subscriptionId && this.subscriptions.has(subscriptionId)) {
-        const callback = this.subscriptions.get(subscriptionId);
-        if (!callback) {
-          throw new Error(`Subscription callback not found for subscriptionId: ${subscriptionId}`);
-        }
-        if (message.type === "ERROR" || message.error) {
-          if (callback.onError) {
-            const { errorMessage, errorCode } = extractMessageError(message);
-            callback.onError(new ApiError(errorMessage, errorMessage, errorCode));
-          }
-        } else {
-          callback.onUpdate(message);
-        }
-      }
-    }
-    async ensureAuthenticated(retryCount = 3) {
-      if (this.isAuthenticated || !this.getAuthToken) return;
-      if (this.authPromise) {
-        await this.authPromise;
-        return;
-      }
-      let lastError = null;
-      for (let attempt = 0; attempt < retryCount; attempt++) {
-        try {
-          const token = await this.getAuthToken();
-          if (!token) throw new Error("user not logged in");
-          this.authPromise = this.authenticate(token);
-          await this.authPromise;
-          this.authPromise = null;
-          console.debug("WebSocket authenticated on demand");
-          return;
-        } catch (error) {
-          this.authPromise = null;
-          lastError = error;
-          const errMsg = error instanceof Error ? error.message : String(error);
-          if (errMsg.includes("not logged in") || errMsg.includes("Session expired")) {
-            console.warn("WebSocket auth failed: user not logged in");
-            throw error;
-          }
-          if (errMsg.includes("still loading")) {
-            if (attempt < retryCount - 1) {
-              const delay = Math.min(500 * (attempt + 1), 2e3);
-              await new Promise((resolve) => setTimeout(resolve, delay));
-              continue;
-            }
-          }
-          if (attempt < retryCount - 1) {
-            const delay = Math.min(1e3 * (attempt + 1), 3e3);
-            console.debug(`WebSocket auth attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
-            await new Promise((resolve) => setTimeout(resolve, delay));
-          }
-        }
-      }
-      console.warn("WebSocket on-demand auth failed after retries:", lastError);
-      throw lastError;
-    }
-    /**
-     * Force re-authentication (call after token refresh)
-     */
-    async reauthenticate() {
-      if (!this.getAuthToken) return;
-      this.isAuthenticated = false;
-      try {
-        const token = await this.getAuthToken();
-        await this.authenticate(token);
-        console.debug("WebSocket reauthenticated successfully");
-      } catch (error) {
-        console.error("WebSocket reauthentication failed:", error);
-        throw error;
-      }
-    }
-    sendMessage(message) {
-      const queuedMsg = message;
-      if (queuedMsg._queuedResolve && queuedMsg._queuedReject) {
-        return this.doSendMessage(message, queuedMsg._queuedResolve, queuedMsg._queuedReject);
-      }
-      if (!this.isConnected || !this.ws) {
-        return new Promise((resolve, reject) => {
-          const queueable = message;
-          queueable._queuedResolve = resolve;
-          queueable._queuedReject = reject;
-          this.messageQueue.push(message);
-        });
-      }
-      return new Promise((resolve, reject) => {
-        this.doSendMessage(message, resolve, reject);
-      });
-    }
-    async doSendMessage(message, resolve, reject) {
-      if (message.type !== "AUTHENTICATE" && this.getAuthToken && !this.isAuthenticated) {
-        try {
-          await this.ensureAuthenticated();
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Authentication required";
-          reject(new ApiError(errorMessage, errorMessage));
-          return;
-        }
-      }
-      const requestId = message.requestId || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-      message.requestId = requestId;
-      if (!this.pendingRequests.has(requestId)) {
-        this.pendingRequests.set(requestId, {
-          resolve,
-          reject,
-          message
-        });
-      }
-      try {
-        this.ws.send(JSON.stringify(message));
-      } catch (error) {
-        this.pendingRequests.delete(requestId);
-        reject(new ApiError("Failed to send message", error instanceof Error ? error.message : "Unknown error"));
-      }
-    }
-    // Data source methods
-    async fetchCollection(props) {
-      const response = await this.sendMessage({
-        type: "FETCH_COLLECTION",
-        payload: props
-      });
-      return (response.entities || []).map((e) => rehydrateEntity(e));
-    }
-    async fetchEntity(props) {
-      const response = await this.sendMessage({
-        type: "FETCH_ENTITY",
-        payload: props
-      });
-      return response.entity ? rehydrateEntity(response.entity) : void 0;
-    }
-    async saveEntity(props) {
-      const response = await this.sendMessage({
-        type: "SAVE_ENTITY",
-        payload: props
-      });
-      return rehydrateEntity(response.entity);
-    }
-    async deleteEntity(props) {
-      await this.sendMessage({
-        type: "DELETE_ENTITY",
-        payload: props
-      });
-    }
-    async executeSql(sql, options) {
-      const response = await this.sendMessage({
-        type: "EXECUTE_SQL",
-        payload: {
-          sql,
-          options
-        }
-      });
-      return response.result || [];
-    }
-    async fetchAvailableDatabases() {
-      const response = await this.sendMessage({
-        type: "FETCH_DATABASES",
-        payload: {}
-      });
-      return response.databases || [];
-    }
-    async fetchAvailableRoles() {
-      const response = await this.sendMessage({
-        type: "FETCH_ROLES"
-      });
-      return response.roles || [];
-    }
-    async fetchCurrentDatabase() {
-      const response = await this.sendMessage({
-        type: "FETCH_CURRENT_DATABASE"
-      });
-      return response.database;
-    }
-    async checkUniqueField(path, name, value, entityId, collection) {
-      const response = await this.sendMessage({
-        type: "CHECK_UNIQUE_FIELD",
-        payload: {
-          path,
-          name,
-          value,
-          entityId,
-          collection
-        }
-      });
-      return response.isUnique;
-    }
-    async countEntities(props) {
-      const response = await this.sendMessage({
-        type: "COUNT_ENTITIES",
-        payload: props
-      });
-      return response.count;
-    }
-    async fetchUnmappedTables(mappedPaths) {
-      const response = await this.sendMessage({
-        type: "FETCH_UNMAPPED_TABLES",
-        payload: { mappedPaths }
-      });
-      return response.tables || [];
-    }
-    async fetchTableMetadata(tableName) {
-      const response = await this.sendMessage({
-        type: "FETCH_TABLE_METADATA",
-        payload: { tableName }
-      });
-      return response.metadata || {
-        columns: [],
-        foreignKeys: [],
-        junctions: [],
-        policies: []
-      };
-    }
-    async createBranch(name, options) {
-      const response = await this.sendMessage({
-        type: "CREATE_BRANCH",
-        payload: {
-          name,
-          options
-        }
-      });
-      return response.branch;
-    }
-    async deleteBranch(name) {
-      await this.sendMessage({
-        type: "DELETE_BRANCH",
-        payload: { name }
-      });
-    }
-    async listBranches() {
-      const response = await this.sendMessage({
-        type: "LIST_BRANCHES",
-        payload: {}
-      });
-      return response.branches || [];
-    }
-    /**
-     * Recursively compare two values for structural equality.
-     * Handles primitives, null, undefined, Date, RegExp, arrays, and plain objects.
-     */
-    deepEqual(a, b) {
-      if (a === b) return true;
-      if (a === null || b === null || a === void 0 || b === void 0) return false;
-      if (typeof a !== typeof b) return false;
-      if (typeof a !== "object") return false;
-      if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime();
-      }
-      if (a instanceof Date || b instanceof Date) return false;
-      if (a instanceof RegExp && b instanceof RegExp) {
-        return a.source === b.source && a.flags === b.flags;
-      }
-      if (a instanceof RegExp || b instanceof RegExp) return false;
-      const aIsArray = Array.isArray(a);
-      const bIsArray = Array.isArray(b);
-      if (aIsArray !== bIsArray) return false;
-      if (aIsArray && bIsArray) {
-        if (a.length !== b.length) return false;
-        for (let i = 0; i < a.length; i++) {
-          if (!this.deepEqual(a[i], b[i])) return false;
-        }
-        return true;
-      }
-      const aObj = a;
-      const bObj = b;
-      const aKeys = Object.keys(aObj);
-      const bKeys = Object.keys(bObj);
-      if (aKeys.length !== bKeys.length) return false;
-      for (const key of aKeys) {
-        if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
-        if (!this.deepEqual(aObj[key], bObj[key])) return false;
-      }
-      return true;
-    }
-    normalizeForComparison(val) {
-      if (!val) return val;
-      if (Array.isArray(val)) {
-        return val.map((item) => this.normalizeForComparison(item));
-      }
-      if (typeof val === "object") {
-        if (val instanceof Date) return val;
-        if (val instanceof RegExp) return val;
-        const obj = val;
-        if (obj.__type === "relation") {
-          const { data, ...rest } = obj;
-          return rest;
-        }
-        const result = {};
-        for (const [k, v] of Object.entries(obj)) {
-          result[k] = this.normalizeForComparison(v);
-        }
-        return result;
-      }
-      return val;
-    }
-    /**
-     * Merge incoming entities with cached data, preserving cached references
-     * for entities whose values haven't changed. This avoids unnecessary
-     * React re-renders when the server refetches all entities but most
-     * haven't actually changed.
-     */
-    mergeEntities(cached, incoming) {
-      if (!cached || cached.length === 0) return incoming;
-      const cachedById = /* @__PURE__ */ new Map();
-      for (const entity of cached) {
-        cachedById.set(entity.id, entity);
-      }
-      return incoming.map((incomingEntity) => {
-        const cachedEntity = cachedById.get(incomingEntity.id);
-        if (!cachedEntity) return incomingEntity;
-        if (cachedEntity.path === incomingEntity.path) {
-          const normCached = this.normalizeForComparison(cachedEntity.values);
-          const normIncoming = this.normalizeForComparison(incomingEntity.values);
-          if (this.deepEqual(normCached, normIncoming)) {
-            return cachedEntity;
-          } else {
-            const mismatches = {};
-            const allKeys = /* @__PURE__ */ new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
-            for (const key of allKeys) {
-              if (!this.deepEqual(normCached[key], normIncoming[key])) {
-                mismatches[key] = {
-                  cached: normCached[key],
-                  incoming: normIncoming[key]
-                };
-              }
-            }
-            console.debug(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:
-`, JSON.stringify(mismatches, null, 2));
-          }
-        }
-        return incomingEntity;
-      });
-    }
-    // Subscription methods
-    listenCollection(props, onUpdate, onError) {
-      const subscriptionKey = this.createCollectionSubscriptionKey(props);
-      const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-      const existingSubscription = this.collectionSubscriptions.get(subscriptionKey);
-      if (existingSubscription) {
-        const callbackMap2 = existingSubscription.callbacks;
-        callbackMap2.set(callbackId, {
-          onUpdate,
-          onError
-        });
-        if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) {
-          try {
-            onUpdate(existingSubscription.latestData);
-          } catch (error) {
-            console.error("Error in collection subscription callback:", error);
-            if (onError) {
-              onError(error instanceof Error ? error : new Error(String(error)));
-            }
-          }
-        }
-        return () => {
-          callbackMap2.delete(callbackId);
-          if (callbackMap2.size === 0) {
-            this.collectionSubscriptions.delete(subscriptionKey);
-            this.backendToCollectionKey.delete(existingSubscription.backendSubscriptionId);
-            if (this.isConnected && this.ws) {
-              this.sendMessage({
-                type: "unsubscribe",
-                payload: { subscriptionId: existingSubscription.backendSubscriptionId }
-              }).catch(console.error);
-            }
-          }
-        };
-      }
-      const backendSubscriptionId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-      const callbackMap = /* @__PURE__ */ new Map();
-      callbackMap.set(callbackId, {
-        onUpdate,
-        onError
-      });
-      this.collectionSubscriptions.set(subscriptionKey, {
-        backendSubscriptionId,
-        callbacks: callbackMap,
-        props
-      });
-      this.backendToCollectionKey.set(backendSubscriptionId, subscriptionKey);
-      this.sendMessage({
-        type: "subscribe_collection",
-        payload: {
-          ...props,
-          subscriptionId: backendSubscriptionId
-        }
-      }).catch((error) => {
-        if (onError) onError(error);
-      });
-      return () => {
-        const subscription = this.collectionSubscriptions.get(subscriptionKey);
-        if (subscription) {
-          const callbacks = subscription.callbacks;
-          callbacks.delete(callbackId);
-          if (callbacks.size === 0) {
-            this.collectionSubscriptions.delete(subscriptionKey);
-            this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
-            if (this.isConnected && this.ws) {
-              this.sendMessage({
-                type: "unsubscribe",
-                payload: { subscriptionId: subscription.backendSubscriptionId }
-              }).catch(console.error);
-            }
-          }
-        }
-      };
-    }
-    listenEntity(props, onUpdate, onError) {
-      const subscriptionKey = this.createEntitySubscriptionKey(props);
-      const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-      const existingSubscription = this.entitySubscriptions.get(subscriptionKey);
-      if (existingSubscription) {
-        const callbackMap2 = existingSubscription.callbacks;
-        callbackMap2.set(callbackId, {
-          onUpdate,
-          onError
-        });
-        if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) {
-          try {
-            onUpdate(existingSubscription.latestData);
-          } catch (error) {
-            console.error("Error in entity subscription callback:", error);
-            if (onError) {
-              onError(error instanceof Error ? error : new Error(String(error)));
-            }
-          }
-        }
-        return () => {
-          callbackMap2.delete(callbackId);
-          if (callbackMap2.size === 0) {
-            this.entitySubscriptions.delete(subscriptionKey);
-            this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
-            if (this.isConnected && this.ws) {
-              this.sendMessage({
-                type: "unsubscribe",
-                payload: { subscriptionId: existingSubscription.backendSubscriptionId }
-              }).catch(console.error);
-            }
-          }
-        };
-      }
-      const backendSubscriptionId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-      const callbackMap = /* @__PURE__ */ new Map();
-      callbackMap.set(callbackId, {
-        onUpdate,
-        onError
-      });
-      this.entitySubscriptions.set(subscriptionKey, {
-        backendSubscriptionId,
-        callbacks: callbackMap,
-        props
-      });
-      this.backendToEntityKey.set(backendSubscriptionId, subscriptionKey);
-      this.sendMessage({
-        type: "subscribe_entity",
-        payload: {
-          ...props,
-          subscriptionId: backendSubscriptionId
-        }
-      }).catch((error) => {
-        if (onError) onError(error);
-      });
-      return () => {
-        const subscription = this.entitySubscriptions.get(subscriptionKey);
-        if (subscription) {
-          const callbacks = subscription.callbacks;
-          callbacks.delete(callbackId);
-          if (callbacks.size === 0) {
-            this.entitySubscriptions.delete(subscriptionKey);
-            this.backendToEntityKey.delete(subscription.backendSubscriptionId);
-            if (this.isConnected && this.ws) {
-              this.sendMessage({
-                type: "unsubscribe",
-                payload: { subscriptionId: subscription.backendSubscriptionId }
-              }).catch(console.error);
-            }
-          }
-        }
-      };
-    }
-    /**
-     * Re-send all active subscriptions to the backend after a reconnect.
-     * The server wipes subscription state when a client disconnects, so
-     * we need to re-register everything to resume receiving updates.
-     */
-    resubscribeAll() {
-      console.debug(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.entitySubscriptions.size} entity(ies)`);
-      for (const [key, sub] of this.collectionSubscriptions.entries()) {
-        const oldBackendId = sub.backendSubscriptionId;
-        const newBackendId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-        sub.backendSubscriptionId = newBackendId;
-        this.backendToCollectionKey.delete(oldBackendId);
-        this.backendToCollectionKey.set(newBackendId, key);
-        this.sendMessage({
-          type: "subscribe_collection",
-          payload: {
-            ...sub.props,
-            subscriptionId: newBackendId
-          }
-        }).catch((error) => {
-          console.error("[WS] Failed to re-subscribe collection:", key, error);
-        });
-      }
-      for (const [key, sub] of this.entitySubscriptions.entries()) {
-        const oldBackendId = sub.backendSubscriptionId;
-        const newBackendId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-        sub.backendSubscriptionId = newBackendId;
-        this.backendToEntityKey.delete(oldBackendId);
-        this.backendToEntityKey.set(newBackendId, key);
-        this.sendMessage({
-          type: "subscribe_entity",
-          payload: {
-            ...sub.props,
-            subscriptionId: newBackendId
-          }
-        }).catch((error) => {
-          console.error("[WS] Failed to re-subscribe entity:", key, error);
-        });
-      }
-    }
-    createCollectionSubscriptionKey(props) {
-      const key = {
-        path: props.path,
-        filter: props.filter,
-        limit: props.limit,
-        startAfter: props.startAfter,
-        orderBy: props.orderBy,
-        order: props.order,
-        searchString: props.searchString,
-        collection: props.collection?.name
-      };
-      return JSON.stringify(key, (_, value) => {
-        if (value && typeof value === "object" && !Array.isArray(value)) {
-          return Object.keys(value).sort().reduce((sorted, k) => {
-            sorted[k] = value[k];
-            return sorted;
-          }, {});
-        }
-        return value;
-      });
-    }
-    createEntitySubscriptionKey(props) {
-      return `${props.path}|${props.entityId}`;
-    }
-  }
-  function createStorage(transport) {
-    const urlsCache = /* @__PURE__ */ new Map();
-    async function putObject({
-      file,
-      key,
-      metadata,
-      bucket
-    }) {
-      const formData = new FormData();
-      formData.append("file", file);
-      if (key) formData.append("key", key);
-      if (bucket) formData.append("bucket", bucket);
-      if (metadata) {
-        for (const [key2, value] of Object.entries(metadata)) {
-          if (value !== void 0 && value !== null) {
-            formData.append(
-              `metadata_${key2}`,
-              typeof value === "string" ? value : JSON.stringify(value)
-            );
-          }
-        }
-      }
-      const result = await transport.request("/storage/upload", {
-        method: "POST",
-        body: formData,
-        headers: {
-          // transport.request merges headers, so to prevent it setting application/json we can delete it
-          // in transport if body is FormData, or we can explicitly set it to an empty string.
-          // Let's rely on standard behaviour for now and adjust transport if it fails.
-        }
-      });
-      return result.data;
-    }
-    async function getSignedUrl(keyOrUrl, bucket) {
-      const cacheKey = bucket ? `${bucket}/${keyOrUrl}` : keyOrUrl;
-      const cached = urlsCache.get(cacheKey);
-      if (cached) return cached;
-      let filePath = keyOrUrl;
-      if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
-        filePath = filePath.substring(filePath.indexOf("://") + 3);
-      }
-      if (bucket && filePath && !filePath.startsWith(bucket)) {
-        filePath = `${bucket}/${filePath}`;
-      }
-      if (!filePath || filePath.trim() === "" || filePath === "/") {
-        return {
-          url: null,
-          fileNotFound: true
-        };
-      }
-      try {
-        const result = await transport.request(`/storage/metadata/${filePath}`);
-        const activeToken = await transport.resolveToken();
-        const tokenQuery = activeToken ? `?token=${activeToken}` : "";
-        const downloadConfig = {
-          url: `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`,
-          metadata: result.data
-        };
-        urlsCache.set(cacheKey, downloadConfig);
-        return downloadConfig;
-      } catch (e) {
-        if (e instanceof Error && "status" in e && e.status === 404) {
-          return {
-            url: null,
-            fileNotFound: true
-          };
-        }
-        throw e;
-      }
-    }
-    async function getObject(key, bucket) {
-      let filePath = key;
-      if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
-        filePath = filePath.substring(filePath.indexOf("://") + 3);
-      }
-      if (bucket && filePath && !filePath.startsWith(bucket)) {
-        filePath = `${bucket}/${filePath}`;
-      }
-      if (!filePath || filePath.trim() === "" || filePath === "/") {
-        return null;
-      }
-      const url = `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`;
-      const response = await transport.fetchFn(url, {
-        headers: transport.getHeaders ? transport.getHeaders() : {}
-      });
-      if (response.status === 404) return null;
-      if (!response.ok) throw new Error("Failed to get file");
-      const blob = await response.blob();
-      const fileName = filePath.split("/").pop() || "file";
-      return new File([blob], fileName, { type: blob.type });
-    }
-    async function deleteObject(key, bucket) {
-      let filePath = key;
-      if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) {
-        filePath = filePath.substring(filePath.indexOf("://") + 3);
-      }
-      if (bucket && filePath && !filePath.startsWith(bucket)) {
-        filePath = `${bucket}/${filePath}`;
-      }
-      if (!filePath || filePath.trim() === "" || filePath === "/") {
-        return;
-      }
-      try {
-        await transport.request(`/storage/file/${filePath}`, { method: "DELETE" });
-      } catch (e) {
-        if (!(e instanceof Error && "status" in e && e.status === 404)) throw e;
-      }
-      urlsCache.delete(bucket ? `${bucket}/${key}` : key);
-    }
-    async function listObjects(prefix, options) {
-      const params = new URLSearchParams();
-      if (prefix) params.set("prefix", prefix);
-      if (options?.bucket) params.set("bucket", options.bucket);
-      if (options?.maxResults) params.set("maxResults", String(options.maxResults));
-      if (options?.pageToken) params.set("pageToken", options.pageToken);
-      const result = await transport.request(`/storage/list?${params.toString()}`);
-      return result.data;
-    }
-    return {
-      putObject,
-      getSignedUrl,
-      getObject,
-      deleteObject,
-      listObjects
-    };
-  }
-  function deriveWebSocketUrl(baseUrl) {
-    if (typeof window !== "undefined") {
-      let absoluteUrl = "";
-      if (!baseUrl) {
-        absoluteUrl = window.location.origin;
-      } else if (/^https?:\/\//i.test(baseUrl) || /^wss?:\/\//i.test(baseUrl)) {
-        absoluteUrl = baseUrl;
-      } else {
-        try {
-          absoluteUrl = new URL(baseUrl, window.location.href).origin;
-        } catch {
-          absoluteUrl = window.location.origin;
-        }
-      }
-      const protocol = absoluteUrl.startsWith("https:") || absoluteUrl.startsWith("wss:") ? "wss:" : "ws:";
-      return absoluteUrl.replace(/^https?:\/\//i, `${protocol}//`).replace(/^wss?:\/\//i, `${protocol}//`).replace(/\/$/, "");
-    }
-    if (!baseUrl) return "";
-    if (!/^https?:\/\//i.test(baseUrl) && !/^wss?:\/\//i.test(baseUrl)) {
-      return "";
-    }
-    return baseUrl.replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://").replace(/\/$/, "");
-  }
-  function createRebaseClient(options) {
-    const transport = createTransport(options);
-    const auth = createAuth(transport, options.auth);
-    const admin = createAdmin(transport, options.admin);
-    const cron = createCron(transport, options.cron);
-    const storage = createStorage(transport);
-    const functions = createFunctionsClient(transport);
-    const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
-    let ws;
-    if (resolvedWsUrl) {
-      const wsOnUnauthorized = options.onUnauthorized || (async () => {
-        try {
-          await auth.refreshSession();
-          return true;
-        } catch (e) {
-          return false;
-        }
-      });
-      ws = new RebaseWebSocketClient({
-        websocketUrl: resolvedWsUrl,
-        getAuthToken: async () => {
-          let session = auth.getSession();
-          if (session && session.expiresAt <= Date.now() + 1e4) {
-            try {
-              session = await auth.refreshSession();
-            } catch (e) {
-            }
-          }
-          return session?.accessToken || options.token || "";
-        },
-        onUnauthorized: wsOnUnauthorized
-      });
-      auth.onAuthStateChange((event, session) => {
-        if (!ws) return;
-        if (event === "SIGNED_OUT") {
-          ws.disconnect();
-        } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-          if (session?.accessToken) {
-            ws.authenticate(session.accessToken).catch(console.warn);
-          }
-        }
-      });
-    }
-    if (!options.onUnauthorized) {
-      transport.setOnUnauthorized(async () => {
-        try {
-          await auth.refreshSession();
-          return true;
-        } catch (e) {
-          return false;
-        }
-      });
-    }
-    const collectionClients = /* @__PURE__ */ new Map();
-    function collection(slug) {
-      if (!collectionClients.has(slug)) {
-        collectionClients.set(slug, createCollectionClient(transport, slug, ws));
-      }
-      return collectionClients.get(slug);
-    }
-    const dataTarget = { collection };
-    const dataProxy = new Proxy(dataTarget, {
-      get(_target, prop) {
-        if (prop === "collection") {
-          return collection;
-        }
-        if (typeof prop === "symbol") return void 0;
-        if (typeof prop === "string" && prop !== "then" && prop !== "toJSON" && prop !== "$$typeof") {
-          const slug = utils.toSnakeCase(prop);
-          return collection(slug);
-        }
-        return void 0;
-      }
-    });
-    const target = {
-      auth,
-      admin,
-      cron,
-      functions,
-      storage,
-      ws,
-      setToken: transport.setToken,
-      setAuthTokenGetter: transport.setAuthTokenGetter,
-      setOnUnauthorized: transport.setOnUnauthorized,
-      resolveToken: transport.resolveToken,
-      baseUrl: transport.baseUrl,
-      collection,
-      call: async (endpoint, payload) => {
-        const prefix = endpoint.startsWith("/") ? "" : "/";
-        const res = await transport.request(`${prefix}${endpoint}`, {
-          method: "POST",
-          body: payload ? JSON.stringify(payload) : void 0
-        });
-        return res.data ?? res;
-      },
-      data: dataProxy,
-      email: void 0
-    };
-    return target;
-  }
-  Object.defineProperty(exports2, "QueryBuilder", {
-    enumerable: true,
-    get: () => common.QueryBuilder
-  });
-  Object.defineProperty(exports2, "and", {
-    enumerable: true,
-    get: () => common.and
-  });
-  Object.defineProperty(exports2, "cond", {
-    enumerable: true,
-    get: () => common.cond
-  });
-  Object.defineProperty(exports2, "or", {
-    enumerable: true,
-    get: () => common.or
-  });
-  exports2.ApiError = ApiError;
-  exports2.RebaseApiError = RebaseApiError;
-  exports2.RebaseWebSocketClient = RebaseWebSocketClient;
-  exports2.buildQueryString = buildQueryString;
-  exports2.createAdmin = createAdmin;
-  exports2.createAuth = createAuth;
-  exports2.createCollectionClient = createCollectionClient;
-  exports2.createCookieStorage = createCookieStorage;
-  exports2.createCron = createCron;
-  exports2.createFunctionsClient = createFunctionsClient;
-  exports2.createMemoryStorage = createMemoryStorage;
-  exports2.createRebaseClient = createRebaseClient;
-  exports2.createStorage = createStorage;
-  exports2.createTransport = createTransport;
-  exports2.rebaseReviver = rebaseReviver;
-  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@rebasepro/types"), require("@rebasepro/common"), require("@rebasepro/utils")) : typeof define === "function" && define.amd ? define([
+		"exports",
+		"@rebasepro/types",
+		"@rebasepro/common",
+		"@rebasepro/utils"
+	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["Rebase Client"] = {}, global._rebasepro_types, global._rebasepro_common, global._rebasepro_utils));
+})(this, function(exports, _rebasepro_types, _rebasepro_common, _rebasepro_utils) {
+	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+	//#region src/reviver.ts
+	function rebaseReviver(_key, value) {
+		if (value && typeof value === "object" && "__type" in value) {
+			const record = value;
+			switch (record.__type) {
+				case "date":
+				case "Date": {
+					if (typeof record.value !== "string") return value;
+					const date = new Date(record.value);
+					return isNaN(date.getTime()) ? null : date;
+				}
+				case "reference":
+				case "EntityReference": return new _rebasepro_types.EntityReference({
+					id: String(record.id),
+					path: record.path,
+					driver: record.driver,
+					databaseId: record.databaseId
+				});
+				case "relation":
+				case "EntityRelation": return new _rebasepro_types.EntityRelation(record.id, record.path, record.data);
+				case "GeoPoint": return new _rebasepro_types.GeoPoint(record.latitude, record.longitude);
+				case "Vector": return new _rebasepro_types.Vector(record.value);
+				default: return value;
+			}
+		}
+		return value;
+	}
+	//#endregion
+	//#region src/transport.ts
+	var RebaseApiError = class extends Error {
+		status;
+		code;
+		details;
+		constructor(status, message, code, details) {
+			super(message);
+			this.name = "RebaseApiError";
+			this.status = status;
+			this.code = code;
+			this.details = details;
+		}
+	};
+	/**
+	* Maps a short operator alias to the PostgREST-style short code.
+	*/
+	var OP_MAP = {
+		"==": "eq",
+		"!=": "neq",
+		">": "gt",
+		">=": "gte",
+		"<": "lt",
+		"<=": "lte",
+		"not-in": "nin",
+		"array-contains": "cs",
+		"array-contains-any": "csa"
+	};
+	/**
+	* Normalise a single `WhereFieldValue` into the PostgREST query-string
+	* representation the backend expects.
+	*
+	* Supports:
+	*  - `null`          → `"eq.null"`
+	*  - `true`/`false`  → `"eq.true"` / `"eq.false"`
+	*  - `42`            → `"42"` (plain equality)
+	*  - `"active"`      → `"active"` (plain equality, backward-compat)
+	*  - `"gte.18"`      → `"gte.18"` (pass-through PostgREST string)
+	*  - `[">=", 18]`    → `"gte.18"` (tuple syntax)
+	*  - `["in", [1,2]]` → `"in.(1,2)"` (tuple with array value)
+	*  - `["!=", null]`  → `"neq.null"`
+	*/
+	function normalizeWhereValue(value) {
+		if (value === null) return "eq.null";
+		if (typeof value === "boolean") return `eq.${value}`;
+		if (typeof value === "number") return String(value);
+		if (Array.isArray(value)) {
+			const [rawOp, val] = (Array.isArray(value[0]) ? value : [value])[0] || [];
+			if (rawOp) {
+				const op = OP_MAP[rawOp] ?? rawOp;
+				if (val === null) return `${op}.null`;
+				if (Array.isArray(val)) return `${op}.(${val.join(",")})`;
+				return `${op}.${val}`;
+			}
+		}
+		return String(value);
+	}
+	function serializeLogicalCondition(cond) {
+		if ("type" in cond) {
+			const sub = cond.conditions.map(serializeLogicalCondition).join(",");
+			return `${cond.type}(${sub})`;
+		} else {
+			const op = OP_MAP[cond.operator] ?? cond.operator;
+			let formattedValue = cond.value;
+			if (Array.isArray(cond.value)) formattedValue = `(${cond.value.join(",")})`;
+			else if (cond.value === null) formattedValue = "null";
+			return `${cond.column}.${op}.${formattedValue}`;
+		}
+	}
+	function buildQueryString(params) {
+		if (!params) return "";
+		const parts = [];
+		if (params.limit != null) parts.push(`limit=${params.limit}`);
+		if (params.offset != null) parts.push(`offset=${params.offset}`);
+		if (params.page != null) parts.push(`page=${params.page}`);
+		if (params.orderBy) parts.push(`orderBy=${encodeURIComponent(params.orderBy)}`);
+		if (params.searchString) parts.push(`searchString=${encodeURIComponent(params.searchString)}`);
+		if (params.include && params.include.length > 0) parts.push(`include=${encodeURIComponent(params.include.join(","))}`);
+		if (params.logical) {
+			const root = params.logical;
+			const serialized = root.conditions.map(serializeLogicalCondition).join(",");
+			parts.push(`${root.type}=${encodeURIComponent(`(${serialized})`)}`);
+		}
+		if (params.where) for (const [field, value] of Object.entries(params.where)) if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) for (const subVal of value) {
+			const normalized = normalizeWhereValue(subVal);
+			parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+		}
+		else {
+			const normalized = normalizeWhereValue(value);
+			parts.push(`${encodeURIComponent(field)}=${encodeURIComponent(normalized)}`);
+		}
+		return parts.length > 0 ? "?" + parts.join("&") : "";
+	}
+	function createTransport(config) {
+		const fetchFn = config.fetch || globalThis.fetch;
+		const apiPath = config.apiPath || "/api";
+		let token = config.token;
+		let tokenGetter;
+		let onUnauthorizedHandler = config.onUnauthorized;
+		function getHeaders(activeToken, init) {
+			return {
+				"Content-Type": "application/json",
+				...activeToken ? { Authorization: `Bearer ${activeToken}` } : {},
+				...init?.headers || {}
+			};
+		}
+		async function request(path, init) {
+			const url = (config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "") + apiPath + path;
+			let activeToken = token;
+			if (tokenGetter) try {
+				const fetched = await tokenGetter();
+				if (fetched !== null && fetched !== void 0) activeToken = fetched;
+			} catch (e) {}
+			const headers = getHeaders(activeToken, init);
+			if (init?.body instanceof FormData) delete headers["Content-Type"];
+			const res = await fetchFn(url, {
+				...init,
+				headers
+			});
+			if (res.status === 204) return void 0;
+			const text = await res.text().catch(() => "");
+			let body = {};
+			if (text) try {
+				body = JSON.parse(text, rebaseReviver);
+			} catch (e) {}
+			const getErrorField = (obj, field) => {
+				const err = obj?.error;
+				if (err && typeof err === "object" && err !== null && field in err) return err[field];
+				return obj?.[field];
+			};
+			if (res.status === 401 && onUnauthorizedHandler) {
+				if (await onUnauthorizedHandler()) {
+					let retryToken = token;
+					if (tokenGetter) try {
+						const fetched = await tokenGetter();
+						if (fetched !== null && fetched !== void 0) retryToken = fetched;
+					} catch (e) {}
+					const retryHeaders = getHeaders(retryToken, init);
+					const retryRes = await fetchFn(url, {
+						...init,
+						headers: retryHeaders
+					});
+					if (retryRes.status === 204) return void 0;
+					const retryText = await retryRes.text().catch(() => "");
+					let retryBody = {};
+					if (retryText) try {
+						retryBody = JSON.parse(retryText, rebaseReviver);
+					} catch (e) {}
+					if (!retryRes.ok) {
+						let fallbackMessage = retryRes.statusText;
+						if (retryRes.status === 404 && !fallbackMessage) fallbackMessage = `Endpoint not found (${init?.method || "GET"} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
+						throw new RebaseApiError(retryRes.status, String(getErrorField(retryBody, "message") || fallbackMessage || `Request failed with status ${retryRes.status}`), getErrorField(retryBody, "code"), getErrorField(retryBody, "details"));
+					}
+					return retryBody;
+				}
+			}
+			if (!res.ok) {
+				let fallbackMessage = res.statusText;
+				if (res.status === 404 && !fallbackMessage) fallbackMessage = `Endpoint not found (${init?.method || "GET"} ${path}). This usually means the collection is not registered on the backend, or the frontend API URL configuration (e.g. VITE_API_URL) is missing or pointing to the wrong host.`;
+				throw new RebaseApiError(res.status, String(getErrorField(body, "message") || fallbackMessage || `Request failed with status ${res.status}`), getErrorField(body, "code"), getErrorField(body, "details"));
+			}
+			return body;
+		}
+		return {
+			request,
+			setToken(newToken) {
+				token = newToken || void 0;
+			},
+			setAuthTokenGetter(getter) {
+				tokenGetter = getter;
+			},
+			setOnUnauthorized(handler) {
+				onUnauthorizedHandler = handler;
+			},
+			get baseUrl() {
+				return config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "";
+			},
+			get apiPath() {
+				return apiPath;
+			},
+			get fetchFn() {
+				return fetchFn;
+			},
+			getHeaders: (init) => getHeaders(token, init),
+			resolveToken: async () => {
+				if (tokenGetter) try {
+					const fetched = await tokenGetter();
+					if (fetched !== null && fetched !== void 0) return fetched;
+				} catch (e) {}
+				return token || null;
+			}
+		};
+	}
+	//#endregion
+	//#region src/auth.ts
+	function createMemoryStorage() {
+		const store = {};
+		return {
+			getItem(key) {
+				return store[key] ?? null;
+			},
+			setItem(key, value) {
+				store[key] = value;
+			},
+			removeItem(key) {
+				delete store[key];
+			}
+		};
+	}
+	function detectStorage() {
+		try {
+			if (typeof localStorage !== "undefined") {
+				localStorage.setItem("__rebase_test__", "1");
+				localStorage.removeItem("__rebase_test__");
+				return localStorage;
+			}
+		} catch (e) {}
+		return createMemoryStorage();
+	}
+	function createAuth(transport, options) {
+		const opts = options || {};
+		const storage = opts.storage || detectStorage();
+		const authPath = opts.authPath || "/auth";
+		const autoRefresh = opts.autoRefresh !== false;
+		const persistSession = opts.persistSession !== false;
+		const STORAGE_KEY = "rebase_auth";
+		const REFRESH_BUFFER_MS = 12e4;
+		let currentSession = null;
+		const listeners = /* @__PURE__ */ new Set();
+		let refreshTimeout = null;
+		function authUrl(endpoint) {
+			return transport.baseUrl + transport.apiPath + authPath + endpoint;
+		}
+		function getFetch() {
+			return transport.fetchFn || globalThis.fetch;
+		}
+		function throwApiError(status, body, statusText) {
+			throw new RebaseApiError(status, body?.error?.message || body?.message || statusText, body?.error?.code || body?.code, body?.error?.details || body?.details);
+		}
+		function emit(event, session) {
+			for (const fn of listeners) try {
+				fn(event, session);
+			} catch (e) {}
+		}
+		function saveSession(session) {
+			if (!persistSession) return;
+			try {
+				storage.setItem(STORAGE_KEY, JSON.stringify(session));
+			} catch (e) {}
+		}
+		function clearStoredSession() {
+			try {
+				storage.removeItem(STORAGE_KEY);
+			} catch (e) {}
+		}
+		function loadStoredSession() {
+			try {
+				const raw = storage.getItem(STORAGE_KEY);
+				if (raw) return JSON.parse(raw);
+			} catch (e) {}
+			return null;
+		}
+		function scheduleRefresh(expiresAt) {
+			if (refreshTimeout) clearTimeout(refreshTimeout);
+			if (!autoRefresh) return;
+			const delay = expiresAt - REFRESH_BUFFER_MS - Date.now();
+			if (delay <= 0) {
+				refreshSession().catch(() => signOut());
+				return;
+			}
+			refreshTimeout = setTimeout(async () => {
+				try {
+					await refreshSession();
+				} catch (e) {
+					signOut();
+				}
+			}, delay);
+		}
+		function handleAuthResponse(data, event) {
+			const session = {
+				accessToken: data.tokens.accessToken,
+				refreshToken: data.tokens.refreshToken,
+				expiresAt: data.tokens.accessTokenExpiresAt,
+				user: data.user
+			};
+			currentSession = session;
+			saveSession(session);
+			transport.setToken(session.accessToken);
+			scheduleRefresh(session.expiresAt);
+			emit(event || "SIGNED_IN", session);
+			return session;
+		}
+		async function signInWithEmail(email, password) {
+			const res = await getFetch()(authUrl("/login"), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					email,
+					password
+				})
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			const session = handleAuthResponse(body, "SIGNED_IN");
+			return {
+				user: session.user,
+				accessToken: session.accessToken,
+				refreshToken: session.refreshToken
+			};
+		}
+		async function signUp(email, password, displayName) {
+			const fetchFn = getFetch();
+			const payload = {
+				email,
+				password
+			};
+			if (displayName !== void 0) payload.displayName = displayName;
+			const res = await fetchFn(authUrl("/register"), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(payload)
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			const session = handleAuthResponse(body, "SIGNED_IN");
+			return {
+				user: session.user,
+				accessToken: session.accessToken,
+				refreshToken: session.refreshToken
+			};
+		}
+		/**
+		* Sign in with Google.
+		*
+		* Supports three invocation styles:
+		* - `signInWithGoogle({ idToken })` — ID-token flow (One Tap / Sign In button)
+		* - `signInWithGoogle({ accessToken })` — Access-token flow (popup)
+		* - `signInWithGoogle({ code, redirectUri })` — Authorization code flow (most secure)
+		*/
+		async function signInWithGoogle(payload) {
+			const res = await getFetch()(authUrl("/google"), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(payload)
+			});
+			const responseBody = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, responseBody, res.statusText);
+			const session = handleAuthResponse(responseBody, "SIGNED_IN");
+			return {
+				user: session.user,
+				accessToken: session.accessToken,
+				refreshToken: session.refreshToken
+			};
+		}
+		async function signInWithLinkedin(code, redirectUri) {
+			const res = await getFetch()(authUrl("/linkedin"), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					code,
+					redirectUri
+				})
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			const session = handleAuthResponse(body, "SIGNED_IN");
+			return {
+				user: session.user,
+				accessToken: session.accessToken,
+				refreshToken: session.refreshToken
+			};
+		}
+		/**
+		* Generic OAuth sign-in. Posts the given payload to `/auth/{providerId}`.
+		* Use this for any provider registered on the backend.
+		*/
+		async function signInWithOAuth(providerId, payload) {
+			const res = await getFetch()(authUrl(`/${providerId}`), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(payload)
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			const session = handleAuthResponse(body, "SIGNED_IN");
+			return {
+				user: session.user,
+				accessToken: session.accessToken,
+				refreshToken: session.refreshToken
+			};
+		}
+		async function signInWithGitHub(code, redirectUri) {
+			return signInWithOAuth("github", {
+				code,
+				redirectUri
+			});
+		}
+		async function signInWithMicrosoft(code, redirectUri) {
+			return signInWithOAuth("microsoft", {
+				code,
+				redirectUri
+			});
+		}
+		async function signInWithApple(code, redirectUri, user) {
+			return signInWithOAuth("apple", {
+				code,
+				redirectUri,
+				user
+			});
+		}
+		async function signInWithFacebook(code, redirectUri) {
+			return signInWithOAuth("facebook", {
+				code,
+				redirectUri
+			});
+		}
+		async function signInWithTwitter(code, redirectUri, codeVerifier) {
+			return signInWithOAuth("twitter", {
+				code,
+				redirectUri,
+				codeVerifier
+			});
+		}
+		async function signInWithDiscord(code, redirectUri) {
+			return signInWithOAuth("discord", {
+				code,
+				redirectUri
+			});
+		}
+		async function signInWithGitLab(code, redirectUri) {
+			return signInWithOAuth("gitlab", {
+				code,
+				redirectUri
+			});
+		}
+		async function signInWithBitbucket(code, redirectUri) {
+			return signInWithOAuth("bitbucket", {
+				code,
+				redirectUri
+			});
+		}
+		async function signInWithSlack(code, redirectUri) {
+			return signInWithOAuth("slack", {
+				code,
+				redirectUri
+			});
+		}
+		async function signInWithSpotify(code, redirectUri) {
+			return signInWithOAuth("spotify", {
+				code,
+				redirectUri
+			});
+		}
+		async function signOut() {
+			const fetchFn = getFetch();
+			try {
+				if (currentSession?.refreshToken) await fetchFn(authUrl("/logout"), {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ refreshToken: currentSession.refreshToken })
+				});
+			} catch (e) {}
+			currentSession = null;
+			clearStoredSession();
+			if (refreshTimeout) {
+				clearTimeout(refreshTimeout);
+				refreshTimeout = null;
+			}
+			transport.setToken(null);
+			emit("SIGNED_OUT", null);
+		}
+		async function refreshSession() {
+			if (!currentSession?.refreshToken) throw new Error("No active session to refresh");
+			const res = await getFetch()(authUrl("/refresh"), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ refreshToken: currentSession.refreshToken })
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			const session = {
+				accessToken: body.tokens.accessToken,
+				refreshToken: body.tokens.refreshToken,
+				expiresAt: body.tokens.accessTokenExpiresAt,
+				user: currentSession.user
+			};
+			currentSession = session;
+			saveSession(session);
+			transport.setToken(session.accessToken);
+			scheduleRefresh(session.expiresAt);
+			emit("TOKEN_REFRESHED", session);
+			return session;
+		}
+		async function getUser() {
+			return (await transport.request(authPath + "/me", { method: "GET" })).user;
+		}
+		async function updateUser(updates) {
+			const data = await transport.request(authPath + "/me", {
+				method: "PATCH",
+				body: JSON.stringify(updates)
+			});
+			if (currentSession) {
+				currentSession = {
+					...currentSession,
+					user: data.user
+				};
+				saveSession(currentSession);
+				emit("USER_UPDATED", currentSession);
+			}
+			return data.user;
+		}
+		async function resetPasswordForEmail(email) {
+			const res = await getFetch()(authUrl("/forgot-password"), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ email })
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			return body;
+		}
+		async function resetPassword(token, password) {
+			const res = await getFetch()(authUrl("/reset-password"), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					token,
+					password
+				})
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			return body;
+		}
+		async function changePassword(oldPassword, newPassword) {
+			return transport.request(authPath + "/change-password", {
+				method: "POST",
+				body: JSON.stringify({
+					oldPassword,
+					newPassword
+				})
+			});
+		}
+		async function sendVerificationEmail() {
+			return transport.request(authPath + "/send-verification", { method: "POST" });
+		}
+		async function verifyEmail(token) {
+			const res = await getFetch()(authUrl("/verify-email?token=" + encodeURIComponent(token)), {
+				method: "GET",
+				headers: { "Content-Type": "application/json" }
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			return body;
+		}
+		async function getSessions() {
+			return (await transport.request(authPath + "/sessions", { method: "GET" })).sessions;
+		}
+		async function revokeSession(sessionId) {
+			return transport.request(authPath + "/sessions/" + encodeURIComponent(sessionId), { method: "DELETE" });
+		}
+		async function revokeAllSessions() {
+			const result = await transport.request(authPath + "/sessions", { method: "DELETE" });
+			currentSession = null;
+			clearStoredSession();
+			if (refreshTimeout) {
+				clearTimeout(refreshTimeout);
+				refreshTimeout = null;
+			}
+			transport.setToken(null);
+			emit("SIGNED_OUT", null);
+			return result;
+		}
+		async function getAuthConfig() {
+			const res = await getFetch()(authUrl("/config"), {
+				method: "GET",
+				headers: { "Content-Type": "application/json" }
+			});
+			const body = await res.json().catch(() => ({}));
+			if (!res.ok) throwApiError(res.status, body, res.statusText);
+			return body;
+		}
+		function getSession() {
+			return currentSession;
+		}
+		function onAuthStateChange(callback) {
+			listeners.add(callback);
+			return () => listeners.delete(callback);
+		}
+		if (persistSession) {
+			const stored = loadStoredSession();
+			if (stored && stored.accessToken && stored.refreshToken) {
+				if (stored.expiresAt > Date.now()) {
+					currentSession = stored;
+					transport.setToken(stored.accessToken);
+					scheduleRefresh(stored.expiresAt);
+				} else if (stored.refreshToken) {
+					currentSession = stored;
+					refreshSession().catch(() => {
+						currentSession = null;
+						clearStoredSession();
+						transport.setToken(null);
+					});
+				}
+			}
+		}
+		return {
+			signInWithEmail,
+			signUp,
+			signInWithGoogle,
+			signInWithLinkedin,
+			signInWithOAuth,
+			signInWithGitHub,
+			signInWithMicrosoft,
+			signInWithApple,
+			signInWithFacebook,
+			signInWithTwitter,
+			signInWithDiscord,
+			signInWithGitLab,
+			signInWithBitbucket,
+			signInWithSlack,
+			signInWithSpotify,
+			signOut,
+			refreshSession,
+			getUser,
+			updateUser,
+			resetPasswordForEmail,
+			resetPassword,
+			changePassword,
+			sendVerificationEmail,
+			verifyEmail,
+			getSessions,
+			revokeSession,
+			revokeAllSessions,
+			getAuthConfig,
+			getSession,
+			onAuthStateChange
+		};
+	}
+	function createCookieStorage(options = {}) {
+		const defaultOptions = {
+			path: "/",
+			sameSite: "Lax",
+			...options
+		};
+		return {
+			getItem(key) {
+				if (typeof document === "undefined") return null;
+				const nameEQ = encodeURIComponent(key) + "=";
+				const ca = document.cookie.split(";");
+				for (let i = 0; i < ca.length; i++) {
+					let c = ca[i];
+					while (c.charAt(0) === " ") c = c.substring(1, c.length);
+					if (c.indexOf(nameEQ) === 0) return decodeURIComponent(c.substring(nameEQ.length, c.length));
+				}
+				return null;
+			},
+			setItem(key, value) {
+				if (typeof document === "undefined") return;
+				let cookieStr = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+				if (defaultOptions.path) cookieStr += `; path=${defaultOptions.path}`;
+				if (defaultOptions.domain) cookieStr += `; domain=${defaultOptions.domain}`;
+				if (defaultOptions.maxAge !== void 0) cookieStr += `; max-age=${defaultOptions.maxAge}`;
+				else cookieStr += `; max-age=${365 * 24 * 60 * 60}`;
+				if (defaultOptions.secure) cookieStr += "; secure";
+				if (defaultOptions.sameSite) cookieStr += `; samesite=${defaultOptions.sameSite}`;
+				document.cookie = cookieStr;
+			},
+			removeItem(key) {
+				if (typeof document === "undefined") return;
+				let cookieStr = `${encodeURIComponent(key)}=; path=${defaultOptions.path || "/"}; max-age=-1`;
+				if (defaultOptions.domain) cookieStr += `; domain=${defaultOptions.domain}`;
+				document.cookie = cookieStr;
+			}
+		};
+	}
+	//#endregion
+	//#region src/admin.ts
+	function createAdmin(transport, options) {
+		const adminPath = (options || {}).adminPath || "/admin";
+		async function listUsers() {
+			return transport.request(adminPath + "/users", { method: "GET" });
+		}
+		async function listUsersPaginated(options) {
+			const params = new URLSearchParams();
+			if (options?.limit !== void 0) params.set("limit", String(options.limit));
+			if (options?.offset !== void 0) params.set("offset", String(options.offset));
+			if (options?.search) params.set("search", options.search);
+			if (options?.orderBy) params.set("orderBy", options.orderBy);
+			if (options?.orderDir) params.set("orderDir", options.orderDir);
+			const qs = params.toString();
+			return transport.request(adminPath + "/users" + (qs ? "?" + qs : ""), { method: "GET" });
+		}
+		async function getUser(userId) {
+			return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "GET" });
+		}
+		async function createUser(data) {
+			return transport.request(adminPath + "/users", {
+				method: "POST",
+				body: JSON.stringify(data)
+			});
+		}
+		async function updateUser(userId, data) {
+			return transport.request(adminPath + "/users/" + encodeURIComponent(userId), {
+				method: "PUT",
+				body: JSON.stringify(data)
+			});
+		}
+		async function deleteUser(userId) {
+			return transport.request(adminPath + "/users/" + encodeURIComponent(userId), { method: "DELETE" });
+		}
+		async function bootstrap() {
+			return transport.request(adminPath + "/bootstrap", { method: "POST" });
+		}
+		return {
+			listUsers,
+			listUsersPaginated,
+			getUser,
+			createUser,
+			updateUser,
+			deleteUser,
+			bootstrap
+		};
+	}
+	//#endregion
+	//#region src/cron.ts
+	function createCron(transport, options) {
+		const cronPath = options?.cronPath || "/cron";
+		async function listJobs() {
+			return transport.request(cronPath, { method: "GET" });
+		}
+		async function getJob(jobId) {
+			return transport.request(cronPath + "/" + encodeURIComponent(jobId), { method: "GET" });
+		}
+		async function triggerJob(jobId) {
+			return transport.request(cronPath + "/" + encodeURIComponent(jobId) + "/trigger", { method: "POST" });
+		}
+		async function getJobLogs(jobId, options) {
+			const params = new URLSearchParams();
+			if (options?.limit !== void 0) params.set("limit", String(options.limit));
+			const qs = params.toString();
+			return transport.request(cronPath + "/" + encodeURIComponent(jobId) + "/logs" + (qs ? "?" + qs : ""), { method: "GET" });
+		}
+		async function toggleJob(jobId, enabled) {
+			return transport.request(cronPath + "/" + encodeURIComponent(jobId), {
+				method: "PUT",
+				body: JSON.stringify({ enabled })
+			});
+		}
+		return {
+			listJobs,
+			getJob,
+			triggerJob,
+			getJobLogs,
+			toggleJob
+		};
+	}
+	//#endregion
+	//#region src/collection.ts
+	function parseWhereFilter(where) {
+		if (!where) return void 0;
+		const filters = {};
+		const OP_TO_FILTER = {
+			"eq": "==",
+			"neq": "!=",
+			"gt": ">",
+			"gte": ">=",
+			"lt": "<",
+			"lte": "<=",
+			"==": "==",
+			"!=": "!=",
+			">": ">",
+			">=": ">=",
+			"<": "<",
+			"<=": "<=",
+			"in": "in",
+			"nin": "not-in",
+			"not-in": "not-in",
+			"cs": "array-contains",
+			"csa": "array-contains-any",
+			"array-contains": "array-contains",
+			"array-contains-any": "array-contains-any"
+		};
+		const parseSingle = (rawValue, fieldKey) => {
+			if (rawValue === null) return ["==", null];
+			if (typeof rawValue === "boolean") return ["==", rawValue];
+			if (typeof rawValue === "number") return ["==", rawValue];
+			if (Array.isArray(rawValue) && rawValue.length === 2 && typeof rawValue[0] === "string") {
+				const [rawOp, val] = rawValue;
+				return [OP_TO_FILTER[rawOp] ?? "==", val];
+			}
+			const value = String(rawValue);
+			const dotIndex = value.indexOf(".");
+			if (dotIndex > 0) {
+				const opStr = value.substring(0, dotIndex);
+				const valStr = value.substring(dotIndex + 1);
+				let op = "==";
+				let val = valStr;
+				switch (opStr) {
+					case "eq":
+						op = "==";
+						break;
+					case "neq":
+						op = "!=";
+						break;
+					case "gt":
+						op = ">";
+						break;
+					case "gte":
+						op = ">=";
+						break;
+					case "lt":
+						op = "<";
+						break;
+					case "lte":
+						op = "<=";
+						break;
+					case "in":
+						op = "in";
+						val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
+						break;
+					case "nin":
+						op = "not-in";
+						val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
+						break;
+					case "cs":
+						op = "array-contains";
+						break;
+					case "csa":
+						op = "array-contains-any";
+						val = valStr.startsWith("(") && valStr.endsWith(")") ? valStr.slice(1, -1).split(",").map((v) => v.trim()) : valStr.split(",");
+						break;
+					default:
+						op = "==";
+						val = value;
+				}
+				if (val === "true") val = true;
+				else if (val === "false") val = false;
+				else if (val === "null") val = null;
+				else if (typeof val === "string" && /^[0-9]+(\.[0-9]+)?$/.test(val) && fieldKey !== "id" && !fieldKey.endsWith("_id")) val = Number(val);
+				return [op, val];
+			} else return ["==", value];
+		};
+		for (const [key, rawValue] of Object.entries(where)) if (Array.isArray(rawValue) && rawValue.length > 0 && Array.isArray(rawValue[0])) filters[key] = rawValue.map((r) => parseSingle(r, key));
+		else filters[key] = parseSingle(rawValue, key);
+		return filters;
+	}
+	/**
+	* Wrap a flat row (returned by the REST API as `{ id, ...fields }`) into
+	* a proper `Entity<M>` structure expected by the core framework.
+	* The `id` is kept inside `values` as well, since collection properties
+	* may define an `isId` field that the form binds to `formex.values`.
+	*/
+	function rowToEntity(row, slug) {
+		return {
+			id: row.id,
+			path: slug,
+			values: row
+		};
+	}
+	function createCollectionClient(transport, slug, ws) {
+		const basePath = `/data/${slug}`;
+		const client = {
+			async find(params) {
+				const qs = buildQueryString(params);
+				const raw = await transport.request(basePath + qs, { method: "GET" });
+				return {
+					data: (raw.data || []).map((row) => rowToEntity(row, slug)),
+					meta: raw.meta
+				};
+			},
+			async findById(id) {
+				try {
+					const raw = await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "GET" });
+					if (!raw) return void 0;
+					return rowToEntity(raw, slug);
+				} catch (err) {
+					if (err instanceof RebaseApiError && err.status === 404) return;
+					throw err;
+				}
+			},
+			async create(data, id) {
+				const body = { ...data };
+				if (id !== void 0) body.id = id;
+				return rowToEntity(await transport.request(basePath, {
+					method: "POST",
+					body: JSON.stringify(body)
+				}), slug);
+			},
+			async update(id, data) {
+				return rowToEntity(await transport.request(`${basePath}/${encodeURIComponent(String(id))}`, {
+					method: "PUT",
+					body: JSON.stringify(data)
+				}), slug);
+			},
+			async delete(id) {
+				return transport.request(`${basePath}/${encodeURIComponent(String(id))}`, { method: "DELETE" });
+			},
+			async count(params) {
+				const qs = buildQueryString({
+					...params,
+					limit: void 0,
+					offset: void 0
+				});
+				return (await transport.request(basePath + "/count" + qs, { method: "GET" })).count ?? 0;
+			},
+			where(columnOrCondition, operator, value) {
+				const builder = new _rebasepro_common.QueryBuilder(client);
+				if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+				return builder.where(columnOrCondition, operator, value);
+			},
+			orderBy(column, ascending) {
+				return new _rebasepro_common.QueryBuilder(client).orderBy(column, ascending);
+			},
+			limit(count) {
+				return new _rebasepro_common.QueryBuilder(client).limit(count);
+			},
+			offset(count) {
+				return new _rebasepro_common.QueryBuilder(client).offset(count);
+			},
+			search(searchString) {
+				return new _rebasepro_common.QueryBuilder(client).search(searchString);
+			},
+			include(...relations) {
+				return new _rebasepro_common.QueryBuilder(client).include(...relations);
+			}
+		};
+		if (ws) {
+			client.listen = (params, onUpdate, onError) => {
+				return ws.listenCollection({
+					path: slug,
+					filter: parseWhereFilter(params?.where),
+					limit: params?.limit,
+					startAfter: params?.offset ? String(params.offset) : void 0,
+					orderBy: params?.orderBy?.split(":")[0],
+					order: params?.orderBy?.split(":")[1],
+					searchString: params?.searchString
+				}, (entities) => {
+					const requestedLimit = params?.limit || 20;
+					onUpdate({
+						data: entities,
+						meta: {
+							total: entities.length,
+							limit: requestedLimit,
+							offset: params?.offset || 0,
+							hasMore: entities.length >= requestedLimit
+						}
+					});
+				}, onError);
+			};
+			client.listenById = (id, onUpdate, onError) => {
+				return ws.listenEntity({
+					path: slug,
+					entityId: String(id)
+				}, (entity) => {
+					if (entity) onUpdate(entity);
+					else onUpdate(void 0);
+				}, onError);
+			};
+		}
+		return client;
+	}
+	//#endregion
+	//#region src/functions.ts
+	/**
+	* Create a `FunctionsClient` backed by the given transport.
+	*
+	* The transport already handles:
+	* - Base URL resolution
+	* - JWT injection via `Authorization: Bearer`
+	* - 401 retry / `onUnauthorized` flow
+	* - Consistent error throwing via `RebaseApiError`
+	*
+	* @internal
+	*/
+	function createFunctionsClient(transport) {
+		return { async invoke(name, payload, options) {
+			const method = options?.method ?? "POST";
+			const subPath = options?.path ? `/${options.path.replace(/^\//, "")}` : "";
+			const routePath = `/functions/${encodeURIComponent(name)}${subPath}`;
+			const init = { method };
+			if (payload !== void 0 && method !== "GET") init.body = JSON.stringify(payload);
+			if (options?.headers) init.headers = options.headers;
+			return transport.request(routePath, init);
+		} };
+	}
+	//#endregion
+	//#region src/storage.ts
+	function createStorage(transport) {
+		const urlsCache = /* @__PURE__ */ new Map();
+		async function putObject({ file, key, metadata, bucket }) {
+			const formData = new FormData();
+			formData.append("file", file);
+			if (key) formData.append("key", key);
+			if (bucket) formData.append("bucket", bucket);
+			if (metadata) {
+				for (const [key, value] of Object.entries(metadata)) if (value !== void 0 && value !== null) formData.append(`metadata_${key}`, typeof value === "string" ? value : JSON.stringify(value));
+			}
+			return (await transport.request("/storage/upload", {
+				method: "POST",
+				body: formData,
+				headers: {}
+			})).data;
+		}
+		async function getSignedUrl(keyOrUrl, bucket) {
+			const cacheKey = bucket ? `${bucket}/${keyOrUrl}` : keyOrUrl;
+			const cached = urlsCache.get(cacheKey);
+			if (cached) return cached;
+			let filePath = keyOrUrl;
+			if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
+			if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
+			if (!filePath || filePath.trim() === "" || filePath === "/") return {
+				url: null,
+				fileNotFound: true
+			};
+			try {
+				const result = await transport.request(`/storage/metadata/${filePath}`);
+				const activeToken = await transport.resolveToken();
+				const tokenQuery = activeToken ? `?token=${activeToken}` : "";
+				const downloadConfig = {
+					url: `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}${tokenQuery}`,
+					metadata: result.data
+				};
+				urlsCache.set(cacheKey, downloadConfig);
+				return downloadConfig;
+			} catch (e) {
+				if (e instanceof Error && "status" in e && e.status === 404) return {
+					url: null,
+					fileNotFound: true
+				};
+				throw e;
+			}
+		}
+		async function getObject(key, bucket) {
+			let filePath = key;
+			if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
+			if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
+			if (!filePath || filePath.trim() === "" || filePath === "/") return null;
+			const url = `${transport.baseUrl}${transport.apiPath}/storage/file/${filePath}`;
+			const response = await transport.fetchFn(url, { headers: transport.getHeaders ? transport.getHeaders() : {} });
+			if (response.status === 404) return null;
+			if (!response.ok) throw new Error("Failed to get file");
+			const blob = await response.blob();
+			const fileName = filePath.split("/").pop() || "file";
+			return new File([blob], fileName, { type: blob.type });
+		}
+		async function deleteObject(key, bucket) {
+			let filePath = key;
+			if (filePath && (filePath.startsWith("local://") || filePath.startsWith("s3://"))) filePath = filePath.substring(filePath.indexOf("://") + 3);
+			if (bucket && filePath && !filePath.startsWith(bucket)) filePath = `${bucket}/${filePath}`;
+			if (!filePath || filePath.trim() === "" || filePath === "/") return;
+			try {
+				await transport.request(`/storage/file/${filePath}`, { method: "DELETE" });
+			} catch (e) {
+				if (!(e instanceof Error && "status" in e && e.status === 404)) throw e;
+			}
+			urlsCache.delete(bucket ? `${bucket}/${key}` : key);
+		}
+		async function listObjects(prefix, options) {
+			const params = new URLSearchParams();
+			if (prefix) params.set("prefix", prefix);
+			if (options?.bucket) params.set("bucket", options.bucket);
+			if (options?.maxResults) params.set("maxResults", String(options.maxResults));
+			if (options?.pageToken) params.set("pageToken", options.pageToken);
+			return (await transport.request(`/storage/list?${params.toString()}`)).data;
+		}
+		return {
+			putObject,
+			getSignedUrl,
+			getObject,
+			deleteObject,
+			listObjects
+		};
+	}
+	//#endregion
+	//#region src/websocket.ts
+	/**
+	* Extract error message and code from a WebSocket message payload.
+	* Handles both `{ error: string }` and `{ error: { message, code } }` shapes.
+	*/
+	function extractMessageError(message) {
+		const payload = message.payload;
+		const errPayload = payload?.error;
+		return {
+			errorMessage: typeof errPayload === "object" ? errPayload.message : payload?.message || (typeof errPayload === "string" ? errPayload : void 0) || message.error || "Unknown error",
+			errorCode: typeof errPayload === "object" ? errPayload.code : payload?.code
+		};
+	}
+	var ApiError = class extends Error {
+		code;
+		error;
+		constructor(message, error, code) {
+			super(message);
+			this.name = "ApiError";
+			this.code = code;
+			this.error = error;
+		}
+	};
+	var RebaseWebSocketClient = class {
+		websocketUrl;
+		ws = null;
+		getAuthToken;
+		subscriptions = /* @__PURE__ */ new Map();
+		listeners = /* @__PURE__ */ new Map();
+		on(event, cb) {
+			if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+			this.listeners.get(event).add(cb);
+			return () => this.listeners.get(event).delete(cb);
+		}
+		emit(event, ...args) {
+			if (this.listeners.has(event)) this.listeners.get(event).forEach((cb) => cb(...args));
+		}
+		collectionSubscriptions = /* @__PURE__ */ new Map();
+		entitySubscriptions = /* @__PURE__ */ new Map();
+		backendToCollectionKey = /* @__PURE__ */ new Map();
+		backendToEntityKey = /* @__PURE__ */ new Map();
+		pendingRequests = /* @__PURE__ */ new Map();
+		reconnectAttempts = 0;
+		maxReconnectAttempts = 5;
+		isConnected = false;
+		messageQueue = [];
+		requestTimeoutMs = 3e4;
+		reconnectTimeout = null;
+		isAuthenticated = false;
+		authPromise = null;
+		WebSocketConstructor;
+		onUnauthorized;
+		refreshInProgress = null;
+		constructor(config) {
+			this.websocketUrl = config.websocketUrl;
+			this.getAuthToken = config.getAuthToken;
+			this.onUnauthorized = config.onUnauthorized;
+			this.WebSocketConstructor = config.WebSocket || (typeof WebSocket !== "undefined" ? WebSocket : void 0);
+			if (!this.WebSocketConstructor) console.warn("WebSocket is not defined in this environment. Realtime subscriptions will not work unless you provide a WebSocket implementation in the config.");
+			else this.initWebSocket();
+		}
+		/**
+		* Authenticate the WebSocket connection
+		*/
+		async authenticate(token) {
+			return new Promise((resolve, reject) => {
+				const requestId = `auth_${Date.now()}`;
+				const timeout = setTimeout(() => {
+					this.pendingRequests.delete(requestId);
+					this.authPromise = null;
+					reject(/* @__PURE__ */ new Error("Authentication timeout"));
+				}, 3e4);
+				this.pendingRequests.set(requestId, {
+					resolve: () => {
+						clearTimeout(timeout);
+						this.isAuthenticated = true;
+						resolve();
+					},
+					reject: (error) => {
+						clearTimeout(timeout);
+						reject(error);
+					}
+				});
+				const message = {
+					type: "AUTHENTICATE",
+					requestId,
+					payload: { token }
+				};
+				if (!this.isConnected || !this.ws) this.messageQueue.unshift(message);
+				else this.ws.send(JSON.stringify(message));
+			});
+		}
+		/**
+		* Set the auth token getter function
+		*/
+		setAuthTokenGetter(getAuthToken) {
+			this.getAuthToken = getAuthToken;
+			if (this.isConnected && !this.isAuthenticated && !this.authPromise) {
+				console.debug("WebSocket auto-authenticating after token getter set");
+				this.getAuthToken().then((token) => {
+					if (!this.ws) return;
+					if (token) this.authenticate(token).catch((e) => {
+						if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
+					});
+				}).catch((e) => {
+					if (this.ws) console.debug("WebSocket auto-auth skipped:", e?.message || e);
+				});
+			}
+		}
+		disconnect() {
+			this.isAuthenticated = false;
+			this.authPromise = null;
+			if (this.reconnectTimeout) {
+				clearTimeout(this.reconnectTimeout);
+				this.reconnectTimeout = null;
+			}
+			if (this.ws) {
+				this.ws.onclose = null;
+				this.ws.onerror = null;
+				this.ws.onopen = null;
+				this.ws.onmessage = null;
+				this.ws.close();
+				this.ws = null;
+			}
+		}
+		initWebSocket() {
+			if (!this.WebSocketConstructor) return;
+			if (this.ws?.readyState === this.WebSocketConstructor.OPEN) return;
+			if (this.ws) {
+				this.ws.onclose = null;
+				this.ws.close();
+				this.ws = null;
+			}
+			try {
+				this.ws = new this.WebSocketConstructor(this.websocketUrl);
+				this.ws.onopen = async () => {
+					console.debug("Connected to PostgreSQL backend");
+					const wasReconnect = this.reconnectAttempts > 0;
+					this.isConnected = true;
+					this.reconnectAttempts = 0;
+					if (this.getAuthToken && !this.isAuthenticated) try {
+						const token = await this.getAuthToken();
+						if (token) {
+							await this.authenticate(token);
+							console.debug("WebSocket auto-authenticated");
+						}
+					} catch (error) {
+						console.debug("WebSocket connected without auth:", error?.message || error);
+					}
+					this.emit(wasReconnect ? "reconnect" : "connect");
+					this.processMessageQueue();
+					if (wasReconnect) this.resubscribeAll();
+				};
+				this.ws.onmessage = (event) => {
+					try {
+						const message = JSON.parse(event.data, rebaseReviver);
+						this.handleWebSocketMessage(message);
+					} catch (error) {
+						console.error("Error parsing WebSocket message:", error);
+					}
+				};
+				this.ws.onclose = () => {
+					console.debug("Disconnected from PostgreSQL backend");
+					this.isConnected = false;
+					this.isAuthenticated = false;
+					this.authPromise = null;
+					this.emit("disconnect");
+					for (const [reqId, request] of this.pendingRequests.entries()) {
+						if (reqId.startsWith("auth_")) request.reject(/* @__PURE__ */ new Error("Connection closed during authentication"));
+						else if (request.message) {
+							request.message._queuedResolve = request.resolve;
+							request.message._queuedReject = request.reject;
+							this.messageQueue.push(request.message);
+						} else request.reject(new ApiError("Connection closed", "Connection closed"));
+						this.pendingRequests.delete(reqId);
+					}
+					this.attemptReconnect();
+				};
+				this.ws.onerror = (error) => {
+					console.error("WebSocket error:", error);
+					this.isConnected = false;
+					this.emit("error", error);
+				};
+			} catch (error) {
+				console.error("Failed to initialize WebSocket:", error);
+				this.attemptReconnect();
+			}
+		}
+		processMessageQueue() {
+			while (this.messageQueue.length > 0 && this.isConnected) {
+				const message = this.messageQueue.shift();
+				if (message) this.sendMessage(message);
+			}
+		}
+		attemptReconnect() {
+			if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+				console.error("Max reconnection attempts reached");
+				return;
+			}
+			this.reconnectAttempts++;
+			const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+			console.debug(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+			if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+			this.reconnectTimeout = setTimeout(() => {
+				this.reconnectTimeout = null;
+				this.initWebSocket();
+			}, delay);
+		}
+		isAuthError(message) {
+			if (message.type === "AUTH_ERROR") return true;
+			const { errorMessage, errorCode } = extractMessageError(message);
+			if (errorCode === "UNAUTHORIZED" || errorCode === "JWT_EXPIRED" || errorCode === "AUTH_ERROR") return true;
+			const lowerMessage = errorMessage.toLowerCase();
+			return lowerMessage.includes("unauthorized") || lowerMessage.includes("token expired") || lowerMessage.includes("token is expired") || lowerMessage.includes("invalid token") || lowerMessage.includes("session expired") || lowerMessage.includes("auth error");
+		}
+		async handleAuthFailure() {
+			if (this.refreshInProgress) return this.refreshInProgress;
+			this.refreshInProgress = (async () => {
+				this.isAuthenticated = false;
+				this.authPromise = null;
+				if (this.onUnauthorized) try {
+					if (await this.onUnauthorized() && this.getAuthToken) {
+						const token = await this.getAuthToken();
+						if (token) {
+							await this.authenticate(token);
+							return true;
+						}
+					}
+				} catch (error) {
+					console.error("WebSocket auth refresh failed:", error);
+				}
+				return false;
+			})();
+			try {
+				return await this.refreshInProgress;
+			} finally {
+				this.refreshInProgress = null;
+			}
+		}
+		/**
+		* Shared logic for re-subscribing a collection or entity subscription
+		* after an auth error is resolved by refreshing credentials.
+		*/
+		resubscribeAfterAuthRefresh(message, subscription, subscriptionKey, idPrefix, backendKeyMap, messageType) {
+			this.handleAuthFailure().then((refreshed) => {
+				if (refreshed) {
+					const oldBackendId = subscription.backendSubscriptionId;
+					const newBackendId = `${idPrefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+					subscription.backendSubscriptionId = newBackendId;
+					backendKeyMap.delete(oldBackendId);
+					backendKeyMap.set(newBackendId, subscriptionKey);
+					this.sendMessage({
+						type: messageType,
+						payload: {
+							...subscription.props,
+							subscriptionId: newBackendId
+						}
+					}).catch((error) => {
+						console.error(`[WS] Failed to re-subscribe ${idPrefix} after auth refresh:`, subscriptionKey, error);
+						subscription.callbacks.forEach((callback) => {
+							if (callback.onError) callback.onError(error);
+						});
+					});
+				} else {
+					const { errorMessage, errorCode } = extractMessageError(message);
+					const error = new ApiError(errorMessage, errorMessage, errorCode);
+					subscription.callbacks.forEach((callback) => {
+						if (callback.onError) callback.onError(error);
+					});
+				}
+			}).catch((err) => {
+				subscription.callbacks.forEach((callback) => {
+					if (callback.onError) callback.onError(err);
+				});
+			});
+		}
+		handleWebSocketMessage(message) {
+			const { type, requestId, subscriptionId } = message;
+			if (requestId && this.pendingRequests.has(requestId)) {
+				const pendingReq = this.pendingRequests.get(requestId);
+				if (type === "ERROR" || type === "AUTH_ERROR" || message.error) if (this.isAuthError(message)) {
+					this.pendingRequests.delete(requestId);
+					this.handleAuthFailure().then((refreshed) => {
+						if (refreshed && pendingReq.message) this.doSendMessage(pendingReq.message, pendingReq.resolve, pendingReq.reject).catch(pendingReq.reject);
+						else {
+							const { errorMessage, errorCode } = extractMessageError(message);
+							pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+						}
+					}).catch((err) => {
+						pendingReq.reject(err);
+					});
+				} else {
+					this.pendingRequests.delete(requestId);
+					const { errorMessage, errorCode } = extractMessageError(message);
+					pendingReq.reject(new ApiError(errorMessage, errorMessage, errorCode));
+				}
+				else {
+					this.pendingRequests.delete(requestId);
+					pendingReq.resolve(message.payload || message);
+				}
+				return;
+			}
+			if (subscriptionId && type === "collection_update") {
+				const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
+				if (subscriptionKey) {
+					const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
+					if (collectionSub) {
+						const incomingEntities = message.entities || [];
+						const entities = this.mergeEntities(collectionSub.latestData, incomingEntities);
+						collectionSub.latestData = entities;
+						collectionSub.lastUpdated = Date.now();
+						collectionSub.isInitialDataReceived = true;
+						collectionSub.callbacks.forEach((callback) => {
+							try {
+								callback.onUpdate(entities);
+							} catch (error) {
+								console.error("Error in collection subscription callback:", error);
+								if (callback.onError) callback.onError(error instanceof Error ? error : new Error(String(error)));
+							}
+						});
+						return;
+					}
+				}
+			}
+			if (subscriptionId && type === "collection_entity_patch") {
+				const subscriptionKey = this.backendToCollectionKey.get(subscriptionId);
+				if (subscriptionKey) {
+					const collectionSub = this.collectionSubscriptions.get(subscriptionKey);
+					if (collectionSub && collectionSub.isInitialDataReceived && collectionSub.latestData) {
+						const patchEntity = message.entity ?? null;
+						const patchEntityId = message.entityId;
+						let updated;
+						if (patchEntity === null || patchEntity === void 0) updated = collectionSub.latestData.filter((e) => String(e.id) !== String(patchEntityId));
+						else {
+							const idx = collectionSub.latestData.findIndex((e) => String(e.id) === String(patchEntity.id));
+							if (idx >= 0) {
+								updated = [...collectionSub.latestData];
+								updated[idx] = patchEntity;
+							} else updated = [patchEntity, ...collectionSub.latestData];
+						}
+						collectionSub.latestData = updated;
+						collectionSub.lastUpdated = Date.now();
+						collectionSub.callbacks.forEach((callback) => {
+							try {
+								callback.onUpdate(updated);
+							} catch (error) {
+								console.error("Error in collection patch callback:", error);
+								if (callback.onError) callback.onError(error instanceof Error ? error : new Error(String(error)));
+							}
+						});
+						return;
+					}
+				}
+			}
+			if (subscriptionId && type === "entity_update") {
+				const subscriptionKey = this.backendToEntityKey.get(subscriptionId);
+				if (subscriptionKey) {
+					const entitySub = this.entitySubscriptions.get(subscriptionKey);
+					if (entitySub) {
+						const entity = message.entity ?? null;
+						entitySub.latestData = entity;
+						entitySub.lastUpdated = Date.now();
+						entitySub.isInitialDataReceived = true;
+						entitySub.callbacks.forEach((callback) => {
+							try {
+								callback.onUpdate(entity);
+							} catch (error) {
+								console.error("Error in entity subscription callback:", error);
+								if (callback.onError) callback.onError(error instanceof Error ? error : new Error(String(error)));
+							}
+						});
+						return;
+					}
+				}
+			}
+			if (subscriptionId && (type === "ERROR" || message.error)) {
+				const collectionKey = this.backendToCollectionKey.get(subscriptionId);
+				if (collectionKey) {
+					const collectionSub = this.collectionSubscriptions.get(collectionKey);
+					if (collectionSub) {
+						if (this.isAuthError(message)) {
+							this.resubscribeAfterAuthRefresh(message, collectionSub, collectionKey, "collection", this.backendToCollectionKey, "subscribe_collection");
+							return;
+						}
+						const { errorMessage, errorCode } = extractMessageError(message);
+						const error = new ApiError(errorMessage, errorMessage, errorCode);
+						collectionSub.callbacks.forEach((callback) => {
+							if (callback.onError) callback.onError(error);
+						});
+						return;
+					}
+				}
+				const entityKey = this.backendToEntityKey.get(subscriptionId);
+				if (entityKey) {
+					const entitySub = this.entitySubscriptions.get(entityKey);
+					if (entitySub) {
+						if (this.isAuthError(message)) {
+							this.resubscribeAfterAuthRefresh(message, entitySub, entityKey, "entity", this.backendToEntityKey, "subscribe_entity");
+							return;
+						}
+						const { errorMessage, errorCode } = extractMessageError(message);
+						const error = new ApiError(errorMessage, errorMessage, errorCode);
+						entitySub.callbacks.forEach((callback) => {
+							if (callback.onError) callback.onError(error);
+						});
+						return;
+					}
+				}
+			}
+			if (subscriptionId && this.subscriptions.has(subscriptionId)) {
+				const callback = this.subscriptions.get(subscriptionId);
+				if (!callback) throw new Error(`Subscription callback not found for subscriptionId: ${subscriptionId}`);
+				if (message.type === "ERROR" || message.error) {
+					if (callback.onError) {
+						const { errorMessage, errorCode } = extractMessageError(message);
+						callback.onError(new ApiError(errorMessage, errorMessage, errorCode));
+					}
+				} else callback.onUpdate(message);
+			}
+		}
+		async ensureAuthenticated(retryCount = 3) {
+			if (this.isAuthenticated || !this.getAuthToken) return;
+			if (this.authPromise) {
+				await this.authPromise;
+				return;
+			}
+			let lastError = null;
+			for (let attempt = 0; attempt < retryCount; attempt++) try {
+				const token = await this.getAuthToken();
+				if (!token) throw new Error("user not logged in");
+				this.authPromise = this.authenticate(token);
+				await this.authPromise;
+				this.authPromise = null;
+				console.debug("WebSocket authenticated on demand");
+				return;
+			} catch (error) {
+				this.authPromise = null;
+				lastError = error;
+				const errMsg = error instanceof Error ? error.message : String(error);
+				if (errMsg.includes("not logged in") || errMsg.includes("Session expired")) {
+					console.warn("WebSocket auth failed: user not logged in");
+					throw error;
+				}
+				if (errMsg.includes("still loading")) {
+					if (attempt < retryCount - 1) {
+						const delay = Math.min(500 * (attempt + 1), 2e3);
+						await new Promise((resolve) => setTimeout(resolve, delay));
+						continue;
+					}
+				}
+				if (attempt < retryCount - 1) {
+					const delay = Math.min(1e3 * (attempt + 1), 3e3);
+					console.debug(`WebSocket auth attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+					await new Promise((resolve) => setTimeout(resolve, delay));
+				}
+			}
+			console.warn("WebSocket on-demand auth failed after retries:", lastError);
+			throw lastError;
+		}
+		async reauthenticate() {
+			if (!this.getAuthToken) return;
+			this.isAuthenticated = false;
+			try {
+				const token = await this.getAuthToken();
+				if (!token) throw new Error("user not logged in");
+				await this.authenticate(token);
+				console.debug("WebSocket reauthenticated successfully");
+			} catch (error) {
+				console.error("WebSocket reauthentication failed:", error);
+				throw error;
+			}
+		}
+		sendMessage(message) {
+			const queuedMsg = message;
+			if (queuedMsg._queuedResolve && queuedMsg._queuedReject) return this.doSendMessage(message, queuedMsg._queuedResolve, queuedMsg._queuedReject);
+			if (!this.isConnected || !this.ws) return new Promise((resolve, reject) => {
+				const queueable = message;
+				queueable._queuedResolve = resolve;
+				queueable._queuedReject = reject;
+				this.messageQueue.push(message);
+			});
+			return new Promise((resolve, reject) => {
+				this.doSendMessage(message, resolve, reject);
+			});
+		}
+		async doSendMessage(message, resolve, reject) {
+			if (message.type !== "AUTHENTICATE" && this.getAuthToken && !this.isAuthenticated) try {
+				await this.ensureAuthenticated();
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : "Authentication required";
+				reject(new ApiError(errorMessage, errorMessage));
+				return;
+			}
+			const requestId = message.requestId || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+			message.requestId = requestId;
+			const expectsResponse = ![
+				"subscribe_collection",
+				"subscribe_entity",
+				"unsubscribe",
+				"join_channel",
+				"leave_channel",
+				"broadcast",
+				"presence_track",
+				"presence_untrack",
+				"presence_state"
+			].includes(message.type);
+			if (expectsResponse && !this.pendingRequests.has(requestId)) {
+				const timeoutHandle = setTimeout(() => {
+					if (this.pendingRequests.has(requestId)) {
+						this.pendingRequests.delete(requestId);
+						reject(new ApiError("Request timed out", "Request timed out"));
+					}
+				}, this.requestTimeoutMs);
+				this.pendingRequests.set(requestId, {
+					resolve: (value) => {
+						clearTimeout(timeoutHandle);
+						resolve(value);
+					},
+					reject: (error) => {
+						clearTimeout(timeoutHandle);
+						reject(error);
+					},
+					message
+				});
+			}
+			try {
+				this.ws.send(JSON.stringify(message));
+				if (!expectsResponse) resolve(void 0);
+			} catch (error) {
+				if (expectsResponse) this.pendingRequests.delete(requestId);
+				reject(new ApiError("Failed to send message", error instanceof Error ? error.message : "Unknown error"));
+			}
+		}
+		async fetchCollection(props) {
+			return (await this.sendMessage({
+				type: "FETCH_COLLECTION",
+				payload: props
+			})).entities || [];
+		}
+		async fetchEntity(props) {
+			return (await this.sendMessage({
+				type: "FETCH_ENTITY",
+				payload: props
+			})).entity ?? void 0;
+		}
+		async saveEntity(props) {
+			return (await this.sendMessage({
+				type: "SAVE_ENTITY",
+				payload: props
+			})).entity;
+		}
+		async deleteEntity(props) {
+			await this.sendMessage({
+				type: "DELETE_ENTITY",
+				payload: props
+			});
+		}
+		async executeSql(sql, options) {
+			return (await this.sendMessage({
+				type: "EXECUTE_SQL",
+				payload: {
+					sql,
+					options
+				}
+			})).result || [];
+		}
+		async fetchAvailableDatabases() {
+			return (await this.sendMessage({
+				type: "FETCH_DATABASES",
+				payload: {}
+			})).databases || [];
+		}
+		async fetchAvailableRoles() {
+			return (await this.sendMessage({ type: "FETCH_ROLES" })).roles || [];
+		}
+		async fetchCurrentDatabase() {
+			return (await this.sendMessage({ type: "FETCH_CURRENT_DATABASE" })).database;
+		}
+		async checkUniqueField(path, name, value, entityId, collection) {
+			return (await this.sendMessage({
+				type: "CHECK_UNIQUE_FIELD",
+				payload: {
+					path,
+					name,
+					value,
+					entityId,
+					collection
+				}
+			})).isUnique;
+		}
+		async countEntities(props) {
+			return (await this.sendMessage({
+				type: "COUNT_ENTITIES",
+				payload: props
+			})).count;
+		}
+		async fetchUnmappedTables(mappedPaths) {
+			return (await this.sendMessage({
+				type: "FETCH_UNMAPPED_TABLES",
+				payload: { mappedPaths }
+			})).tables || [];
+		}
+		async fetchTableMetadata(tableName) {
+			return (await this.sendMessage({
+				type: "FETCH_TABLE_METADATA",
+				payload: { tableName }
+			})).metadata || {
+				columns: [],
+				foreignKeys: [],
+				junctions: [],
+				policies: []
+			};
+		}
+		async createBranch(name, options) {
+			return (await this.sendMessage({
+				type: "CREATE_BRANCH",
+				payload: {
+					name,
+					options
+				}
+			})).branch;
+		}
+		async deleteBranch(name) {
+			await this.sendMessage({
+				type: "DELETE_BRANCH",
+				payload: { name }
+			});
+		}
+		async listBranches() {
+			return (await this.sendMessage({
+				type: "LIST_BRANCHES",
+				payload: {}
+			})).branches || [];
+		}
+		/**
+		* Recursively compare two values for structural equality.
+		* Handles primitives, null, undefined, Date, RegExp, arrays, and plain objects.
+		*/
+		deepEqual(a, b) {
+			if (a === b) return true;
+			if (a === null || b === null || a === void 0 || b === void 0) return false;
+			if (typeof a !== typeof b) return false;
+			if (typeof a !== "object") return false;
+			if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+			if (a instanceof Date || b instanceof Date) return false;
+			if (a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
+			if (a instanceof RegExp || b instanceof RegExp) return false;
+			const aIsArray = Array.isArray(a);
+			const bIsArray = Array.isArray(b);
+			if (aIsArray !== bIsArray) return false;
+			if (aIsArray && bIsArray) {
+				if (a.length !== b.length) return false;
+				for (let i = 0; i < a.length; i++) if (!this.deepEqual(a[i], b[i])) return false;
+				return true;
+			}
+			const aObj = a;
+			const bObj = b;
+			const aKeys = Object.keys(aObj);
+			const bKeys = Object.keys(bObj);
+			if (aKeys.length !== bKeys.length) return false;
+			for (const key of aKeys) {
+				if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
+				if (!this.deepEqual(aObj[key], bObj[key])) return false;
+			}
+			return true;
+		}
+		normalizeForComparison(val) {
+			if (!val) return val;
+			if (Array.isArray(val)) return val.map((item) => this.normalizeForComparison(item));
+			if (typeof val === "object") {
+				if (val instanceof Date) return val;
+				if (val instanceof RegExp) return val;
+				const obj = val;
+				if (obj.__type === "relation") {
+					const { data, ...rest } = obj;
+					return rest;
+				}
+				const result = {};
+				for (const [k, v] of Object.entries(obj)) result[k] = this.normalizeForComparison(v);
+				return result;
+			}
+			return val;
+		}
+		/**
+		* Merge incoming entities with cached data, preserving cached references
+		* for entities whose values haven't changed. This avoids unnecessary
+		* React re-renders when the server refetches all entities but most
+		* haven't actually changed.
+		*/
+		mergeEntities(cached, incoming) {
+			if (!cached || cached.length === 0) return incoming;
+			const cachedById = /* @__PURE__ */ new Map();
+			for (const entity of cached) cachedById.set(entity.id, entity);
+			return incoming.map((incomingEntity) => {
+				const cachedEntity = cachedById.get(incomingEntity.id);
+				if (!cachedEntity) return incomingEntity;
+				if (cachedEntity.path === incomingEntity.path) {
+					const normCached = this.normalizeForComparison(cachedEntity.values);
+					const normIncoming = this.normalizeForComparison(incomingEntity.values);
+					if (this.deepEqual(normCached, normIncoming)) return cachedEntity;
+					else {
+						const mismatches = {};
+						const allKeys = new Set([...Object.keys(normCached), ...Object.keys(normIncoming)]);
+						for (const key of allKeys) if (!this.deepEqual(normCached[key], normIncoming[key])) mismatches[key] = {
+							cached: normCached[key],
+							incoming: normIncoming[key]
+						};
+						console.debug(`[RebaseWS] Row ${incomingEntity.id} refetch mismatch:\n`, JSON.stringify(mismatches, null, 2));
+					}
+				}
+				return incomingEntity;
+			});
+		}
+		listenCollection(props, onUpdate, onError) {
+			const subscriptionKey = this.createCollectionSubscriptionKey(props);
+			const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+			const existingSubscription = this.collectionSubscriptions.get(subscriptionKey);
+			if (existingSubscription) {
+				const callbackMap = existingSubscription.callbacks;
+				callbackMap.set(callbackId, {
+					onUpdate,
+					onError
+				});
+				if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) try {
+					onUpdate(existingSubscription.latestData);
+				} catch (error) {
+					console.error("Error in collection subscription callback:", error);
+					if (onError) onError(error instanceof Error ? error : new Error(String(error)));
+				}
+				return () => {
+					callbackMap.delete(callbackId);
+					if (callbackMap.size === 0) {
+						this.collectionSubscriptions.delete(subscriptionKey);
+						this.backendToCollectionKey.delete(existingSubscription.backendSubscriptionId);
+						if (this.isConnected && this.ws) this.sendMessage({
+							type: "unsubscribe",
+							payload: { subscriptionId: existingSubscription.backendSubscriptionId }
+						}).catch(console.error);
+					}
+				};
+			}
+			const backendSubscriptionId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+			const callbackMap = /* @__PURE__ */ new Map();
+			callbackMap.set(callbackId, {
+				onUpdate,
+				onError
+			});
+			this.collectionSubscriptions.set(subscriptionKey, {
+				backendSubscriptionId,
+				callbacks: callbackMap,
+				props
+			});
+			this.backendToCollectionKey.set(backendSubscriptionId, subscriptionKey);
+			this.sendMessage({
+				type: "subscribe_collection",
+				payload: {
+					...props,
+					subscriptionId: backendSubscriptionId
+				}
+			}).catch((error) => {
+				if (onError) onError(error);
+			});
+			return () => {
+				const subscription = this.collectionSubscriptions.get(subscriptionKey);
+				if (subscription) {
+					const callbacks = subscription.callbacks;
+					callbacks.delete(callbackId);
+					if (callbacks.size === 0) {
+						this.collectionSubscriptions.delete(subscriptionKey);
+						this.backendToCollectionKey.delete(subscription.backendSubscriptionId);
+						if (this.isConnected && this.ws) this.sendMessage({
+							type: "unsubscribe",
+							payload: { subscriptionId: subscription.backendSubscriptionId }
+						}).catch(console.error);
+					}
+				}
+			};
+		}
+		listenEntity(props, onUpdate, onError) {
+			const subscriptionKey = this.createEntitySubscriptionKey(props);
+			const callbackId = `callback_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+			const existingSubscription = this.entitySubscriptions.get(subscriptionKey);
+			if (existingSubscription) {
+				const callbackMap = existingSubscription.callbacks;
+				callbackMap.set(callbackId, {
+					onUpdate,
+					onError
+				});
+				if (existingSubscription.latestData !== void 0 && existingSubscription.isInitialDataReceived) try {
+					onUpdate(existingSubscription.latestData);
+				} catch (error) {
+					console.error("Error in entity subscription callback:", error);
+					if (onError) onError(error instanceof Error ? error : new Error(String(error)));
+				}
+				return () => {
+					callbackMap.delete(callbackId);
+					if (callbackMap.size === 0) {
+						this.entitySubscriptions.delete(subscriptionKey);
+						this.backendToEntityKey.delete(existingSubscription.backendSubscriptionId);
+						if (this.isConnected && this.ws) this.sendMessage({
+							type: "unsubscribe",
+							payload: { subscriptionId: existingSubscription.backendSubscriptionId }
+						}).catch(console.error);
+					}
+				};
+			}
+			const backendSubscriptionId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+			const callbackMap = /* @__PURE__ */ new Map();
+			callbackMap.set(callbackId, {
+				onUpdate,
+				onError
+			});
+			this.entitySubscriptions.set(subscriptionKey, {
+				backendSubscriptionId,
+				callbacks: callbackMap,
+				props
+			});
+			this.backendToEntityKey.set(backendSubscriptionId, subscriptionKey);
+			this.sendMessage({
+				type: "subscribe_entity",
+				payload: {
+					...props,
+					subscriptionId: backendSubscriptionId
+				}
+			}).catch((error) => {
+				if (onError) onError(error);
+			});
+			return () => {
+				const subscription = this.entitySubscriptions.get(subscriptionKey);
+				if (subscription) {
+					const callbacks = subscription.callbacks;
+					callbacks.delete(callbackId);
+					if (callbacks.size === 0) {
+						this.entitySubscriptions.delete(subscriptionKey);
+						this.backendToEntityKey.delete(subscription.backendSubscriptionId);
+						if (this.isConnected && this.ws) this.sendMessage({
+							type: "unsubscribe",
+							payload: { subscriptionId: subscription.backendSubscriptionId }
+						}).catch(console.error);
+					}
+				}
+			};
+		}
+		/**
+		* Re-send all active subscriptions to the backend after a reconnect.
+		* The server wipes subscription state when a client disconnects, so
+		* we need to re-register everything to resume receiving updates.
+		*/
+		resubscribeAll() {
+			console.debug(`[WS] Re-subscribing: ${this.collectionSubscriptions.size} collection(s), ${this.entitySubscriptions.size} entity(ies)`);
+			for (const [key, sub] of this.collectionSubscriptions.entries()) {
+				const oldBackendId = sub.backendSubscriptionId;
+				const newBackendId = `collection_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+				sub.backendSubscriptionId = newBackendId;
+				this.backendToCollectionKey.delete(oldBackendId);
+				this.backendToCollectionKey.set(newBackendId, key);
+				this.sendMessage({
+					type: "subscribe_collection",
+					payload: {
+						...sub.props,
+						subscriptionId: newBackendId
+					}
+				}).catch((error) => {
+					console.error("[WS] Failed to re-subscribe collection:", key, error);
+				});
+			}
+			for (const [key, sub] of this.entitySubscriptions.entries()) {
+				const oldBackendId = sub.backendSubscriptionId;
+				const newBackendId = `entity_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+				sub.backendSubscriptionId = newBackendId;
+				this.backendToEntityKey.delete(oldBackendId);
+				this.backendToEntityKey.set(newBackendId, key);
+				this.sendMessage({
+					type: "subscribe_entity",
+					payload: {
+						...sub.props,
+						subscriptionId: newBackendId
+					}
+				}).catch((error) => {
+					console.error("[WS] Failed to re-subscribe entity:", key, error);
+				});
+			}
+		}
+		createCollectionSubscriptionKey(props) {
+			const key = {
+				path: props.path,
+				filter: props.filter,
+				limit: props.limit,
+				startAfter: props.startAfter,
+				orderBy: props.orderBy,
+				order: props.order,
+				searchString: props.searchString,
+				collection: props.collection?.name
+			};
+			return JSON.stringify(key, (_, value) => {
+				if (value && typeof value === "object" && !Array.isArray(value)) return Object.keys(value).sort().reduce((sorted, k) => {
+					sorted[k] = value[k];
+					return sorted;
+				}, {});
+				return value;
+			});
+		}
+		createEntitySubscriptionKey(props) {
+			return `${props.path}|${props.entityId}`;
+		}
+	};
+	//#endregion
+	//#region src/index.ts
+	/**
+	* Derive a WebSocket URL from an HTTP base URL.
+	* `http://` → `ws://`, `https://` → `wss://`.
+	*/
+	function deriveWebSocketUrl(baseUrl) {
+		if (typeof window !== "undefined") {
+			let absoluteUrl = "";
+			if (!baseUrl) absoluteUrl = window.location.origin;
+			else if (/^https?:\/\//i.test(baseUrl) || /^wss?:\/\//i.test(baseUrl)) absoluteUrl = baseUrl;
+			else try {
+				absoluteUrl = new URL(baseUrl, window.location.href).origin;
+			} catch {
+				absoluteUrl = window.location.origin;
+			}
+			const protocol = absoluteUrl.startsWith("https:") || absoluteUrl.startsWith("wss:") ? "wss:" : "ws:";
+			return absoluteUrl.replace(/^https?:\/\//i, `${protocol}//`).replace(/^wss?:\/\//i, `${protocol}//`).replace(/\/$/, "");
+		}
+		if (!baseUrl) return "";
+		if (!/^https?:\/\//i.test(baseUrl) && !/^wss?:\/\//i.test(baseUrl)) return "";
+		return baseUrl.replace(/^https?:\/\//i, (match) => match.toLowerCase() === "https://" ? "wss://" : "ws://").replace(/\/$/, "");
+	}
+	function createRebaseClient(options) {
+		const transport = createTransport(options);
+		const auth = createAuth(transport, options.auth);
+		const admin = createAdmin(transport, options.admin);
+		const cron = createCron(transport, options.cron);
+		const storage = createStorage(transport);
+		const functions = createFunctionsClient(transport);
+		const resolvedWsUrl = options.websocketUrl ?? deriveWebSocketUrl(options.baseUrl);
+		let ws;
+		if (resolvedWsUrl) {
+			ws = new RebaseWebSocketClient({
+				websocketUrl: resolvedWsUrl,
+				getAuthToken: async () => {
+					let session = auth.getSession();
+					if (session && session.expiresAt <= Date.now() + 1e4) try {
+						session = await auth.refreshSession();
+					} catch (e) {}
+					return session?.accessToken || options.token || "";
+				},
+				onUnauthorized: options.onUnauthorized || (async () => {
+					try {
+						await auth.refreshSession();
+						return true;
+					} catch (e) {
+						return false;
+					}
+				})
+			});
+			auth.onAuthStateChange((event, session) => {
+				if (!ws) return;
+				if (event === "SIGNED_OUT") ws.disconnect();
+				else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
+					if (session?.accessToken) ws.authenticate(session.accessToken).catch(console.warn);
+				}
+			});
+		}
+		if (!options.onUnauthorized) transport.setOnUnauthorized(async () => {
+			try {
+				await auth.refreshSession();
+				return true;
+			} catch (e) {
+				return false;
+			}
+		});
+		const collectionClients = /* @__PURE__ */ new Map();
+		function collection(slug) {
+			if (!collectionClients.has(slug)) collectionClients.set(slug, createCollectionClient(transport, slug, ws));
+			return collectionClients.get(slug);
+		}
+		const dataProxy = new Proxy({ collection }, { get(_target, prop) {
+			if (prop === "collection") return collection;
+			if (typeof prop === "symbol") return void 0;
+			if (typeof prop === "string" && prop !== "then" && prop !== "toJSON" && prop !== "$$typeof") return collection((0, _rebasepro_utils.toSnakeCase)(prop));
+		} });
+		return {
+			auth,
+			admin,
+			cron,
+			functions,
+			storage,
+			ws,
+			setToken: transport.setToken,
+			setAuthTokenGetter: transport.setAuthTokenGetter,
+			setOnUnauthorized: transport.setOnUnauthorized,
+			resolveToken: transport.resolveToken,
+			baseUrl: transport.baseUrl,
+			collection,
+			call: async (endpoint, payload) => {
+				const prefix = endpoint.startsWith("/") ? "" : "/";
+				const res = await transport.request(`${prefix}${endpoint}`, {
+					method: "POST",
+					body: payload ? JSON.stringify(payload) : void 0
+				});
+				return res.data ?? res;
+			},
+			data: dataProxy,
+			email: void 0
+		};
+	}
+	//#endregion
+	exports.ApiError = ApiError;
+	Object.defineProperty(exports, "QueryBuilder", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_common.QueryBuilder;
+		}
+	});
+	exports.RebaseApiError = RebaseApiError;
+	exports.RebaseWebSocketClient = RebaseWebSocketClient;
+	Object.defineProperty(exports, "and", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_common.and;
+		}
+	});
+	exports.buildQueryString = buildQueryString;
+	Object.defineProperty(exports, "cond", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_common.cond;
+		}
+	});
+	exports.createAdmin = createAdmin;
+	exports.createAuth = createAuth;
+	exports.createCollectionClient = createCollectionClient;
+	exports.createCookieStorage = createCookieStorage;
+	exports.createCron = createCron;
+	exports.createFunctionsClient = createFunctionsClient;
+	exports.createMemoryStorage = createMemoryStorage;
+	exports.createRebaseClient = createRebaseClient;
+	exports.createStorage = createStorage;
+	exports.createTransport = createTransport;
+	Object.defineProperty(exports, "or", {
+		enumerable: true,
+		get: function() {
+			return _rebasepro_common.or;
+		}
+	});
+	exports.rebaseReviver = rebaseReviver;
 });
-//# sourceMappingURL=index.umd.js.map
+
+//# sourceMappingURL=index.umd.js.map