@cimplify/sdk 0.104.0 → 0.104.1

package/dist/{chunk-OKADBZAI.mjs → chunk-UFOWPN3D.mjs}

@@ -1,6 +1,333 @@
 import { messagePreview } from './chunk-U4MW6PYU.mjs';
-import { safe, generateIdempotencyKey, err, ok, CatalogueQueries, CartOperations, CheckoutService, OrderQueries, LinkService, AuthService, BusinessService, InventoryService, SchedulingService, LiteService, FxService, createElements } from './chunk-OCCNG6MO.mjs';
-import { CimplifyError, ErrorCode, IdempotencyMismatchError, enrichError } from './chunk-H3RATH4B.mjs';
+import { ok, err, safe, generateIdempotencyKey, createDefaultPaymentAuthorizationAdapterRegistry, CatalogueQueries, CartOperations, CheckoutService, OrderQueries, LinkService, AuthService, BusinessService, InventoryService, SchedulingService, LiteService, FxService, createElements } from './chunk-V4457OKB.mjs';
+import { PURCHASE_INTENT_RESOLVE_STATUS, PURCHASE_INTENT_CONFIRM_STATUS, PURCHASE_INTENT_RESOLUTION_KIND, PURCHASE_INTENT_ACTION_DECISION, CimplifyError, PURCHASE_INTENT_ERROR_CODE, ErrorCode, IdempotencyMismatchError, enrichError } from './chunk-RBNBSQI7.mjs';
+
+// src/types/observability.ts
+var SESSION_CHANGE_SOURCE = {
+  RESPONSE: "response",
+  MANUAL: "manual",
+  CLEAR: "clear"
+};
+
+// src/utils/purchase-intent-resolver.ts
+var DEFAULT_POLL_INTERVAL_MS = 3e3;
+var DEFAULT_MAX_POLL_ATTEMPTS = 60;
+var DEFAULT_MAX_ACTION_STEPS = 4;
+var DEFAULT_MAX_TERMS_REVIEW_STEPS = 4;
+function nonnegativeInteger(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function abortError() {
+  const error = new Error("Purchase-intent resolution was cancelled.");
+  error.name = "AbortError";
+  return error;
+}
+async function abortableWait(milliseconds, signal) {
+  if (signal?.aborted) throw abortError();
+  if (milliseconds <= 0) return;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, milliseconds);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var PurchaseIntentResolver = class {
+  constructor(dependencies) {
+    this.confirmation = dependencies.confirmation;
+    this.wait = dependencies.wait ?? abortableWait;
+  }
+  async resolve(intentId, options) {
+    const pollIntervalMs = nonnegativeInteger(
+      options.pollIntervalMs,
+      DEFAULT_POLL_INTERVAL_MS
+    );
+    const maxPollAttempts = nonnegativeInteger(
+      options.maxPollAttempts,
+      DEFAULT_MAX_POLL_ATTEMPTS
+    );
+    const maxActionSteps = nonnegativeInteger(options.maxActionSteps, DEFAULT_MAX_ACTION_STEPS);
+    const maxTermsReviewSteps = nonnegativeInteger(
+      options.maxTermsReviewSteps,
+      DEFAULT_MAX_TERMS_REVIEW_STEPS
+    );
+    let request = options.confirmation;
+    let pollAttempts = 0;
+    let actionSteps = 0;
+    let termsReviewSteps = 0;
+    this.ensureActive(options.signal);
+    this.notify(options, PURCHASE_INTENT_RESOLVE_STATUS.CONFIRMING);
+    let responseResult = options.initialResponse ? ok(options.initialResponse) : await this.confirmation.confirm(intentId, request, { signal: options.signal });
+    while (responseResult.ok) {
+      this.ensureActive(options.signal);
+      const response = responseResult.value;
+      switch (response.status) {
+        case PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED:
+          this.notify(options, PURCHASE_INTENT_RESOLVE_STATUS.COMPLETED, response);
+          return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.COMPLETED, response });
+        case PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED:
+          this.notify(options, PURCHASE_INTENT_RESOLVE_STATUS.FAILED, response);
+          return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.FAILED, response });
+        case PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_OUTCOME_UNKNOWN:
+          this.notify(options, PURCHASE_INTENT_RESOLVE_STATUS.OUTCOME_UNKNOWN, response);
+          return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.OUTCOME_UNKNOWN, response });
+        case PURCHASE_INTENT_CONFIRM_STATUS.COLLECTION_PROCESSING:
+          if (pollAttempts >= maxPollAttempts) {
+            return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.TIMED_OUT, response });
+          }
+          pollAttempts += 1;
+          this.notify(options, PURCHASE_INTENT_RESOLVE_STATUS.POLLING, response);
+          await this.wait(pollIntervalMs, options.signal);
+          responseResult = await this.confirmation.confirm(intentId, request, {
+            signal: options.signal
+          });
+          continue;
+        case PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED:
+        case PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED:
+        case PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED: {
+          this.notify(options, PURCHASE_INTENT_RESOLVE_STATUS.AWAITING_ACTION, response);
+          if (!options.onActionRequired || actionSteps >= maxActionSteps) {
+            return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED, response });
+          }
+          actionSteps += 1;
+          const decision = await options.onActionRequired(response);
+          if (decision === PURCHASE_INTENT_ACTION_DECISION.STOP) {
+            return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED, response });
+          }
+          if (typeof decision === "object" && decision.kind === PURCHASE_INTENT_ACTION_DECISION.SUBMIT) {
+            if (!this.confirmation.submitAction) {
+              return err(
+                new CimplifyError(
+                  PURCHASE_INTENT_ERROR_CODE.ACTION_UNSUPPORTED,
+                  "This confirmation transport cannot submit purchase-intent actions.",
+                  false
+                )
+              );
+            }
+            responseResult = await this.confirmation.submitAction(
+              intentId,
+              response.attempt_id,
+              decision.request,
+              { signal: options.signal }
+            );
+            continue;
+          }
+          if (decision !== PURCHASE_INTENT_ACTION_DECISION.CONTINUE) {
+            return err(
+              new CimplifyError(
+                PURCHASE_INTENT_ERROR_CODE.ACTION_UNSUPPORTED,
+                "The action callback returned an unsupported decision.",
+                false
+              )
+            );
+          }
+          await this.wait(pollIntervalMs, options.signal);
+          responseResult = await this.confirmation.confirm(intentId, request, {
+            signal: options.signal
+          });
+          continue;
+        }
+        case PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED: {
+          this.notify(options, PURCHASE_INTENT_RESOLVE_STATUS.REVIEWING_TERMS, response);
+          if (!options.onTermsChanged || termsReviewSteps >= maxTermsReviewSteps) {
+            return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED, response });
+          }
+          termsReviewSteps += 1;
+          const replacementRequest = await options.onTermsChanged(response);
+          if (!replacementRequest) {
+            return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED, response });
+          }
+          request = replacementRequest;
+          responseResult = await this.confirmation.confirm(intentId, request, {
+            signal: options.signal
+          });
+          continue;
+        }
+        case PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
+        case PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
+        case PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
+          return ok({ kind: PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED, response });
+      }
+    }
+    return responseResult;
+  }
+  ensureActive(signal) {
+    if (signal?.aborted) throw abortError();
+  }
+  notify(options, status, response) {
+    try {
+      options.onStatusChange?.(status, response);
+    } catch {
+    }
+  }
+};
+
+// src/purchase-intent.ts
+var PURCHASE_INTENT_ROUTE = {
+  DIRECT_COLLECTION: "/api/v1/purchase-intents",
+  HOSTED_SESSION_COLLECTION: "/v1/checkout/sessions",
+  PREPARE: "prepare",
+  REFRESH: "refresh",
+  CONFIRM: "confirm",
+  REPLAY: "replay",
+  ATTEMPTS: "attempts",
+  ACTIONS: "actions"
+};
+function directIntentPath(intentId) {
+  const normalized = intentId.trim();
+  if (!normalized) throw new TypeError("intentId must not be empty");
+  return `${PURCHASE_INTENT_ROUTE.DIRECT_COLLECTION}/${encodeURIComponent(normalized)}`;
+}
+function hostedSessionPath(sessionId) {
+  const normalized = sessionId.trim();
+  if (!normalized) throw new TypeError("sessionId must not be empty");
+  return `${PURCHASE_INTENT_ROUTE.HOSTED_SESSION_COLLECTION}/${encodeURIComponent(normalized)}`;
+}
+var PurchaseIntentService = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.resolver = new PurchaseIntentResolver({ confirmation: this });
+  }
+  mint(request, options) {
+    return safe(
+      this.transport.post(PURCHASE_INTENT_ROUTE.DIRECT_COLLECTION, request, {
+        idempotencyKey: request.client_intent_key,
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs
+      })
+    );
+  }
+  get(intentId, options) {
+    return safe(
+      this.transport.get(this.intentPath(intentId), {
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs
+      })
+    );
+  }
+  refresh(intentId, expectedRevision, options) {
+    const request = {
+      expected_intent_revision: expectedRevision
+    };
+    return safe(
+      this.transport.post(
+        `${this.intentPath(intentId)}/${PURCHASE_INTENT_ROUTE.REFRESH}`,
+        request,
+        {
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  confirm(intentId, request, options) {
+    return safe(
+      this.transport.post(
+        `${this.intentPath(intentId)}/${PURCHASE_INTENT_ROUTE.CONFIRM}`,
+        request,
+        {
+          idempotencyKey: request.idempotency_key,
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  submitAction(intentId, attemptId, request, options) {
+    const normalizedAttemptId = attemptId.trim();
+    if (!normalizedAttemptId) throw new TypeError("attemptId must not be empty");
+    return safe(
+      this.transport.post(
+        `${this.intentPath(intentId)}/${PURCHASE_INTENT_ROUTE.ATTEMPTS}/${encodeURIComponent(normalizedAttemptId)}/${PURCHASE_INTENT_ROUTE.ACTIONS}`,
+        request,
+        {
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  resolve(intentId, options) {
+    return this.resolver.resolve(intentId, options);
+  }
+  /**
+   * Bind subsequent preparation/confirmation to one hosted checkout-session
+   * owner. The session ID is a route authority, not an intent-owner rewrite.
+   */
+  forHostedSession(sessionId) {
+    return new HostedPurchaseIntentService(this.transport, sessionId);
+  }
+  intentPath(intentId) {
+    return directIntentPath(intentId);
+  }
+};
+var HostedPurchaseIntentService = class {
+  constructor(transport, sessionId) {
+    this.transport = transport;
+    this.sessionPath = hostedSessionPath(sessionId);
+    this.resolver = new PurchaseIntentResolver({ confirmation: this });
+  }
+  prepare(request, options) {
+    return safe(
+      this.transport.post(
+        `${this.sessionPath}/${PURCHASE_INTENT_ROUTE.PREPARE}`,
+        request,
+        {
+          idempotencyKey: request.idempotency_key,
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  confirm(_intentId, request, options) {
+    return safe(
+      this.transport.post(
+        `${this.sessionPath}/${PURCHASE_INTENT_ROUTE.CONFIRM}`,
+        request,
+        {
+          idempotencyKey: request.idempotency_key,
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  replay(options) {
+    return safe(
+      this.transport.get(
+        `${this.sessionPath}/${PURCHASE_INTENT_ROUTE.REPLAY}`,
+        {
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  submitAction(_intentId, attemptId, request, options) {
+    const normalized = attemptId.trim();
+    if (!normalized) throw new TypeError("attemptId must not be empty");
+    return safe(
+      this.transport.post(
+        `${this.sessionPath}/${PURCHASE_INTENT_ROUTE.ATTEMPTS}/${encodeURIComponent(normalized)}/${PURCHASE_INTENT_ROUTE.ACTIONS}`,
+        request,
+        {
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  resolve(intentId, options) {
+    return this.resolver.resolve(intentId, options);
+  }
+};
 
 // src/store-credit.ts
 var StoreCreditQueries = class {
@@ -18,12 +345,13 @@ var StoreCreditQueries = class {
 
 // src/internal/analytics-session.ts
 var ANALYTICS_SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
-var ANALYTICS_SESSION_STORAGE_KEY = "cimplify_analytics_session";
-var ANALYTICS_SESSION_STATE_VERSION = 1;
+var ANALYTICS_SESSION_STORAGE_KEY_PREFIX = "cimplify_analytics_session:v2:";
+var ANALYTICS_SESSION_STATE_VERSION = 2;
 var MICROSECONDS_PER_MILLISECOND = 1e3;
 var MICROSECONDS_PER_SECOND = 1e6;
 var AnalyticsSessionCoordinator = class {
-  constructor() {
+  constructor(identity) {
+    this.identity = identity;
     this.fallbackState = null;
   }
   beginEvent(nowMs = Date.now()) {
@@ -61,7 +389,7 @@ var AnalyticsSessionCoordinator = class {
   reset() {
     this.fallbackState = null;
     try {
-      sessionStorage.removeItem(ANALYTICS_SESSION_STORAGE_KEY);
+      sessionStorage.removeItem(this.storageKey());
     } catch {
     }
   }
@@ -71,11 +399,11 @@ var AnalyticsSessionCoordinator = class {
   }
   read() {
     try {
-      const serialized = sessionStorage.getItem(ANALYTICS_SESSION_STORAGE_KEY);
+      const serialized = sessionStorage.getItem(this.storageKey());
       if (!serialized) return this.fallbackState;
       const state = JSON.parse(serialized);
       if (!isPersistedSession(state)) {
-        sessionStorage.removeItem(ANALYTICS_SESSION_STORAGE_KEY);
+        sessionStorage.removeItem(this.storageKey());
         return this.fallbackState;
       }
       this.fallbackState = state;
@@ -87,10 +415,13 @@ var AnalyticsSessionCoordinator = class {
   write(state) {
     this.fallbackState = state;
     try {
-      sessionStorage.setItem(ANALYTICS_SESSION_STORAGE_KEY, JSON.stringify(state));
+      sessionStorage.setItem(this.storageKey(), JSON.stringify(state));
     } catch {
     }
   }
+  storageKey() {
+    return `${ANALYTICS_SESSION_STORAGE_KEY_PREFIX}${encodeURIComponent(this.identity)}`;
+  }
 };
 function newSession(nowMs) {
   return {
@@ -157,11 +488,127 @@ function generateSessionId() {
 
 // src/activity.ts
 var VISITOR_ID_STORAGE_KEY = "cimplify_visitor_id";
+var ACTIVITY_RETRY_POLICY = {
+  maxRetries: 1,
+  jitterRatio: 0.2
+};
+var PAGE_VIEW_TRACKER_KEY = /* @__PURE__ */ Symbol.for("@cimplify/sdk.page-view-tracker-hub");
+var PAGE_VIEW_TRACKER_VERSION = 2;
+function trackerHost() {
+  return window;
+}
+function currentWindowTrackerHub() {
+  const candidate = trackerHost()[PAGE_VIEW_TRACKER_KEY];
+  return candidate?.version === PAGE_VIEW_TRACKER_VERSION && candidate.registrations instanceof Map && typeof candidate.recordAll === "function" ? candidate : null;
+}
+function weakReference(target) {
+  const WeakReference = globalThis.WeakRef;
+  if (WeakReference) return new WeakReference(target);
+  return { deref: () => target };
+}
+function latestLiveOwner(registration) {
+  let latest = null;
+  for (const [token, reference] of registration.owners) {
+    const owner = reference.deref();
+    if (!owner || owner.released) {
+      registration.owners.delete(token);
+    } else {
+      latest = owner;
+    }
+  }
+  return latest;
+}
+function recordRegistration(registration, path) {
+  if (path === registration.lastPath) return;
+  const owner = registration.activeOwner && !registration.activeOwner.released ? registration.activeOwner : latestLiveOwner(registration);
+  if (!owner) return;
+  registration.activeOwner = owner;
+  registration.lastPath = path;
+  owner.recorder(path);
+}
+function createWindowTrackerHub() {
+  const originalPushState = window.history.pushState;
+  const originalReplaceState = window.history.replaceState;
+  const hub = {
+    version: PAGE_VIEW_TRACKER_VERSION,
+    registrations: /* @__PURE__ */ new Map(),
+    originalPushState,
+    originalReplaceState
+  };
+  hub.recordAll = () => {
+    const path = window.location.pathname;
+    for (const registration of hub.registrations.values()) {
+      recordRegistration(registration, path);
+    }
+  };
+  hub.patchedPushState = function(...args) {
+    originalPushState.apply(this, args);
+    hub.recordAll();
+  };
+  hub.patchedReplaceState = function(...args) {
+    originalReplaceState.apply(this, args);
+    hub.recordAll();
+  };
+  hub.popstateListener = () => hub.recordAll();
+  window.history.pushState = hub.patchedPushState;
+  window.history.replaceState = hub.patchedReplaceState;
+  window.addEventListener("popstate", hub.popstateListener);
+  trackerHost()[PAGE_VIEW_TRACKER_KEY] = hub;
+  return hub;
+}
+function pageViewTrackerIdentity(client) {
+  return JSON.stringify([client.getBaseUrl(), client.getPublicKey().trim()]);
+}
+function acquireWindowPageViewTracker(identity, recorder) {
+  const hub = currentWindowTrackerHub() ?? createWindowTrackerHub();
+  let registration = hub.registrations.get(identity);
+  const isNewIdentity = !registration;
+  if (!registration) {
+    registration = { owners: /* @__PURE__ */ new Map(), activeOwner: null, lastPath: null };
+    hub.registrations.set(identity, registration);
+  }
+  const owner = {
+    token: Symbol(identity),
+    recorder,
+    released: false
+  };
+  registration.owners.set(owner.token, weakReference(owner));
+  registration.activeOwner = owner;
+  if (isNewIdentity) {
+    recordRegistration(registration, window.location.pathname);
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    owner.released = true;
+    registration.owners.delete(owner.token);
+    if (registration.activeOwner === owner) {
+      registration.activeOwner = latestLiveOwner(registration);
+    }
+    if (registration.activeOwner) return;
+    if (hub.registrations.get(identity) === registration) {
+      hub.registrations.delete(identity);
+    }
+    if (hub.registrations.size !== 0) return;
+    window.removeEventListener("popstate", hub.popstateListener);
+    if (window.history.pushState === hub.patchedPushState) {
+      window.history.pushState = hub.originalPushState;
+    }
+    if (window.history.replaceState === hub.patchedReplaceState) {
+      window.history.replaceState = hub.originalReplaceState;
+    }
+    if (currentWindowTrackerHub() === hub) {
+      delete trackerHost()[PAGE_VIEW_TRACKER_KEY];
+    }
+  };
+}
 var ActivityService = class {
   constructor(client) {
     this.client = client;
-    this.sessions = new AnalyticsSessionCoordinator();
+    this.localGeneration = 0;
     this.bootstrapRequest = null;
+    this.sessions = this.createSessionCoordinator();
   }
   /**
    * Record session start (landing, referrer, UTM, device). Fire-and-forget,
@@ -171,7 +618,7 @@ var ActivityService = class {
   startSession() {
     if (typeof window === "undefined") return;
     const session = this.sessions.beginEvent();
-    void this.bootstrapSession(session).catch(() => {
+    void this.bootstrapSession(session, false, this.captureGeneration()).catch(() => {
     });
   }
   /** Rebind an existing analytics session after the server authenticates a customer. */
@@ -179,13 +626,19 @@ var ActivityService = class {
     if (typeof window === "undefined") return;
     const session = this.sessions.current();
     if (!session) return;
-    void this.bootstrapSession(session, true).catch(() => {
+    void this.bootstrapSession(session, true, this.captureGeneration()).catch(() => {
     });
   }
   /** A signed-out browser starts a fresh anonymous analytics session. */
   resetSession() {
+    this.invalidatePendingActivity();
     this.sessions.reset();
-    this.bootstrapRequest = null;
+  }
+  /** Drop the old storefront's analytics state before binding this service to the new one. */
+  resetForStorefrontIdentityChange() {
+    this.invalidatePendingActivity();
+    this.sessions.reset();
+    this.sessions = this.createSessionCoordinator();
   }
   buildSessionPayload(session) {
     const params = new URLSearchParams(window.location.search);
@@ -281,32 +734,12 @@ var ActivityService = class {
   autoTrackPageViews() {
     if (typeof window === "undefined") return () => {
     };
-    let lastPath = null;
-    const record = () => {
-      const path = window.location.pathname;
-      if (path === lastPath) return;
-      lastPath = path;
+    return acquireWindowPageViewTracker(pageViewTrackerIdentity(this.client), (path) => {
       try {
         this.trackPageView({ pagePath: path });
       } catch {
       }
-    };
-    const { pushState, replaceState } = window.history;
-    window.history.pushState = function(...args) {
-      pushState.apply(this, args);
-      record();
-    };
-    window.history.replaceState = function(...args) {
-      replaceState.apply(this, args);
-      record();
-    };
-    window.addEventListener("popstate", record);
-    record();
-    return () => {
-      window.history.pushState = pushState;
-      window.history.replaceState = replaceState;
-      window.removeEventListener("popstate", record);
-    };
+    });
   }
   sendEvents(events, session) {
     if (typeof window === "undefined") return;
@@ -314,29 +747,59 @@ var ActivityService = class {
     });
   }
   async postEvents(events, session) {
-    await this.bootstrapSession(session);
-    await this.client.post("/api/v1/activity/events", {
-      analytics_session_id: session.id,
-      occurred_at: session.occurredAt,
-      events
-    });
+    const generation = this.captureGeneration();
+    await this.bootstrapSession(session, false, generation);
+    if (!this.isCurrentGeneration(generation)) return;
+    await this.client.post(
+      "/api/v1/activity/events",
+      {
+        analytics_session_id: session.id,
+        occurred_at: session.occurredAt,
+        events
+      },
+      { retryPolicy: ACTIVITY_RETRY_POLICY }
+    );
   }
-  bootstrapSession(session, force = false) {
+  bootstrapSession(session, force = false, generation = this.captureGeneration()) {
     if (!force && !session.requiresBootstrap) return Promise.resolve();
-    if (!force && this.bootstrapRequest?.sessionId === session.id) {
+    if (!force && this.bootstrapRequest?.sessionId === session.id && sameActivityGeneration(this.bootstrapRequest.generation, generation)) {
       return this.bootstrapRequest.promise;
     }
-    const promise = this.client.post("/api/v1/activity/session", this.buildSessionPayload(session)).then(() => {
-      this.sessions.markBootstrapped(session.id);
+    const promise = this.client.post("/api/v1/activity/session", this.buildSessionPayload(session), {
+      retryPolicy: ACTIVITY_RETRY_POLICY
+    }).then(() => {
+      if (this.isCurrentGeneration(generation)) {
+        this.sessions.markBootstrapped(session.id);
+      }
     }).finally(() => {
       if (this.bootstrapRequest?.promise === promise) {
         this.bootstrapRequest = null;
       }
     });
-    this.bootstrapRequest = { sessionId: session.id, promise };
+    this.bootstrapRequest = { sessionId: session.id, generation, promise };
     return promise;
   }
+  captureGeneration() {
+    return {
+      local: this.localGeneration,
+      publicKey: this.client.getPublicKeyEpoch(),
+      session: this.client.getSessionEpoch()
+    };
+  }
+  isCurrentGeneration(generation) {
+    return sameActivityGeneration(generation, this.captureGeneration());
+  }
+  invalidatePendingActivity() {
+    this.localGeneration += 1;
+    this.bootstrapRequest = null;
+  }
+  createSessionCoordinator() {
+    return new AnalyticsSessionCoordinator(pageViewTrackerIdentity(this.client));
+  }
 };
+function sameActivityGeneration(left, right) {
+  return left.local === right.local && left.publicKey === right.publicKey && left.session === right.session;
+}
 function currentPath() {
   if (typeof window !== "undefined") {
     return window.location.pathname;
@@ -849,459 +1312,108 @@ var SupportService = class {
   }
 };
 
-// src/payment-authorization/providers/paystack.ts
-async function openPaystackPopup(options, signal) {
-  if (typeof window === "undefined") {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  let PaystackPop;
-  try {
-    const imported = await import('@paystack/inline-js');
-    PaystackPop = imported.default;
-  } catch {
-    return { success: false, error: "PROVIDER_UNAVAILABLE" };
-  }
-  return new Promise((resolve) => {
-    let settled = false;
-    let providerStarted = false;
-    const resolveOnce = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      if (signal) {
-        signal.removeEventListener("abort", onAbort);
-      }
-      resolve(result);
-    };
-    const onAbort = () => {
-      resolveOnce({
-        success: false,
-        // Once Paystack owns the transaction, cancellation is ambiguous. The
-        // adapter converts this into submitted so Cimplify polling decides.
-        error: providerStarted ? "SUBMISSION_UNKNOWN" : "CANCELLED"
-      });
-    };
-    if (signal?.aborted) {
-      resolveOnce({ success: false, error: "CANCELLED" });
-      return;
-    }
-    if (signal) {
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-    try {
-      const popup = new PaystackPop();
-      popup.newTransaction({
-        key: options.key,
-        email: options.email,
-        amount: options.amount,
-        currency: options.currency,
-        reference: options.reference,
-        accessCode: options.accessCode,
-        onSuccess: (transaction) => {
-          resolveOnce({
-            success: true,
-            reference: transaction.reference ?? options.reference
-          });
-        },
-        onCancel: () => {
-          resolveOnce({ success: false, error: "PAYMENT_CANCELLED" });
-        },
-        onError: (error) => {
-          resolveOnce({
-            success: false,
-            error: error?.message || "PAYMENT_FAILED"
-          });
-        }
-      });
-      providerStarted = true;
-    } catch {
-      resolveOnce({ success: false, error: "POPUP_BLOCKED" });
-    }
-  });
+// src/internal/cross-tab-session.ts
+var CROSS_TAB_SESSION_HUB_KEY = /* @__PURE__ */ Symbol.for("@cimplify/sdk.cross-tab-session-hub");
+var SESSION_SYNC_STORAGE_KEY = "cimplify_session_sync";
+var MAX_RECENT_ENVELOPES = 64;
+function hubHost() {
+  return window;
 }
-var PaystackAuthorizationAdapter = class {
-  constructor(openPopup = openPaystackPopup) {
-    this.openPopup = openPopup;
-    this.provider = "paystack";
-  }
-  async authorize(context) {
-    const result = await this.openPopup(
-      {
-        key: context.action.public_key,
-        email: context.email,
-        accessCode: context.action.client_secret,
-        reference: context.reference || context.action.client_secret,
-        currency: context.currency
-      },
-      context.signal
-    );
-    if (result.success) {
-      return { status: "submitted", reference: result.reference || context.reference };
-    }
-    if (result.error === "SUBMISSION_UNKNOWN") {
-      return { status: "submitted", reference: context.reference };
-    }
-    if (!result.error || result.error === "CANCELLED" || result.error === "PAYMENT_CANCELLED") {
-      return { status: "cancelled" };
-    }
-    if (result.error === "POPUP_BLOCKED") {
-      return {
-        status: "failed",
-        code: "POPUP_BLOCKED",
-        message: "Unable to open the Paystack payment popup. Please allow popups and try again.",
-        recoverable: true
-      };
-    }
-    if (result.error === "PROVIDER_UNAVAILABLE") {
-      return {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: "Paystack is unavailable in this environment.",
-        recoverable: false
-      };
-    }
-    return {
-      status: "failed",
-      code: "PAYMENT_FAILED",
-      message: result.error || "Paystack payment could not be submitted.",
-      recoverable: true
-    };
+function currentHub() {
+  const candidate = hubHost()[CROSS_TAB_SESSION_HUB_KEY];
+  return candidate?.subscribers instanceof Map && candidate.recentEnvelopes instanceof Set && typeof candidate.storageListener === "function" && typeof candidate.dispatch === "function" ? candidate : null;
+}
+function subscriberReference(target) {
+  const WeakReference = globalThis.WeakRef;
+  if (WeakReference) return new WeakReference(target);
+  return { deref: () => target };
+}
+function pruneSubscribers(hub) {
+  for (const [token, reference] of hub.subscribers) {
+    if (!reference.deref()) hub.subscribers.delete(token);
   }
-};
-
-// src/payment-authorization/providers/stripe.ts
-async function loadStripeFromPeer(publicKey, options) {
+}
+function parseSessionSyncPayload(serialized) {
+  if (!serialized) return null;
   try {
-    const imported = await import('@stripe/stripe-js');
-    return imported.loadStripe ? imported.loadStripe(publicKey, options) : null;
+    const payload = JSON.parse(serialized);
+    return (payload.type === "claimed" || payload.type === "cleared") && typeof payload.token === "string" && payload.token.length > 0 && typeof payload.at === "number" && Number.isFinite(payload.at) && (payload.name === void 0 || payload.name === null || typeof payload.name === "string") ? payload : null;
   } catch {
     return null;
   }
 }
-function createStripeModal() {
-  if (typeof document === "undefined" || !document.body) return null;
-  const previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
-  const root = document.createElement("div");
-  root.setAttribute("role", "dialog");
-  root.setAttribute("aria-modal", "true");
-  root.setAttribute("aria-label", "Secure card payment");
-  Object.assign(root.style, {
-    position: "fixed",
-    inset: "0",
-    zIndex: "2147483647",
-    display: "grid",
-    placeItems: "center",
-    padding: "16px",
-    background: "rgba(15, 23, 42, 0.58)"
-  });
-  const form = document.createElement("form");
-  Object.assign(form.style, {
-    width: "min(100%, 480px)",
-    maxHeight: "calc(100vh - 32px)",
-    overflow: "auto",
-    borderRadius: "12px",
-    padding: "24px",
-    background: "#fff",
-    boxShadow: "0 24px 80px rgba(15, 23, 42, 0.32)"
-  });
-  const title = document.createElement("h2");
-  title.textContent = "Complete card payment";
-  Object.assign(title.style, { margin: "0 0 18px", font: "600 18px/1.4 system-ui" });
-  const paymentMount = document.createElement("div");
-  paymentMount.setAttribute("data-cimplify-stripe-payment-element", "");
-  const error = document.createElement("p");
-  error.setAttribute("role", "alert");
-  Object.assign(error.style, {
-    minHeight: "20px",
-    margin: "14px 0 0",
-    color: "#b91c1c",
-    font: "14px/1.4 system-ui"
-  });
-  const actions = document.createElement("div");
-  Object.assign(actions.style, {
-    display: "flex",
-    justifyContent: "flex-end",
-    gap: "10px",
-    marginTop: "18px"
-  });
-  const cancelButton = document.createElement("button");
-  cancelButton.type = "button";
-  cancelButton.textContent = "Cancel";
-  Object.assign(cancelButton.style, {
-    border: "1px solid #cbd5e1",
-    borderRadius: "8px",
-    padding: "10px 16px",
-    background: "#fff",
-    color: "#0f172a",
-    cursor: "pointer"
-  });
-  const submitButton = document.createElement("button");
-  submitButton.type = "submit";
-  submitButton.textContent = "Pay securely";
-  Object.assign(submitButton.style, {
-    border: "0",
-    borderRadius: "8px",
-    padding: "10px 16px",
-    background: "#0f172a",
-    color: "#fff",
-    cursor: "pointer"
-  });
-  actions.append(cancelButton, submitButton);
-  form.append(title, paymentMount, error, actions);
-  root.append(form);
-  document.body.append(root);
-  cancelButton.focus();
-  return { root, form, paymentMount, submitButton, cancelButton, error, previousFocus };
+function sessionSyncEnvelopeKey(payload) {
+  const name = payload.name === void 0 ? ["missing"] : ["present", payload.name];
+  return JSON.stringify([payload.type, payload.token, name, payload.at]);
 }
-function stripeFailure(error) {
-  const message = error?.message || "Stripe could not authorize this payment.";
-  if (error?.code === "payment_intent_authentication_failure" || error?.type === "invalid_request_error") {
-    return {
-      status: "failed",
-      code: "AUTHORIZATION_FAILED",
-      message,
-      recoverable: true
-    };
-  }
-  return { status: "failed", code: "PAYMENT_FAILED", message, recoverable: true };
+function rememberEnvelope(hub, envelope) {
+  if (hub.recentEnvelopes.has(envelope)) return false;
+  hub.recentEnvelopes.add(envelope);
+  if (hub.recentEnvelopes.size > MAX_RECENT_ENVELOPES) {
+    const oldest = hub.recentEnvelopes.values().next().value;
+    if (oldest) hub.recentEnvelopes.delete(oldest);
+  }
+  return true;
 }
-var StripeAuthorizationAdapter = class {
-  constructor(loadStripe = loadStripeFromPeer) {
-    this.loadStripe = loadStripe;
-    this.provider = "stripe";
-  }
-  async authorize(context) {
-    if (typeof window === "undefined" || typeof document === "undefined" || context.signal?.aborted) {
-      return context.signal?.aborted ? { status: "cancelled" } : {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: "Stripe Payment Element is unavailable in this environment.",
-        recoverable: false
-      };
-    }
-    let stripe;
-    try {
-      stripe = await this.loadStripe(
-        context.action.public_key,
-        context.action.provider_account_id ? { stripeAccount: context.action.provider_account_id } : void 0
-      );
-    } catch (error) {
-      return {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: error instanceof Error ? error.message : "Stripe.js could not be loaded.",
-        recoverable: true
-      };
-    }
-    if (context.signal?.aborted) {
-      return { status: "cancelled" };
-    }
-    if (!stripe) {
-      return {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: "Stripe.js could not be loaded.",
-        recoverable: false
-      };
-    }
-    const modal = createStripeModal();
-    if (!modal) {
-      return {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: "Stripe Payment Element could not be mounted.",
-        recoverable: false
-      };
-    }
-    let paymentElement;
-    let elements;
-    try {
-      elements = stripe.elements({ clientSecret: context.action.client_secret });
-      paymentElement = elements.create("payment");
-      paymentElement.mount(modal.paymentMount);
-    } catch {
-      modal.root.remove();
-      modal.previousFocus?.focus();
-      return {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: "Stripe Payment Element could not be initialized.",
-        recoverable: false
-      };
+function createHub() {
+  const hub = {
+    subscribers: /* @__PURE__ */ new Map(),
+    recentEnvelopes: /* @__PURE__ */ new Set()
+  };
+  hub.dispatch = (payload) => {
+    if (!rememberEnvelope(hub, sessionSyncEnvelopeKey(payload))) return;
+    for (const [token, reference] of hub.subscribers) {
+      const subscriber = reference.deref();
+      if (!subscriber) {
+        hub.subscribers.delete(token);
+        continue;
+      }
+      try {
+        subscriber.notify(payload);
+      } catch {
+      }
     }
-    if (context.signal?.aborted) {
-      if (paymentElement.destroy) paymentElement.destroy();
-      else paymentElement.unmount?.();
-      modal.root.remove();
-      modal.previousFocus?.focus();
-      return { status: "cancelled" };
-    }
-    return new Promise((resolve) => {
-      let settled = false;
-      let submitting = false;
-      let confirmationStarted = false;
-      const cleanup = () => {
-        context.signal?.removeEventListener("abort", onAbort);
-        modal.form.removeEventListener("submit", onSubmit);
-        modal.cancelButton.removeEventListener("click", onCancel);
-        if (paymentElement.destroy) paymentElement.destroy();
-        else paymentElement.unmount?.();
-        modal.root.remove();
-        modal.previousFocus?.focus();
-      };
-      const settle = (outcome) => {
-        if (settled) return;
-        settled = true;
-        cleanup();
-        resolve(outcome);
-      };
-      const onAbort = () => {
-        if (confirmationStarted) {
-          settle({ status: "submitted", reference: context.reference });
-          return;
-        }
-        settle({ status: "cancelled" });
-      };
-      const onCancel = () => {
-        if (!confirmationStarted) settle({ status: "cancelled" });
-      };
-      const onSubmit = async (event) => {
-        event.preventDefault();
-        if (submitting || settled) return;
-        submitting = true;
-        modal.submitButton.disabled = true;
-        modal.error.textContent = "";
-        try {
-          const validation = elements.submit ? await elements.submit() : {};
-          if (validation.error) {
-            modal.error.textContent = validation.error.message || "Check your payment details.";
-            submitting = false;
-            modal.submitButton.disabled = false;
-            return;
-          }
-          if (settled || context.signal?.aborted) {
-            settle({ status: "cancelled" });
-            return;
-          }
-          confirmationStarted = true;
-          modal.cancelButton.disabled = true;
-          const confirmation = await stripe.confirmPayment({
-            elements,
-            confirmParams: { return_url: context.returnUrl || window.location.href },
-            redirect: "if_required"
-          });
-          if (settled) return;
-          if (confirmation.error) {
-            settle(stripeFailure(confirmation.error));
-            return;
-          }
-          settle({
-            status: "submitted",
-            reference: confirmation.paymentIntent?.id || context.reference
-          });
-        } catch (error) {
-          if (confirmationStarted) {
-            settle({ status: "submitted", reference: context.reference });
-            return;
-          }
-          settle(
-            stripeFailure({
-              message: error instanceof Error ? error.message : "Stripe confirmation failed."
-            })
-          );
-        }
-      };
-      modal.form.addEventListener("submit", onSubmit);
-      modal.cancelButton.addEventListener("click", onCancel);
-      context.signal?.addEventListener("abort", onAbort, { once: true });
-      paymentElement.on?.("escape", onCancel);
-      paymentElement.on?.("loaderror", (event) => {
-        if (confirmationStarted) return;
-        settle({
-          status: "failed",
-          code: "PROVIDER_UNAVAILABLE",
-          message: event?.error?.message || "Stripe Payment Element failed to load.",
-          recoverable: true
-        });
-      });
-    });
-  }
-};
-
-// src/payment-authorization/registry.ts
-function normalizeProvider(provider) {
-  return typeof provider === "string" ? provider.trim().toLowerCase() : "";
+  };
+  hub.storageListener = (event) => {
+    const storageEvent = event;
+    if (storageEvent.key !== SESSION_SYNC_STORAGE_KEY) return;
+    const payload = parseSessionSyncPayload(storageEvent.newValue);
+    if (payload) hub.dispatch(payload);
+  };
+  window.addEventListener("storage", hub.storageListener);
+  hubHost()[CROSS_TAB_SESSION_HUB_KEY] = hub;
+  return hub;
 }
-var PaymentAuthorizationAdapterRegistry = class {
-  constructor(adapters = []) {
-    this.adapters = /* @__PURE__ */ new Map();
-    for (const adapter of adapters) {
-      this.register(adapter);
-    }
-  }
-  register(adapter) {
-    const provider = normalizeProvider(adapter.provider);
-    if (!provider) {
-      throw new TypeError("Payment authorization adapter provider cannot be empty.");
-    }
-    this.adapters.set(provider, adapter);
-    return this;
-  }
-  unregister(provider) {
-    return this.adapters.delete(normalizeProvider(provider));
-  }
-  get(provider) {
-    return this.adapters.get(normalizeProvider(provider));
-  }
-  supports(provider) {
-    return this.adapters.has(normalizeProvider(provider));
-  }
-  providers() {
-    return [...this.adapters.keys()];
-  }
-  async authorize(action, options) {
-    const provider = normalizeProvider(action.provider);
-    if (!provider) {
-      return {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: "Card authorization response did not identify a payment provider.",
-        recoverable: false
-      };
-    }
-    const adapter = this.adapters.get(provider);
-    if (!adapter) {
-      return {
-        status: "failed",
-        code: "PROVIDER_UNAVAILABLE",
-        message: `Card authorization provider '${provider}' is not supported by this SDK client.`,
-        recoverable: false
-      };
-    }
-    try {
-      const normalizedAction = action.provider === provider ? action : { ...action, provider };
-      return await adapter.authorize({ ...options, action: normalizedAction });
-    } catch (error) {
-      return {
-        status: "failed",
-        code: "PAYMENT_FAILED",
-        message: error instanceof Error ? error.message : `Card authorization provider '${provider}' failed unexpectedly.`,
-        recoverable: true
-      };
-    }
+function publishLocalSessionSync(payload) {
+  if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
+  (currentHub() ?? createHub()).dispatch(payload);
+}
+function subscribeCrossTabSession(notify) {
+  if (typeof window === "undefined" || typeof window.addEventListener !== "function") {
+    return () => {
+    };
   }
-};
-function createDefaultPaymentAuthorizationAdapterRegistry() {
-  return new PaymentAuthorizationAdapterRegistry([
-    new PaystackAuthorizationAdapter(),
-    new StripeAuthorizationAdapter()
-  ]);
+  const hub = currentHub() ?? createHub();
+  pruneSubscribers(hub);
+  const token = /* @__PURE__ */ Symbol("cross-tab-session-subscriber");
+  const subscriber = { notify };
+  hub.subscribers.set(token, subscriberReference(subscriber));
+  let unsubscribed = false;
+  return () => {
+    if (unsubscribed) return;
+    unsubscribed = true;
+    subscriber.notify = () => {
+    };
+    hub.subscribers.delete(token);
+    pruneSubscribers(hub);
+    if (hub.subscribers.size !== 0) return;
+    window.removeEventListener("storage", hub.storageListener);
+    if (currentHub() === hub) delete hubHost()[CROSS_TAB_SESSION_HUB_KEY];
+  };
 }
 
 // src/client.ts
 var SESSION_TOKEN_STORAGE_KEY = "cimplify_session_token";
-var SESSION_SYNC_STORAGE_KEY = "cimplify_session_sync";
 var ORDER_TOKEN_PREFIX = "cimplify_ot_";
 var SESSION_TOKEN_HEADER = "x-session-token";
 var LOCATION_ID_QUERY_PARAMETER = "location_id";
@@ -1309,8 +1421,37 @@ var ORDER_TOKEN_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 5e3;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY_MS = 1e3;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+var MAX_RETRY_AFTER_MS = 3e4;
+function sleep(ms, signal) {
+  if (signal?.aborted) {
+    return Promise.reject(new CimplifyError(ErrorCode.CANCELLED, "Request was cancelled.", true));
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new CimplifyError(ErrorCode.CANCELLED, "Request was cancelled.", true));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function parseRetryAfterMs(value) {
+  if (!value) return null;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS);
+  }
+  const retryAt = Date.parse(value);
+  if (!Number.isFinite(retryAt)) return null;
+  return Math.min(Math.max(0, retryAt - Date.now()), MAX_RETRY_AFTER_MS);
+}
+function withPositiveJitter(delayMs, jitterRatio = 0) {
+  const boundedRatio = Math.min(Math.max(jitterRatio, 0), 1);
+  if (boundedRatio === 0 || delayMs === 0) return delayMs;
+  return Math.round(delayMs + delayMs * boundedRatio * Math.random());
 }
 function nextInit(cacheOptions) {
   if (!cacheOptions) return {};
@@ -1424,6 +1565,9 @@ var CimplifyClient = class {
     this.businessId = null;
     this.businessIdResolvePromise = null;
     this.publicKeyEpoch = 0;
+    this.stopCrossTabSessionWatch = null;
+    this.latestSessionSyncAt = Number.NEGATIVE_INFINITY;
+    this.latestSessionSyncOrderKey = null;
     this.inflightRequests = /* @__PURE__ */ new Map();
     /**
      * App-level event channel. Subscribe to surface mutation rollbacks, outbox
@@ -1445,7 +1589,11 @@ var CimplifyClient = class {
     this.authorizationAdapters = config.authorizationAdapterRegistry ?? createDefaultPaymentAuthorizationAdapterRegistry();
     this.fetchImpl = (config.fetch ?? globalThis.fetch).bind(globalThis);
     this.sessionToken = this.loadSessionToken() ?? this.mintSessionToken();
-    this.watchCrossTabSession();
+    const persistedSessionSync = this.loadSessionSyncPayload();
+    if (persistedSessionSync) this.observeSessionSync(persistedSessionSync);
+    this.stopCrossTabSessionWatch = subscribeCrossTabSession((payload) => {
+      this.applyCrossTabSession(payload);
+    });
     if (!this.publicKey && !config.suppressPublicKeyWarning) {
       console.warn(
         '[Cimplify] No public key found. Set NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY in your environment, or pass { publicKey: "cpk_..." } to createCimplifyClient().'
@@ -1472,6 +1620,12 @@ var CimplifyClient = class {
     this.stopPageViewTracking?.();
     this.stopPageViewTracking = null;
   }
+  /** Release window-level subscriptions and automatic tracking owned by this client. */
+  destroy() {
+    this.stopTrackingPageViews();
+    this.stopCrossTabSessionWatch?.();
+    this.stopCrossTabSessionWatch = null;
+  }
   getAccessToken() {
     return this.accessToken;
   }
@@ -1499,7 +1653,7 @@ var CimplifyClient = class {
     this.hooks.onSessionChange?.({
       previousToken: previous,
       newToken: token,
-      source: "manual"
+      source: SESSION_CHANGE_SOURCE.MANUAL
     });
     this.events.emit(AUTH_TOKEN_CHANGED, { token });
   }
@@ -1543,7 +1697,7 @@ var CimplifyClient = class {
     this.hooks.onSessionChange?.({
       previousToken: previous,
       newToken: null,
-      source: "clear"
+      source: SESSION_CHANGE_SOURCE.CLEAR
     });
     this.events.emit(AUTH_TOKEN_CHANGED, { token: null });
     this.events.emit(SESSION_CLEARED, {});
@@ -1565,9 +1719,10 @@ var CimplifyClient = class {
   hasClaimedSessionAuthority() {
     if (!this.sessionToken) return false;
     try {
-      const raw = this.safeStorage()?.getItem(SESSION_SYNC_STORAGE_KEY);
-      if (!raw) return false;
-      const payload = JSON.parse(raw);
+      const payload = parseSessionSyncPayload(
+        this.safeStorage()?.getItem(SESSION_SYNC_STORAGE_KEY) ?? null
+      );
+      if (!payload) return false;
       return payload.type === "claimed" && payload.token === this.sessionToken;
     } catch {
       return false;
@@ -1582,41 +1737,49 @@ var CimplifyClient = class {
     });
   }
   broadcastSessionSync(payload) {
+    const envelope = {
+      ...payload,
+      at: this.nextSessionSyncTimestamp()
+    };
     try {
-      this.safeStorage()?.setItem(
-        SESSION_SYNC_STORAGE_KEY,
-        JSON.stringify({ ...payload, at: Date.now() })
-      );
+      this.safeStorage()?.setItem(SESSION_SYNC_STORAGE_KEY, JSON.stringify(envelope));
     } catch {
     }
+    publishLocalSessionSync(envelope);
   }
-  watchCrossTabSession() {
-    if (typeof window === "undefined" || typeof window.addEventListener !== "function") return;
-    window.addEventListener("storage", (event) => {
-      if (event.key !== SESSION_SYNC_STORAGE_KEY || !event.newValue) return;
-      let payload;
-      try {
-        payload = JSON.parse(event.newValue);
-      } catch {
-        return;
-      }
-      if (!payload?.token || payload.token === this.sessionToken) return;
-      if (payload.type === "claimed") {
-        this.sessionToken = payload.token;
-        this.sessionEpoch++;
-        this.events.emit(SESSION_CLAIMED, {
-          sessionToken: payload.token,
-          threadId: null,
-          customerName: payload.name ?? ""
-        });
-      } else if (payload.type === "cleared") {
-        this.accessToken = null;
-        this.sessionToken = payload.token;
-        this.sessionEpoch++;
-        this.events.emit(AUTH_TOKEN_CHANGED, { token: null });
-        this.events.emit(SESSION_CLEARED, {});
-      }
-    });
+  applyCrossTabSession(payload) {
+    if (!this.observeSessionSync(payload)) return;
+    if (payload.token === this.sessionToken) return;
+    if (payload.type === "claimed") {
+      this.sessionToken = payload.token;
+      this.sessionEpoch++;
+      this.events.emit(SESSION_CLAIMED, {
+        sessionToken: payload.token,
+        threadId: null,
+        customerName: payload.name ?? ""
+      });
+    } else {
+      this.accessToken = null;
+      this._activity?.resetSession();
+      this.sessionToken = payload.token;
+      this.sessionEpoch++;
+      this.events.emit(AUTH_TOKEN_CHANGED, { token: null });
+      this.events.emit(SESSION_CLEARED, {});
+    }
+  }
+  observeSessionSync(payload) {
+    if (payload.at < this.latestSessionSyncAt) return false;
+    const envelope = sessionSyncEnvelopeKey(payload);
+    if (payload.at === this.latestSessionSyncAt && this.latestSessionSyncOrderKey !== null && envelope <= this.latestSessionSyncOrderKey) {
+      return false;
+    }
+    this.latestSessionSyncAt = payload.at;
+    this.latestSessionSyncOrderKey = envelope;
+    return true;
+  }
+  nextSessionSyncTimestamp() {
+    const now = Date.now();
+    return Number.isFinite(this.latestSessionSyncAt) ? Math.max(now, this.latestSessionSyncAt + 1) : now;
   }
   setOrderToken(orderId, token) {
     try {
@@ -1680,17 +1843,24 @@ var CimplifyClient = class {
   setPublicKey(publicKey) {
     const normalized = publicKey.trim();
     if (normalized === this.publicKey) return;
+    const restartPageViewTracking = this.stopPageViewTracking !== null;
+    if (restartPageViewTracking) {
+      this.stopTrackingPageViews();
+    }
     this.publicKey = normalized;
     this.publicKeyEpoch += 1;
     this.businessId = null;
     this.businessIdResolvePromise = null;
     this.inflightRequests.clear();
-    this._activity?.resetSession();
+    this._activity?.resetForStorefrontIdentityChange();
     delete this.context.location_id;
     if (this.accessToken !== null) {
       this.setAccessToken(null);
     }
     this.events.emit(SESSION_CLEARED, {});
+    if (restartPageViewTracking) {
+      this.stopPageViewTracking = this.activity.autoTrackPageViews();
+    }
   }
   getBusinessId() {
     return this.businessId;
@@ -1731,8 +1901,8 @@ var CimplifyClient = class {
       }
     }
   }
-  async authedFetch(url, options, timeoutMs) {
-    return this.resilientFetch(url, options, timeoutMs);
+  async authedFetch(url, options, timeoutMs, retryPolicy, signal) {
+    return this.resilientFetch(url, options, timeoutMs, retryPolicy, signal);
   }
   // Storage guards: even the `window.localStorage` property access throws in
   // some sandboxed iframes and strict private-browsing modes. These run in the
@@ -1754,6 +1924,13 @@ var CimplifyClient = class {
       return null;
     }
   }
+  loadSessionSyncPayload() {
+    try {
+      return parseSessionSyncPayload(this.safeStorage()?.getItem(SESSION_SYNC_STORAGE_KEY) ?? null);
+    } catch {
+      return null;
+    }
+  }
   /**
    * Mint the session token client-side so the very first request already
    * carries it. Without this, parallel first-load requests each get a
@@ -1809,7 +1986,7 @@ var CimplifyClient = class {
     }
     return headers;
   }
-  async resilientFetch(url, options, timeoutMs) {
+  async resilientFetch(url, options, timeoutMs, retryPolicy, signal) {
     const method = options.method || "GET";
     const path = url.replace(this.baseUrl, "").replace(this.linkApiUrl, "");
     const startTime = Date.now();
@@ -1823,15 +2000,31 @@ var CimplifyClient = class {
     };
     this.hooks.onRequestStart?.(context);
     let lastError;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+    const configuredMaxRetries = Math.max(0, Math.floor(this.maxRetries));
+    const maxRetries = Math.min(
+      configuredMaxRetries,
+      Math.max(0, Math.floor(retryPolicy?.maxRetries ?? configuredMaxRetries))
+    );
+    const jitterRatio = retryPolicy?.jitterRatio ?? 0;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
+        if (signal?.aborted) {
+          throw new CimplifyError(ErrorCode.CANCELLED, "Request was cancelled.", true);
+        }
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs ?? this.timeout);
-        const response = await this.fetchImpl(url, {
-          ...options,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
+        const onAbort = () => controller.abort();
+        signal?.addEventListener("abort", onAbort, { once: true });
+        let response;
+        try {
+          response = await this.fetchImpl(url, {
+            ...options,
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeoutId);
+          signal?.removeEventListener("abort", onAbort);
+        }
         this.captureSessionToken(response);
         if (response.ok) {
           this.hooks.onRequestSuccess?.({
@@ -1841,17 +2034,19 @@ var CimplifyClient = class {
           });
           return response;
         }
-        if ((response.status === 429 || response.status === 503) && attempt < this.maxRetries) {
+        if ((response.status === 429 || response.status === 503) && attempt < maxRetries) {
           retryCount++;
-          const retryAfter = response.headers.get("Retry-After");
-          const delay = retryAfter ? Math.min(parseInt(retryAfter, 10) * 1e3, 3e4) || this.retryDelay * Math.pow(2, attempt) : this.retryDelay * Math.pow(2, attempt);
+          const retryAfterMs = parseRetryAfterMs(response.headers.get("Retry-After"));
+          const retryBaseMs = retryAfterMs ?? this.retryDelay * Math.pow(2, attempt);
+          const jitteredDelayMs = withPositiveJitter(retryBaseMs, jitterRatio);
+          const delay = retryAfterMs === null ? jitteredDelayMs : Math.min(jitteredDelayMs, MAX_RETRY_AFTER_MS);
           this.hooks.onRetry?.({
             ...context,
             attempt: retryCount,
             delayMs: delay,
             error: new Error(`Retryable: ${response.status}`)
           });
-          await sleep(delay);
+          await sleep(delay, signal);
           continue;
         }
         if (response.status >= 400 && response.status < 500) {
@@ -1869,22 +2064,22 @@ var CimplifyClient = class {
           });
           return response;
         }
-        if (response.status >= 500 && attempt < this.maxRetries) {
+        if (response.status >= 500 && attempt < maxRetries) {
           retryCount++;
-          const delay = this.retryDelay * Math.pow(2, attempt);
+          const delay = withPositiveJitter(this.retryDelay * Math.pow(2, attempt), jitterRatio);
           this.hooks.onRetry?.({
             ...context,
             attempt: retryCount,
             delayMs: delay,
             error: new Error(`Server error: ${response.status}`)
           });
-          await sleep(delay);
+          await sleep(delay, signal);
           continue;
         }
         this.hooks.onRequestError?.({
           ...context,
           error: new CimplifyError(
-            "SERVER_ERROR",
+            ErrorCode.SERVER_ERROR,
             `Server error ${response.status} after ${retryCount} retries`,
             false
           ),
@@ -1896,9 +2091,12 @@ var CimplifyClient = class {
         return response;
       } catch (error) {
         lastError = error;
+        if (signal?.aborted) {
+          throw new CimplifyError(ErrorCode.CANCELLED, "Request was cancelled.", true);
+        }
         const networkError = toNetworkError(error, this.isTestMode());
         const errorRetryable = isRetryable(error);
-        if (!errorRetryable || attempt >= this.maxRetries) {
+        if (!errorRetryable || attempt >= maxRetries) {
           this.hooks.onRequestError?.({
             ...context,
             error: networkError,
@@ -1909,14 +2107,14 @@ var CimplifyClient = class {
           throw networkError;
         }
         retryCount++;
-        const delay = this.retryDelay * Math.pow(2, attempt);
+        const delay = withPositiveJitter(this.retryDelay * Math.pow(2, attempt), jitterRatio);
         this.hooks.onRetry?.({
           ...context,
           attempt: retryCount,
           delayMs: delay,
           error: networkError
         });
-        await sleep(delay);
+        await sleep(delay, signal);
       }
     }
     const finalError = toNetworkError(lastError, this.isTestMode());
@@ -1953,16 +2151,24 @@ var CimplifyClient = class {
     return request;
   }
   async get(path, opts) {
-    const key = this.getDedupeKey("get", path, opts?.cacheOptions);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.authedFetch(this.buildUrl(this.baseUrl, path), {
-        method: "GET",
-        credentials: this.credentials,
-        headers: this.getHeaders(),
-        ...nextInit(opts?.cacheOptions)
-      });
+    const request = async () => {
+      const response = await this.authedFetch(
+        this.buildUrl(this.baseUrl, path),
+        {
+          method: "GET",
+          credentials: this.credentials,
+          headers: this.getHeaders(),
+          ...nextInit(opts?.cacheOptions)
+        },
+        opts?.timeoutMs,
+        opts?.retryPolicy,
+        opts?.signal
+      );
       return this.handleRestResponse(response);
-    });
+    };
+    if (opts?.signal) return request();
+    const key = this.getDedupeKey("get", path, opts?.cacheOptions);
+    return this.deduplicatedRequest(key, request);
   }
   async post(path, body, opts) {
     const response = await this.authedFetch(
@@ -1973,7 +2179,9 @@ var CimplifyClient = class {
         headers: mergeOptionHeaders(this.getHeaders(), opts),
         body: body ? JSON.stringify(body) : void 0
       },
-      opts?.timeoutMs
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
     );
     return this.handleRestResponse(response);
   }
@@ -1986,7 +2194,9 @@ var CimplifyClient = class {
         headers: mergeOptionHeaders(this.getHeaders(), opts),
         body: body ? JSON.stringify(body) : void 0
       },
-      opts?.timeoutMs
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
     );
     return this.handleRestResponse(response);
   }
@@ -1998,21 +2208,31 @@ var CimplifyClient = class {
         credentials: this.credentials,
         headers: mergeOptionHeaders(this.getHeaders(), opts)
       },
-      opts?.timeoutMs
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
     );
     return this.handleRestResponse(response);
   }
   async linkGet(path, opts) {
-    const key = this.getDedupeKey("linkGet", path, opts?.cacheOptions);
-    return this.deduplicatedRequest(key, async () => {
-      const response = await this.authedFetch(`${this.linkApiUrl}${path}`, {
-        method: "GET",
-        credentials: this.credentials,
-        headers: this.getHeaders(),
-        ...nextInit(opts?.cacheOptions)
-      });
+    const request = async () => {
+      const response = await this.authedFetch(
+        `${this.linkApiUrl}${path}`,
+        {
+          method: "GET",
+          credentials: this.credentials,
+          headers: this.getHeaders(),
+          ...nextInit(opts?.cacheOptions)
+        },
+        opts?.timeoutMs,
+        opts?.retryPolicy,
+        opts?.signal
+      );
       return this.handleRestResponse(response);
-    });
+    };
+    if (opts?.signal) return request();
+    const key = this.getDedupeKey("linkGet", path, opts?.cacheOptions);
+    return this.deduplicatedRequest(key, request);
   }
   async linkPost(path, body, opts) {
     const response = await this.authedFetch(
@@ -2023,25 +2243,33 @@ var CimplifyClient = class {
         headers: mergeOptionHeaders(this.getHeaders(), opts),
         body: body ? JSON.stringify(body) : void 0
       },
-      opts?.timeoutMs
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
     );
     return this.handleRestResponse(response);
   }
   async linkDelete(path, opts) {
-    const response = await this.authedFetch(`${this.linkApiUrl}${path}`, {
-      method: "DELETE",
-      credentials: this.credentials,
-      headers: mergeOptionHeaders(this.getHeaders(), opts)
-    });
+    const response = await this.authedFetch(
+      `${this.linkApiUrl}${path}`,
+      {
+        method: "DELETE",
+        credentials: this.credentials,
+        headers: mergeOptionHeaders(this.getHeaders(), opts)
+      },
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
+    );
     return this.handleRestResponse(response);
   }
   async handleRestResponse(response) {
     const json = await response.json();
     if (!response.ok) {
-      const errorCode = typeof json.error === "object" && json.error?.error_code || typeof json.error === "object" && json.error?.code || "API_ERROR";
+      const errorCode = typeof json.error === "object" && json.error?.error_code || typeof json.error === "object" && json.error?.code || ErrorCode.API_ERROR;
       const errorMessage = typeof json.error === "object" && json.error?.error_message || typeof json.error === "object" && json.error?.message || typeof json.error === "string" && json.error || typeof json.message === "string" && json.message || "An error occurred";
       const retryable = typeof json.error === "object" && typeof json.error?.retryable === "boolean" ? json.error.retryable : false;
-      if (errorCode === "IDEMPOTENCY_MISMATCH") {
+      if (errorCode === ErrorCode.IDEMPOTENCY_MISMATCH) {
         const originalCreatedAt = typeof json.error === "object" && json.error?.original_created_at || "";
         throw new IdempotencyMismatchError(errorMessage, originalCreatedAt);
       }
@@ -2058,7 +2286,7 @@ var CimplifyClient = class {
     if (json?.success === false || json?.error?.code || json?.error?.message) {
       const error = enrichError(
         new CimplifyError(
-          json.error?.code || "API_ERROR",
+          json.error?.code || ErrorCode.API_ERROR,
           json.error?.message || "An error occurred",
           json.error?.retryable || false
         ),
@@ -2089,6 +2317,12 @@ var CimplifyClient = class {
     }
     return this._checkout;
   }
+  get purchaseIntents() {
+    if (!this._purchaseIntents) {
+      this._purchaseIntents = new PurchaseIntentService(this);
+    }
+    return this._purchaseIntents;
+  }
   get orders() {
     if (!this._orders) {
       this._orders = new OrderQueries(this);
@@ -2199,4 +2433,4 @@ function createCimplifyClient(config = {}) {
   return new CimplifyClient(config);
 }
 
-export { AUTH_TOKEN_CHANGED, ActivityService, CimplifyClient, DeliveryService, MUTATION_ERROR, PaymentAuthorizationAdapterRegistry, PaystackAuthorizationAdapter, PlacesService, SESSION_CLAIMED, SESSION_CLEARED, StoreCreditQueries, StripeAuthorizationAdapter, SubscriptionService, SupportService, UploadService, chatRealtimeUpdateFromWire, createCimplifyClient, createDefaultPaymentAuthorizationAdapterRegistry };
+export { AUTH_TOKEN_CHANGED, ActivityService, CimplifyClient, DeliveryService, HostedPurchaseIntentService, MUTATION_ERROR, PURCHASE_INTENT_ROUTE, PlacesService, PurchaseIntentResolver, PurchaseIntentService, SESSION_CHANGE_SOURCE, SESSION_CLAIMED, SESSION_CLEARED, StoreCreditQueries, SubscriptionService, SupportService, UploadService, chatRealtimeUpdateFromWire, createCimplifyClient };