@tiquo/dom-package 1.0.0 → 1.1.0

package/dist/index.js

@@ -22,10 +22,154 @@ var index_exports = {};
 __export(index_exports, {
   TiquoAuth: () => TiquoAuth,
   TiquoAuthError: () => TiquoAuthError,
+  addCustomerUserId: () => addCustomerUserId,
+  clearCachedEmail: () => clearCachedEmail,
   default: () => index_default,
+  getCustomerUserIds: () => getCustomerUserIds,
+  getPrefilledEmailFromCookie: () => getPrefilledEmailFromCookie,
+  isClerkAuthenticated: () => isClerkAuthenticated,
+  trackCustomerPresence: () => trackCustomerPresence,
   useTiquoAuth: () => useTiquoAuth
 });
 module.exports = __toCommonJS(index_exports);
+
+// src/customer-cookie.ts
+var COOKIE_NAME = "tiquo_customer_user_ids";
+var COOKIE_MAX_AGE = 31536e3;
+function isClerkAuthenticated() {
+  if (typeof document === "undefined") return false;
+  return document.cookie.includes("__clerk_db_jwt") || document.cookie.includes("__session");
+}
+function getCustomerUserIds() {
+  if (typeof document === "undefined") return [];
+  const match = document.cookie.match(new RegExp(`${COOKIE_NAME}=([^;]+)`));
+  if (match) {
+    try {
+      const decoded = decodeURIComponent(match[1]);
+      const parsed = JSON.parse(decoded);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((id) => typeof id === "string");
+      }
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function addCustomerUserId(userId) {
+  if (typeof document === "undefined") return;
+  if (typeof window === "undefined") return;
+  if (isClerkAuthenticated()) {
+    console.log("[Customer Cookie] Skipping - Clerk user detected");
+    return;
+  }
+  if (!userId || typeof userId !== "string") {
+    console.warn("[Customer Cookie] Invalid userId provided");
+    return;
+  }
+  const existing = getCustomerUserIds();
+  if (existing.includes(userId)) {
+    console.log("[Customer Cookie] User ID already in cookie");
+    return;
+  }
+  existing.push(userId);
+  const hostname = window.location.hostname;
+  const isProduction = hostname.endsWith(".tiquo.app") || hostname === "tiquo.app";
+  const cookieParts = [
+    `${COOKIE_NAME}=${encodeURIComponent(JSON.stringify(existing))}`,
+    "path=/",
+    `max-age=${COOKIE_MAX_AGE}`,
+    "SameSite=Lax"
+  ];
+  if (isProduction) {
+    cookieParts.push("domain=.tiquo.app");
+    cookieParts.push("Secure");
+  }
+  document.cookie = cookieParts.join("; ");
+  console.log("[Customer Cookie] Added user ID to cookie:", userId);
+}
+var CONVEX_SITE_URL = "https://edge.tiquo.app";
+var cachedEmailData = null;
+var EMAIL_CACHE_TTL = 5 * 60 * 1e3;
+async function getPrefilledEmailFromCookie(organizationId) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (isClerkAuthenticated()) {
+    return null;
+  }
+  const userIds = getCustomerUserIds();
+  if (userIds.length === 0) {
+    return null;
+  }
+  if (cachedEmailData && cachedEmailData.organizationId === organizationId && Date.now() - cachedEmailData.fetchedAt < EMAIL_CACHE_TTL) {
+    return {
+      email: cachedEmailData.email,
+      firstName: cachedEmailData.firstName,
+      lastName: cachedEmailData.lastName
+    };
+  }
+  try {
+    const response = await fetch(`${CONVEX_SITE_URL}/api/customer-cookie-email`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ userIds, organizationId })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.success && data.email) {
+        cachedEmailData = {
+          organizationId,
+          email: data.email,
+          firstName: data.firstName,
+          lastName: data.lastName,
+          fetchedAt: Date.now()
+        };
+        return {
+          email: data.email,
+          firstName: data.firstName,
+          lastName: data.lastName
+        };
+      }
+    }
+    return null;
+  } catch (error) {
+    console.error("[Customer Cookie] Failed to get prefilled email:", error);
+    return null;
+  }
+}
+function clearCachedEmail() {
+  cachedEmailData = null;
+}
+async function trackCustomerPresence(organizationId) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "Not in browser environment" };
+  }
+  if (isClerkAuthenticated()) {
+    return { success: false, error: "Clerk user detected" };
+  }
+  const userIds = getCustomerUserIds();
+  if (userIds.length === 0) {
+    return { success: false, error: "No user IDs in cookie" };
+  }
+  try {
+    const response = await fetch(`${CONVEX_SITE_URL}/api/customer-presence`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ userIds, organizationId })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data;
+    }
+    return { success: false, error: "Failed to track presence" };
+  } catch (error) {
+    console.error("[Customer Cookie] Failed to track presence:", error);
+    return { success: false, error: "Network error" };
+  }
+}
+
+// src/index.ts
 var TiquoAuthError = class extends Error {
   constructor(message, code, statusCode) {
     super(message);
@@ -34,12 +178,32 @@ var TiquoAuthError = class extends Error {
     this.name = "TiquoAuthError";
   }
 };
+function decodeJWT(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = parts[1];
+    const decoded = atob(payload.replace(/-/g, "+").replace(/_/g, "/"));
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function isTokenExpired(token, bufferSeconds = 300) {
+  const payload = decodeJWT(token);
+  if (!payload) return true;
+  const expiresAt = payload.exp * 1e3;
+  const bufferMs = bufferSeconds * 1e3;
+  return Date.now() > expiresAt - bufferMs;
+}
 var TiquoAuth = class {
   constructor(config) {
-    this.sessionToken = null;
+    this.accessToken = null;
+    this.refreshToken = null;
     this.session = null;
     this.listeners = /* @__PURE__ */ new Set();
     this.refreshTimer = null;
+    this.isRefreshing = false;
     // Multi-tab sync
     this.broadcastChannel = null;
     this.isProcessingTabSync = false;
@@ -57,14 +221,17 @@ var TiquoAuth = class {
       apiEndpoint: config.apiEndpoint || "https://edge.tiquo.app",
       storagePrefix: config.storagePrefix || "tiquo_auth_",
       debug: config.debug || false,
-      enableTabSync: config.enableTabSync !== false
+      enableTabSync: config.enableTabSync !== false,
       // Default true
+      accessToken: config.accessToken,
+      refreshToken: config.refreshToken
     };
     this.tabId = this.generateTabId();
     if (this.config.enableTabSync) {
       this.initTabSync();
     }
-    this.restoreSession();
+    this.checkForInjectedTokens();
+    this.restoreTokens();
   }
   // ============================================
   // PUBLIC METHODS
@@ -109,13 +276,19 @@ var TiquoAuth = class {
       throw new TiquoAuthError(error.error || "Invalid OTP", "OTP_VERIFY_FAILED", response.status);
     }
     const result = await response.json();
-    this.sessionToken = result.sessionToken;
-    this.saveSession();
+    this.accessToken = result.accessToken;
+    this.refreshToken = result.refreshToken;
+    this.saveTokens();
     await this.refreshSession();
+    if (this.session?.user?.id) {
+      addCustomerUserId(this.session.user.id);
+    }
     this.broadcastTabSync("LOGIN");
     return {
       success: true,
-      sessionToken: result.sessionToken,
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresIn: result.expiresIn,
       expiresAt: result.expiresAt,
       isNewUser: result.isNewUser,
       hasCustomer: result.hasCustomer
@@ -125,10 +298,11 @@ var TiquoAuth = class {
    * Get the current authenticated user and customer data
    */
   async getUser() {
-    if (!this.sessionToken) {
+    if (!this.accessToken) {
       return null;
     }
-    if (this.session && this.session.expiresAt > Date.now()) {
+    await this.refreshTokenIfNeeded();
+    if (this.session) {
       return this.session;
     }
     return this.refreshSession();
@@ -137,60 +311,49 @@ var TiquoAuth = class {
    * Check if user is currently authenticated
    */
   isAuthenticated() {
-    return !!this.sessionToken && (!this.session || this.session.expiresAt > Date.now());
+    return !!this.accessToken && !isTokenExpired(this.accessToken, 0);
   }
   /**
    * Update the authenticated customer's profile
    * Only allows updating the logged-in customer's own data
    */
   async updateProfile(updates) {
-    if (!this.sessionToken) {
-      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
-    }
+    await this.ensureValidToken();
     this.log("Updating customer profile:", updates);
-    const response = await this.request("/api/auth-dom/profile", {
+    const response = await this.request("/api/client/v1/profile", {
       method: "PATCH",
-      body: JSON.stringify({
-        publicKey: this.config.publicKey,
-        sessionToken: this.sessionToken,
-        updates
-      })
+      body: JSON.stringify(updates)
     });
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: "Failed to update profile" }));
       throw new TiquoAuthError(error.error || "Failed to update profile", "PROFILE_UPDATE_FAILED", response.status);
     }
     const result = await response.json();
-    if (this.session && result.customer) {
+    if (this.session && result.data?.customer) {
       this.session = {
         ...this.session,
-        customer: {
-          id: result.customer.id,
-          firstName: result.customer.firstName,
-          lastName: result.customer.lastName,
-          displayName: result.customer.displayName,
-          customerNumber: result.customer.customerNumber,
-          email: result.customer.email,
-          phone: result.customer.phone
-        }
+        customer: result.data.customer
       };
       this.notifyListeners();
       this.broadcastTabSync("SESSION_UPDATE");
     }
-    return result;
+    return {
+      success: true,
+      customer: result.data?.customer
+    };
   }
   /**
    * Log out the current user
    */
   async logout() {
     this.log("Logging out");
-    if (this.sessionToken) {
+    if (this.refreshToken) {
       try {
         await this.request("/api/auth-dom/logout", {
           method: "POST",
           body: JSON.stringify({
             publicKey: this.config.publicKey,
-            sessionToken: this.sessionToken
+            refreshToken: this.refreshToken
           })
         });
       } catch (error) {
@@ -198,7 +361,7 @@ var TiquoAuth = class {
       }
     }
     this.broadcastTabSync("LOGOUT");
-    this.clearSession();
+    this.clearTokens();
   }
   /**
    * Subscribe to authentication state changes
@@ -215,12 +378,9 @@ var TiquoAuth = class {
    * Only returns orders for the logged-in customer
    */
   async getOrders(options) {
-    if (!this.sessionToken) {
-      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
-    }
+    await this.ensureValidToken();
     this.log("Fetching customer orders:", options);
-    const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/orders`);
-    url.searchParams.set("publicKey", this.config.publicKey);
+    const url = new URL(`${this.config.apiEndpoint}/api/client/v1/orders`);
     if (options?.limit) {
       url.searchParams.set("limit", options.limit.toString());
     }
@@ -233,7 +393,7 @@ var TiquoAuth = class {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.sessionToken}`
+        "Authorization": `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
@@ -241,19 +401,17 @@ var TiquoAuth = class {
       const error = await response.json().catch(() => ({ error: "Failed to get orders" }));
       throw new TiquoAuthError(error.error || "Failed to get orders", "GET_ORDERS_FAILED", response.status);
     }
-    return response.json();
+    const result = await response.json();
+    return result.data || { orders: [], hasMore: false };
   }
   /**
    * Get the authenticated customer's booking history
    * Only returns bookings for the logged-in customer
    */
   async getBookings(options) {
-    if (!this.sessionToken) {
-      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
-    }
+    await this.ensureValidToken();
     this.log("Fetching customer bookings:", options);
-    const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/bookings`);
-    url.searchParams.set("publicKey", this.config.publicKey);
+    const url = new URL(`${this.config.apiEndpoint}/api/client/v1/bookings`);
     if (options?.limit) {
       url.searchParams.set("limit", options.limit.toString());
     }
@@ -269,7 +427,7 @@ var TiquoAuth = class {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.sessionToken}`
+        "Authorization": `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
@@ -277,19 +435,17 @@ var TiquoAuth = class {
       const error = await response.json().catch(() => ({ error: "Failed to get bookings" }));
       throw new TiquoAuthError(error.error || "Failed to get bookings", "GET_BOOKINGS_FAILED", response.status);
     }
-    return response.json();
+    const result = await response.json();
+    return result.data || { bookings: [], hasMore: false };
   }
   /**
    * Get the authenticated customer's enquiry history
    * Only returns enquiries for the logged-in customer
    */
   async getEnquiries(options) {
-    if (!this.sessionToken) {
-      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
-    }
+    await this.ensureValidToken();
     this.log("Fetching customer enquiries:", options);
-    const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/enquiries`);
-    url.searchParams.set("publicKey", this.config.publicKey);
+    const url = new URL(`${this.config.apiEndpoint}/api/client/v1/enquiries`);
     if (options?.limit) {
       url.searchParams.set("limit", options.limit.toString());
     }
@@ -302,7 +458,7 @@ var TiquoAuth = class {
     const response = await fetch(url.toString(), {
       method: "GET",
       headers: {
-        "Authorization": `Bearer ${this.sessionToken}`
+        "Authorization": `Bearer ${this.accessToken}`
       },
       credentials: "include"
     });
@@ -310,21 +466,20 @@ var TiquoAuth = class {
       const error = await response.json().catch(() => ({ error: "Failed to get enquiries" }));
       throw new TiquoAuthError(error.error || "Failed to get enquiries", "GET_ENQUIRIES_FAILED", response.status);
     }
-    return response.json();
+    const result = await response.json();
+    return result.data || { enquiries: [], hasMore: false };
   }
   /**
    * Generate a short-lived token for customer flow iframe authentication
    */
   async getIframeToken(customerFlowId) {
-    if (!this.sessionToken) {
-      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
-    }
+    await this.ensureValidToken();
     this.log("Generating iframe token");
     const response = await this.request("/api/auth-dom/iframe-token", {
       method: "POST",
       body: JSON.stringify({
         publicKey: this.config.publicKey,
-        sessionToken: this.sessionToken,
+        sessionToken: this.accessToken,
         customerFlowId
       })
     });
@@ -347,7 +502,7 @@ var TiquoAuth = class {
       throw new TiquoAuthError("Container element not found", "CONTAINER_NOT_FOUND");
     }
     let authToken;
-    if (this.sessionToken) {
+    if (this.accessToken) {
       try {
         const { token } = await this.getIframeToken();
         authToken = token;
@@ -377,22 +532,71 @@ var TiquoAuth = class {
     return iframe;
   }
   /**
-   * Get the current session token (for advanced use cases)
+   * Get the current access token (for advanced use cases)
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Get the current refresh token (for advanced use cases)
    */
-  getSessionToken() {
-    return this.sessionToken;
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  /**
+   * Initialize with external tokens (for WebView integration)
+   */
+  initWithTokens(accessToken, refreshToken) {
+    this.log("Initializing with external tokens");
+    this.accessToken = accessToken;
+    this.refreshToken = refreshToken || null;
+    this.saveTokens();
+    this.refreshSession();
+    this.broadcastTabSync("LOGIN");
   }
   // ============================================
   // PRIVATE METHODS
   // ============================================
+  /**
+   * Check for tokens injected by native apps (WebView integration)
+   */
+  checkForInjectedTokens() {
+    if (typeof window === "undefined") return;
+    if (this.config.accessToken) {
+      this.log("Found token in config");
+      this.accessToken = this.config.accessToken;
+      this.refreshToken = this.config.refreshToken || null;
+      return;
+    }
+    if (window.__TIQUO_INIT_TOKEN__?.accessToken) {
+      this.log("Found token in window.__TIQUO_INIT_TOKEN__");
+      this.accessToken = window.__TIQUO_INIT_TOKEN__.accessToken;
+      this.refreshToken = window.__TIQUO_INIT_TOKEN__.refreshToken || null;
+      delete window.__TIQUO_INIT_TOKEN__;
+      return;
+    }
+    if (window.location.hash) {
+      const params = new URLSearchParams(window.location.hash.slice(1));
+      const accessToken = params.get("access_token");
+      if (accessToken) {
+        this.log("Found token in URL fragment");
+        this.accessToken = accessToken;
+        this.refreshToken = params.get("refresh_token");
+        if (window.history?.replaceState) {
+          window.history.replaceState(null, "", window.location.pathname + window.location.search);
+        }
+        return;
+      }
+    }
+  }
   async request(path, options) {
     const url = `${this.config.apiEndpoint}${path}`;
     const headers = {
       "Content-Type": "application/json",
       ...options.headers
     };
-    if (this.sessionToken && !(typeof options.body === "string" && options.body.includes("sessionToken"))) {
-      headers["Authorization"] = `Bearer ${this.sessionToken}`;
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
     }
     return fetch(url, {
       ...options,
@@ -400,73 +604,171 @@ var TiquoAuth = class {
       credentials: "include"
     });
   }
+  /**
+   * Ensure we have a valid access token, refreshing if necessary
+   */
+  async ensureValidToken() {
+    if (!this.accessToken) {
+      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
+    }
+    await this.refreshTokenIfNeeded();
+    if (!this.accessToken) {
+      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
+    }
+  }
+  /**
+   * Refresh the access token if it's expired or about to expire
+   */
+  async refreshTokenIfNeeded() {
+    if (!this.accessToken || !this.refreshToken) {
+      return false;
+    }
+    if (!isTokenExpired(this.accessToken, 300)) {
+      return true;
+    }
+    return this.performTokenRefresh();
+  }
+  /**
+   * Perform the actual token refresh
+   */
+  async performTokenRefresh() {
+    if (this.isRefreshing) {
+      return new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (!this.isRefreshing) {
+            clearInterval(checkInterval);
+            resolve(!!this.accessToken);
+          }
+        }, 100);
+      });
+    }
+    if (!this.refreshToken) {
+      return false;
+    }
+    this.isRefreshing = true;
+    this.log("Refreshing access token");
+    try {
+      const response = await fetch(`${this.config.apiEndpoint}/api/client/v1/refresh`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          refresh_token: this.refreshToken
+        }),
+        credentials: "include"
+      });
+      if (!response.ok) {
+        this.log("Token refresh failed, clearing session");
+        this.clearTokens();
+        return false;
+      }
+      const result = await response.json();
+      if (result.success && result.data) {
+        this.accessToken = result.data.access_token;
+        this.refreshToken = result.data.refresh_token;
+        this.saveTokens();
+        this.scheduleRefresh();
+        this.broadcastTabSync("TOKEN_REFRESH");
+        this.log("Token refreshed successfully");
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.log("Token refresh error:", error);
+      return false;
+    } finally {
+      this.isRefreshing = false;
+    }
+  }
   async refreshSession() {
-    if (!this.sessionToken) {
+    if (!this.accessToken) {
       return null;
     }
     try {
-      const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/session`);
-      url.searchParams.set("publicKey", this.config.publicKey);
-      const response = await fetch(url.toString(), {
+      await this.refreshTokenIfNeeded();
+      const response = await fetch(`${this.config.apiEndpoint}/api/client/v1/profile`, {
         method: "GET",
         headers: {
-          "Authorization": `Bearer ${this.sessionToken}`
+          "Authorization": `Bearer ${this.accessToken}`
         },
         credentials: "include"
       });
       if (!response.ok) {
         this.log("Session invalid, clearing");
-        this.clearSession();
+        this.clearTokens();
         return null;
       }
-      const data = await response.json();
-      this.session = {
-        user: data.user,
-        customer: data.customer,
-        expiresAt: data.session.expiresAt
-      };
-      this.notifyListeners();
-      this.scheduleRefresh();
-      return this.session;
+      const result = await response.json();
+      if (result.success && result.data) {
+        const payload = decodeJWT(this.accessToken);
+        const expiresAt = payload?.exp ? payload.exp * 1e3 : Date.now() + 36e5;
+        this.session = {
+          user: result.data.user,
+          customer: result.data.customer,
+          expiresAt
+        };
+        if (this.session.user?.id) {
+          addCustomerUserId(this.session.user.id);
+        }
+        this.notifyListeners();
+        this.scheduleRefresh();
+        return this.session;
+      }
+      return null;
     } catch (error) {
       this.log("Session refresh error:", error);
       return null;
     }
   }
-  saveSession() {
-    if (this.sessionToken) {
-      try {
+  saveTokens() {
+    try {
+      if (this.accessToken) {
         localStorage.setItem(
-          `${this.config.storagePrefix}session`,
-          this.sessionToken
+          `${this.config.storagePrefix}access_token`,
+          this.accessToken
         );
-      } catch (error) {
-        this.log("Failed to save session to storage:", error);
       }
+      if (this.refreshToken) {
+        localStorage.setItem(
+          `${this.config.storagePrefix}refresh_token`,
+          this.refreshToken
+        );
+      }
+    } catch (error) {
+      this.log("Failed to save tokens to storage:", error);
     }
   }
-  restoreSession() {
+  restoreTokens() {
+    if (this.accessToken) {
+      this.refreshSession();
+      return;
+    }
     try {
-      const token = localStorage.getItem(`${this.config.storagePrefix}session`);
-      if (token) {
-        this.sessionToken = token;
+      const accessToken = localStorage.getItem(`${this.config.storagePrefix}access_token`);
+      const refreshToken = localStorage.getItem(`${this.config.storagePrefix}refresh_token`);
+      if (accessToken) {
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
         this.refreshSession();
       }
     } catch (error) {
-      this.log("Failed to restore session from storage:", error);
+      this.log("Failed to restore tokens from storage:", error);
     }
   }
-  clearSession() {
-    this.sessionToken = null;
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshToken = null;
     this.session = null;
     if (this.refreshTimer) {
       clearTimeout(this.refreshTimer);
       this.refreshTimer = null;
     }
     try {
-      localStorage.removeItem(`${this.config.storagePrefix}session`);
+      localStorage.removeItem(`${this.config.storagePrefix}access_token`);
+      localStorage.removeItem(`${this.config.storagePrefix}refresh_token`);
     } catch (error) {
-      this.log("Failed to clear session from storage:", error);
+      this.log("Failed to clear tokens from storage:", error);
     }
     this.notifyListeners();
   }
@@ -483,11 +785,14 @@ var TiquoAuth = class {
     if (this.refreshTimer) {
       clearTimeout(this.refreshTimer);
     }
-    if (!this.session) return;
-    const refreshIn = this.session.expiresAt - Date.now() - 5 * 60 * 1e3;
+    if (!this.accessToken) return;
+    const payload = decodeJWT(this.accessToken);
+    if (!payload) return;
+    const expiresAt = payload.exp * 1e3;
+    const refreshIn = expiresAt - Date.now() - 5 * 60 * 1e3;
     if (refreshIn > 0) {
       this.refreshTimer = setTimeout(() => {
-        this.refreshSession();
+        this.performTokenRefresh();
       }, refreshIn);
     }
   }
@@ -524,7 +829,8 @@ var TiquoAuth = class {
       type,
       tabId: this.tabId,
       timestamp: Date.now(),
-      sessionToken: type === "LOGOUT" ? null : this.sessionToken,
+      accessToken: type === "LOGOUT" ? null : this.accessToken,
+      refreshToken: type === "LOGOUT" ? null : this.refreshToken,
       session: type === "LOGOUT" ? null : this.session
     };
     try {
@@ -542,24 +848,30 @@ var TiquoAuth = class {
     try {
       switch (message.type) {
         case "LOGIN":
-          if (message.sessionToken && message.session) {
-            this.sessionToken = message.sessionToken;
-            this.session = message.session;
-            this.saveSession();
+        case "TOKEN_REFRESH":
+          if (message.accessToken) {
+            this.accessToken = message.accessToken;
+            this.refreshToken = message.refreshToken || null;
+            if (message.session) {
+              this.session = message.session;
+            }
+            this.saveTokens();
             this.scheduleRefresh();
             this.notifyListeners();
-            this.log("Session synced from another tab (login)");
+            this.log("Tokens synced from another tab");
           }
           break;
         case "LOGOUT":
-          this.sessionToken = null;
+          this.accessToken = null;
+          this.refreshToken = null;
           this.session = null;
           if (this.refreshTimer) {
             clearTimeout(this.refreshTimer);
             this.refreshTimer = null;
           }
           try {
-            localStorage.removeItem(`${this.config.storagePrefix}session`);
+            localStorage.removeItem(`${this.config.storagePrefix}access_token`);
+            localStorage.removeItem(`${this.config.storagePrefix}refresh_token`);
           } catch {
           }
           this.notifyListeners();
@@ -633,5 +945,11 @@ var index_default = TiquoAuth;
 0 && (module.exports = {
   TiquoAuth,
   TiquoAuthError,
+  addCustomerUserId,
+  clearCachedEmail,
+  getCustomerUserIds,
+  getPrefilledEmailFromCookie,
+  isClerkAuthenticated,
+  trackCustomerPresence,
   useTiquoAuth
 });